Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.jxpath.ri.model.dynamic; import java.util.Arrays; import java.util.Map; import org.apache.commons.jxpath.AbstractFactory; import org.apache.commons.jxpath.DynamicPropertyHandler; import org.apache.commons.jxpath.JXPathAbstractFactoryException; import org.apache.commons.jxpath.JXPathContext; import org.apache.commons.jxpath.JXPathInvalidAccessException; import org.apache.commons.jxpath.ri.model.NodePointer; import org.apache.commons.jxpath.ri.model.beans.PropertyPointer; import org.apache.commons.jxpath.util.ValueUtils; /** * Pointer pointing to a property of an object with dynamic properties. * * @author Dmitri Plotnikov * @version $Revision: 652845 $ $Date: 2008-05-02 12:46:46 -0500 (Fri, 02 May 2008) $ */ public class DynamicPropertyPointer extends PropertyPointer { private static final long serialVersionUID = -5720585681149150822L; private DynamicPropertyHandler handler; private String name; private String[] names; private String requiredPropertyName; /** * Create a new DynamicPropertyPointer. * @param parent pointer * @param handler DynamicPropertyHandler */ public DynamicPropertyPointer(NodePointer parent, DynamicPropertyHandler handler) { super(parent); this.handler = handler; } /** * This type of node is auxiliary. * @return true */ public boolean isContainer() { return true; } /** * Number of the DP object's properties. * @return int */ public int getPropertyCount() { return getPropertyNames().length; } /** * Names of all properties, sorted alphabetically. * @return String[] */ public String[] getPropertyNames() { if (names == null) { String[] allNames = handler.getPropertyNames(getBean()); names = new String[allNames.length]; for (int i = 0; i < names.length; i++) { names[i] = allNames[i]; } Arrays.sort(names); if (requiredPropertyName != null) { int inx = Arrays.binarySearch(names, requiredPropertyName); if (inx < 0) { allNames = names; names = new String[allNames.length + 1]; names[0] = requiredPropertyName; System.arraycopy(allNames, 0, names, 1, allNames.length); Arrays.sort(names); } } } return names; } /** * Returns the name of the currently selected property or "*" * if none has been selected. * @return String */ public String getPropertyName() { if (name == null) { String[] names = getPropertyNames(); name = propertyIndex >= 0 && propertyIndex < names.length ? names[propertyIndex] : "*"; } return name; } /** * Select a property by name. If the supplied name is * not one of the object's existing properties, it implicitly * adds this name to the object's property name list. It does not * set the property value though. In order to set the property * value, call setValue(). * @param propertyName to set */ public void setPropertyName(String propertyName) { setPropertyIndex(UNSPECIFIED_PROPERTY); this.name = propertyName; requiredPropertyName = propertyName; if (names != null && Arrays.binarySearch(names, propertyName) < 0) { names = null; } } /** * Index of the currently selected property in the list of all * properties sorted alphabetically. * @return int */ public int getPropertyIndex() { if (propertyIndex == UNSPECIFIED_PROPERTY) { String[] names = getPropertyNames(); for (int i = 0; i < names.length; i++) { if (names[i].equals(name)) { setPropertyIndex(i); break; } } } return super.getPropertyIndex(); } /** * Index a property by its index in the list of all * properties sorted alphabetically. * @param index to set */ public void setPropertyIndex(int index) { if (propertyIndex != index) { super.setPropertyIndex(index); name = null; } } /** * Returns the value of the property, not an element of the collection * represented by the property, if any. * @return Object */ public Object getBaseValue() { return handler.getProperty(getBean(), getPropertyName()); } /** * If index == WHOLE_COLLECTION, the value of the property, otherwise * the value of the index'th element of the collection represented by the * property. If the property is not a collection, index should be zero * and the value will be the property itself. * @return Object */ public Object getImmediateNode() { Object value; if (index == WHOLE_COLLECTION) { value = ValueUtils.getValue(handler.getProperty(getBean(), getPropertyName())); } else { value = ValueUtils.getValue(handler.getProperty(getBean(), getPropertyName()), index); } return value; } /** * A dynamic property is always considered actual - all keys are apparently * existing with possibly the value of null. * @return boolean */ protected boolean isActualProperty() { return true; } /** * If index == WHOLE_COLLECTION, change the value of the property, otherwise * change the value of the index'th element of the collection * represented by the property. * @param value to set */ public void setValue(Object value) { if (index == WHOLE_COLLECTION) { handler.setProperty(getBean(), getPropertyName(), value); } else { ValueUtils.setValue(handler.getProperty(getBean(), getPropertyName()), index, value); } } public NodePointer createPath(JXPathContext context) { // Ignore the name passed to us, use our own data Object collection = getBaseValue(); if (collection == null) { AbstractFactory factory = getAbstractFactory(context); boolean success = factory.createObject(context, this, getBean(), getPropertyName(), 0); if (!success) { throw new JXPathAbstractFactoryException( "Factory could not create an object for path: " + asPath()); } collection = getBaseValue(); } if (index != WHOLE_COLLECTION) { if (index < 0) { throw new JXPathInvalidAccessException("Index is less than 1: " + asPath()); } if (index >= getLength()) { collection = ValueUtils.expandCollection(collection, index + 1); handler.setProperty(getBean(), getPropertyName(), collection); } } return this; } public NodePointer createPath(JXPathContext context, Object value) { if (index == WHOLE_COLLECTION) { handler.setProperty(getBean(), getPropertyName(), value); } else { createPath(context); ValueUtils.setValue(getBaseValue(), index, value); } return this; } public void remove() { if (index == WHOLE_COLLECTION) { removeKey(); } else if (isCollection()) { Object collection = ValueUtils.remove(getBaseValue(), index); handler.setProperty(getBean(), getPropertyName(), collection); } else if (index == 0) { removeKey(); } } /** * Remove the current property. */ private void removeKey() { Object bean = getBean(); if (bean instanceof Map) { ((Map) bean).remove(getPropertyName()); } else { handler.setProperty(bean, getPropertyName(), null); } } public String asPath() { StringBuffer buffer = new StringBuffer(); buffer.append(getImmediateParentPointer().asPath()); if (buffer.length() == 0) { buffer.append("/."); } else if (buffer.charAt(buffer.length() - 1) == '/') { buffer.append('.'); } buffer.append("[@name='"); buffer.append(escape(getPropertyName())); buffer.append("']"); if (index != WHOLE_COLLECTION && isCollection()) { buffer.append('[').append(index + 1).append(']'); } return buffer.toString(); } }