001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *     http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.commons.jxpath.ri.model.beans;
018    
019    import org.apache.commons.jxpath.AbstractFactory;
020    import org.apache.commons.jxpath.JXPathAbstractFactoryException;
021    import org.apache.commons.jxpath.JXPathContext;
022    import org.apache.commons.jxpath.JXPathInvalidAccessException;
023    import org.apache.commons.jxpath.ri.QName;
024    import org.apache.commons.jxpath.ri.model.NodePointer;
025    
026    /**
027     * @author Dmitri Plotnikov
028     * @version $Revision: 652884 $ $Date: 2008-05-02 15:02:00 -0500 (Fri, 02 May 2008) $
029     */
030    public class NullPropertyPointer extends PropertyPointer {
031    
032        private String propertyName = "*";
033        private boolean byNameAttribute = false;
034    
035        private static final long serialVersionUID = 5296593071854982754L;
036    
037        /**
038         * Create a new NullPropertyPointer.
039         * @param parent pointer
040         */
041        public NullPropertyPointer(NodePointer parent) {
042            super(parent);
043        }
044    
045        public QName getName() {
046            return new QName(propertyName);
047        }
048    
049        public void setPropertyIndex(int index) {
050        }
051    
052        public int getLength() {
053            return 0;
054        }
055    
056        public Object getBaseValue() {
057            return null;
058        }
059    
060        public Object getImmediateNode() {
061            return null;
062        }
063    
064        public boolean isLeaf() {
065            return true;
066        }
067    
068        public NodePointer getValuePointer() {
069            return new NullPointer(this,  new QName(getPropertyName()));
070        }
071    
072        protected boolean isActualProperty() {
073            return false;
074        }
075    
076        public boolean isActual() {
077            return false;
078        }
079    
080        public boolean isContainer() {
081            return true;
082        }
083    
084        public void setValue(Object value) {
085            if (parent == null || parent.isContainer()) {
086                throw new JXPathInvalidAccessException(
087                    "Cannot set property "
088                        + asPath()
089                        + ", the target object is null");
090            }
091            if (parent instanceof PropertyOwnerPointer
092                    && ((PropertyOwnerPointer) parent)
093                            .isDynamicPropertyDeclarationSupported()) {
094                // If the parent property owner can create
095                // a property automatically - let it do so
096                PropertyPointer propertyPointer =
097                    ((PropertyOwnerPointer) parent).getPropertyPointer();
098                propertyPointer.setPropertyName(propertyName);
099                propertyPointer.setValue(value);
100            }
101            else {
102                throw new JXPathInvalidAccessException(
103                    "Cannot set property "
104                        + asPath()
105                        + ", path does not match a changeable location");
106            }
107        }
108    
109        public NodePointer createPath(JXPathContext context) {
110            NodePointer newParent = parent.createPath(context);
111            if (isAttribute()) {
112                return newParent.createAttribute(context, getName());
113            }
114            if (parent instanceof NullPointer && parent.equals(newParent)) {
115                throw createBadFactoryException(context.getFactory());
116            }
117            // Consider these two use cases:
118            // 1. The parent pointer of NullPropertyPointer is
119            //    a PropertyOwnerPointer other than NullPointer. When we call
120            //    createPath on it, it most likely returns itself. We then
121            //    take a PropertyPointer from it and get the PropertyPointer
122            //    to expand the collection for the corresponding property.
123            //
124            // 2. The parent pointer of NullPropertyPointer is a NullPointer.
125            //    When we call createPath, it may return a PropertyOwnerPointer
126            //    or it may return anything else, like a DOMNodePointer.
127            //    In the former case we need to do exactly what we did in use
128            //    case 1.  In the latter case, we simply request that the
129            //    non-property pointer expand the collection by itself.
130            if (newParent instanceof PropertyOwnerPointer) {
131                PropertyOwnerPointer pop = (PropertyOwnerPointer) newParent;
132                newParent = pop.getPropertyPointer();
133            }
134            return newParent.createChild(context, getName(), getIndex());
135        }
136    
137        public NodePointer createPath(JXPathContext context, Object value) {
138            NodePointer newParent = parent.createPath(context);
139            if (isAttribute()) {
140                NodePointer pointer = newParent.createAttribute(context, getName());
141                pointer.setValue(value);
142                return pointer;
143            }
144            if (parent instanceof NullPointer && parent.equals(newParent)) {
145                throw createBadFactoryException(context.getFactory());
146            }
147            if (newParent instanceof PropertyOwnerPointer) {
148                PropertyOwnerPointer pop = (PropertyOwnerPointer) newParent;
149                newParent = pop.getPropertyPointer();
150            }
151            return newParent.createChild(context, getName(), index, value);
152        }
153    
154        public NodePointer createChild(JXPathContext context, QName name, int index) {
155            return createPath(context).createChild(context, name, index);
156        }
157    
158        public NodePointer createChild(JXPathContext context, QName name,
159                int index, Object value) {
160            return createPath(context).createChild(context, name, index, value);
161        }
162    
163        public String getPropertyName() {
164            return propertyName;
165        }
166    
167        public void setPropertyName(String propertyName) {
168            this.propertyName = propertyName;
169        }
170    
171        /**
172         * Set the name attribute.
173         * @param attributeValue value to set
174         */
175        public void setNameAttributeValue(String attributeValue) {
176            this.propertyName = attributeValue;
177            byNameAttribute = true;
178        }
179    
180        public boolean isCollection() {
181            return getIndex() != WHOLE_COLLECTION;
182        }
183    
184        public int getPropertyCount() {
185            return 0;
186        }
187    
188        public String[] getPropertyNames() {
189            return new String[0];
190        }
191    
192        public String asPath() {
193            if (!byNameAttribute) {
194                return super.asPath();
195            }
196            StringBuffer buffer = new StringBuffer();
197            buffer.append(getImmediateParentPointer().asPath());
198            buffer.append("[@name='");
199            buffer.append(escape(getPropertyName()));
200            buffer.append("']");
201            if (index != WHOLE_COLLECTION) {
202                buffer.append('[').append(index + 1).append(']');
203            }
204            return buffer.toString();
205        }
206    
207        /**
208         * Create a "bad factory" JXPathAbstractFactoryException for the specified AbstractFactory.
209         * @param factory AbstractFactory
210         * @return JXPathAbstractFactoryException
211         */
212        private JXPathAbstractFactoryException createBadFactoryException(AbstractFactory factory) {
213            return new JXPathAbstractFactoryException("Factory " + factory
214                    + " reported success creating object for path: " + asPath()
215                    + " but object was null.  Terminating to avoid stack recursion.");
216        }
217    }