/*
* 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.configuration2.tree.xpath;
import java.util.Locale;
import org.apache.commons.configuration2.tree.NodeHandler;
import org.apache.commons.jxpath.ri.Compiler;
import org.apache.commons.jxpath.ri.QName;
import org.apache.commons.jxpath.ri.compiler.NodeTest;
import org.apache.commons.jxpath.ri.compiler.NodeTypeTest;
import org.apache.commons.jxpath.ri.model.NodeIterator;
import org.apache.commons.jxpath.ri.model.NodePointer;
A specific NodePointer
implementation for configuration nodes.
This is needed for queries using JXPath.
Type parameters: - <T> – the type of the nodes this pointer deals with
Since: 1.3
/**
* <p>
* A specific {@code NodePointer} implementation for configuration nodes.
* </p>
* <p>
* This is needed for queries using JXPath.
* </p>
*
* @since 1.3
* @param <T> the type of the nodes this pointer deals with
*/
class ConfigurationNodePointer<T> extends NodePointer
{
The serial version UID.
/**
* The serial version UID.
*/
private static final long serialVersionUID = -1087475639680007713L;
The node handler. /** The node handler. */
private final NodeHandler<T> handler;
Stores the associated node. /** Stores the associated node. */
private final T node;
Creates a new instance of ConfigurationNodePointer
pointing to the specified node. Params: - node – the wrapped node
- locale – the locale
- handler – the
NodeHandler
/**
* Creates a new instance of {@code ConfigurationNodePointer} pointing to
* the specified node.
*
* @param node the wrapped node
* @param locale the locale
* @param handler the {@code NodeHandler}
*/
public ConfigurationNodePointer(final T node, final Locale locale,
final NodeHandler<T> handler)
{
super(null, locale);
this.node = node;
this.handler = handler;
}
Creates a new instance of ConfigurationNodePointer
and initializes it with its parent pointer. Params: - parent – the parent pointer
- node – the associated node
- handler – the
NodeHandler
/**
* Creates a new instance of {@code ConfigurationNodePointer} and
* initializes it with its parent pointer.
*
* @param parent the parent pointer
* @param node the associated node
* @param handler the {@code NodeHandler}
*/
public ConfigurationNodePointer(final ConfigurationNodePointer<T> parent, final T node,
final NodeHandler<T> handler)
{
super(parent);
this.node = node;
this.handler = handler;
}
Returns a flag whether this node is a leaf. This is the case if there are
no child nodes.
Returns: a flag if this node is a leaf
/**
* Returns a flag whether this node is a leaf. This is the case if there are
* no child nodes.
*
* @return a flag if this node is a leaf
*/
@Override
public boolean isLeaf()
{
return getNodeHandler().getChildrenCount(node, null) < 1;
}
Returns a flag if this node is a collection. This is not the case.
Returns: the collection flag
/**
* Returns a flag if this node is a collection. This is not the case.
*
* @return the collection flag
*/
@Override
public boolean isCollection()
{
return false;
}
Returns this node's length. This is always 1.
Returns: the node's length
/**
* Returns this node's length. This is always 1.
*
* @return the node's length
*/
@Override
public int getLength()
{
return 1;
}
Checks whether this node pointer refers to an attribute node. This is
not the case.
Returns: the attribute flag
/**
* Checks whether this node pointer refers to an attribute node. This is
* not the case.
*
* @return the attribute flag
*/
@Override
public boolean isAttribute()
{
return false;
}
Returns this node's name.
Returns: the name
/**
* Returns this node's name.
*
* @return the name
*/
@Override
public QName getName()
{
return new QName(null, getNodeHandler().nodeName(node));
}
Returns this node's base value. This is the associated configuration
node.
Returns: the base value
/**
* Returns this node's base value. This is the associated configuration
* node.
*
* @return the base value
*/
@Override
public Object getBaseValue()
{
return node;
}
Returns the immediate node. This is the associated configuration node.
Returns: the immediate node
/**
* Returns the immediate node. This is the associated configuration node.
*
* @return the immediate node
*/
@Override
public Object getImmediateNode()
{
return node;
}
Returns the value of this node.
Returns: the represented node's value
/**
* Returns the value of this node.
*
* @return the represented node's value
*/
@Override
public Object getValue()
{
return getNodeHandler().getValue(node);
}
Sets the value of this node. This is not supported, so always an
exception is thrown.
Params: - value – the new value
/**
* Sets the value of this node. This is not supported, so always an
* exception is thrown.
*
* @param value the new value
*/
@Override
public void setValue(final Object value)
{
throw new UnsupportedOperationException("Node value cannot be set!");
}
Compares two child node pointers.
Params: - pointer1 – one pointer
- pointer2 – another pointer
Returns: a flag, which pointer should be sorted first
/**
* Compares two child node pointers.
*
* @param pointer1 one pointer
* @param pointer2 another pointer
* @return a flag, which pointer should be sorted first
*/
@Override
public int compareChildNodePointers(final NodePointer pointer1,
final NodePointer pointer2)
{
final Object node1 = pointer1.getBaseValue();
final Object node2 = pointer2.getBaseValue();
// sort based on the occurrence in the sub node list
for (final T child : getNodeHandler().getChildren(node))
{
if (child == node1)
{
return -1;
}
else if (child == node2)
{
return 1;
}
}
return 0; // should not happen
}
Returns an iterator for the attributes that match the given name.
Params: - name – the attribute name
Returns: the iterator for the attributes
/**
* Returns an iterator for the attributes that match the given name.
*
* @param name the attribute name
* @return the iterator for the attributes
*/
@Override
public NodeIterator attributeIterator(final QName name)
{
return new ConfigurationNodeIteratorAttribute<>(this, name);
}
Returns an iterator for the children of this pointer that match the given
test object.
Params: - test – the test object
- reverse – the reverse flag
- startWith – the start value of the iteration
/**
* Returns an iterator for the children of this pointer that match the given
* test object.
*
* @param test the test object
* @param reverse the reverse flag
* @param startWith the start value of the iteration
*/
@Override
public NodeIterator childIterator(final NodeTest test, final boolean reverse,
final NodePointer startWith)
{
return new ConfigurationNodeIteratorChildren<>(this, test, reverse,
castPointer(startWith));
}
Tests if this node matches the given test. Configuration nodes are text
nodes, too because they can contain a value.
Params: - test – the test object
Returns: a flag if this node corresponds to the test
/**
* Tests if this node matches the given test. Configuration nodes are text
* nodes, too because they can contain a value.
*
* @param test the test object
* @return a flag if this node corresponds to the test
*/
@Override
public boolean testNode(final NodeTest test)
{
if (test instanceof NodeTypeTest
&& ((NodeTypeTest) test).getNodeType() == Compiler.NODE_TYPE_TEXT)
{
return true;
}
return super.testNode(test);
}
Returns the NodeHandler
used by this instance. Returns: the NodeHandler
/**
* Returns the {@code NodeHandler} used by this instance.
*
* @return the {@code NodeHandler}
*/
public NodeHandler<T> getNodeHandler()
{
return handler;
}
Returns the wrapped configuration node.
Returns: the wrapped node
/**
* Returns the wrapped configuration node.
*
* @return the wrapped node
*/
public T getConfigurationNode()
{
return node;
}
Casts the given child pointer to a node pointer of this type. This is a
bit dangerous. However, in a typical setup, child node pointers can only
be created by this instance which ensures that they are of the correct
type. Therefore, this cast is safe.
Params: - p – the
NodePointer
to cast
Returns: the resulting ConfigurationNodePointer
/**
* Casts the given child pointer to a node pointer of this type. This is a
* bit dangerous. However, in a typical setup, child node pointers can only
* be created by this instance which ensures that they are of the correct
* type. Therefore, this cast is safe.
*
* @param p the {@code NodePointer} to cast
* @return the resulting {@code ConfigurationNodePointer}
*/
private ConfigurationNodePointer<T> castPointer(final NodePointer p)
{
@SuppressWarnings("unchecked") // see method comment
final
ConfigurationNodePointer<T> result = (ConfigurationNodePointer<T>) p;
return result;
}
}