View Javadoc

1   /*
2    * Copyright 1999-2004 The Apache Software Foundation
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.commons.jxpath.ri.model.container;
17  
18  import java.util.Locale;
19  
20  import org.apache.commons.jxpath.Container;
21  import org.apache.commons.jxpath.ri.QName;
22  import org.apache.commons.jxpath.ri.compiler.NodeTest;
23  import org.apache.commons.jxpath.ri.model.NodeIterator;
24  import org.apache.commons.jxpath.ri.model.NodePointer;
25  import org.apache.commons.jxpath.util.ValueUtils;
26  
27  /***
28   * Transparent pointer to a Container. The getValue() method
29   * returns the contents of the container, rather than the container
30   * itself.
31   *
32   * @author Dmitri Plotnikov
33   * @version $Revision: 1.13 $ $Date: 2004/04/04 22:06:36 $
34   */
35  public class ContainerPointer extends NodePointer {
36      private Container container;
37      private NodePointer valuePointer;
38  
39      public ContainerPointer(Container container, Locale locale) {
40          super(null, locale);
41          this.container = container;
42      }
43  
44      public ContainerPointer(NodePointer parent, Container container) {
45          super(parent);
46          this.container = container;
47      }
48  
49      /***
50       * This type of node is auxiliary.
51       */
52      public boolean isContainer() {
53          return true;
54      }
55  
56      public QName getName() {
57          return null;
58      }
59  
60      public Object getBaseValue() {
61          return container;
62      }
63      
64      public boolean isCollection() {
65          Object value = getBaseValue();
66          return value != null && ValueUtils.isCollection(value);
67      }
68      
69      public int getLength() {
70          Object value = getBaseValue();
71          if (value == null) {
72              return 1;
73          }
74          return ValueUtils.getLength(value);
75      }    
76  
77      public boolean isLeaf() {
78          return getValuePointer().isLeaf();
79      }    
80  
81      public Object getImmediateNode() {
82          Object value = getBaseValue();
83          if (index != WHOLE_COLLECTION) {
84              if (index >= 0 && index < getLength()) {
85                  return ValueUtils.getValue(value, index);
86              }
87              else {
88                  return null;
89              }
90          }
91          else {
92              return ValueUtils.getValue(value);
93          }
94      }
95  
96      public void setValue(Object value) {
97          // TODO: what if this is a collection?
98          container.setValue(value);
99      }
100 
101     public NodePointer getImmediateValuePointer() {
102         if (valuePointer == null) {
103             Object value = getImmediateNode();
104             valuePointer =
105                 NodePointer.newChildNodePointer(this, getName(), value);
106         }
107         return valuePointer;
108     }
109 
110     public int hashCode() {
111         return System.identityHashCode(container) + index;
112     }
113 
114     public boolean equals(Object object) {
115         if (object == this) {
116             return true;
117         }
118 
119         if (!(object instanceof ContainerPointer)) {
120             return false;
121         }
122 
123         ContainerPointer other = (ContainerPointer) object;
124         return container == other.container && index == other.index;
125     }
126 
127     public NodeIterator childIterator(
128         NodeTest test,
129         boolean reverse,
130         NodePointer startWith) 
131     {
132         return getValuePointer().childIterator(test, reverse, startWith);
133     }
134 
135     public NodeIterator attributeIterator(QName name) {
136         return getValuePointer().attributeIterator(name);
137     }
138 
139     public NodeIterator namespaceIterator() {
140         return getValuePointer().namespaceIterator();
141     }
142 
143     public NodePointer namespacePointer(String namespace) {
144         return getValuePointer().namespacePointer(namespace);
145     }
146 
147     public boolean testNode(NodeTest nodeTest) {
148         return getValuePointer().testNode(nodeTest);
149     }
150 
151     public int compareChildNodePointers(
152         NodePointer pointer1,
153         NodePointer pointer2) 
154     {
155         return pointer1.getIndex() - pointer2.getIndex();
156     }
157     
158     public String getNamespaceURI(String prefix) {
159         return getValuePointer().getNamespaceURI(prefix);
160     }
161     
162     public String asPath() {
163         if (parent != null) {
164             return parent.asPath();
165         }
166         return "/";
167     }
168  }