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 */
017package org.apache.commons.configuration2.tree.xpath;
018
019import java.util.Locale;
020
021import org.apache.commons.configuration2.tree.NodeHandler;
022import org.apache.commons.jxpath.ri.QName;
023import org.apache.commons.jxpath.ri.model.NodePointer;
024import org.apache.commons.jxpath.ri.model.NodePointerFactory;
025
026/**
027 * <p>
028 * Implementation of the {@code NodePointerFactory} interface for configuration nodes.
029 * </p>
030 * <p>
031 * This class is able to create {@code NodePointer}s for the nodes of hierarchical configurations. Because there is no
032 * common base class for configuration nodes (any specific configuration implementation can use its own node class) a
033 * trick is needed for activating this factory for a concrete JXPath query: The {@code wrapNode()} method has to be
034 * called with the node object and its corresponding {@code NodeHandler}. This creates a wrapper object containing all
035 * information required by the factory for processing a query. Then this wrapper object has to be passed to the query
036 * methods of the JXPath context.
037 * </p>
038 *
039 * @since 1.3
040 */
041public class ConfigurationNodePointerFactory implements NodePointerFactory {
042    /** Constant for the order of this factory. */
043    public static final int CONFIGURATION_NODE_POINTER_FACTORY_ORDER = 200;
044
045    /**
046     * Gets the order of this factory between other factories.
047     *
048     * @return this order's factory
049     */
050    @Override
051    public int getOrder() {
052        return CONFIGURATION_NODE_POINTER_FACTORY_ORDER;
053    }
054
055    /**
056     * Creates a node pointer for the specified bean. If the bean is a configuration node (indicated by a wrapper object), a
057     * corresponding pointer is returned.
058     *
059     * @param name the name of the node
060     * @param bean the bean
061     * @param locale the locale
062     * @return a pointer for a configuration node if the bean is such a node
063     */
064    @Override
065    @SuppressWarnings("unchecked")
066    /*
067     * Type casts are safe here; because of the way the NodeWrapper was constructed the node handler must be compatible with
068     * the node.
069     */
070    public NodePointer createNodePointer(final QName name, final Object bean, final Locale locale) {
071        if (bean instanceof NodeWrapper) {
072            final NodeWrapper<Object> wrapper = (NodeWrapper<Object>) bean;
073            return new ConfigurationNodePointer<>(wrapper.getNode(), locale, wrapper.getNodeHandler());
074        }
075        return null;
076    }
077
078    /**
079     * Creates a node pointer for the specified bean. If the bean is a configuration node, a corresponding pointer is
080     * returned.
081     *
082     * @param parent the parent node
083     * @param name the name
084     * @param bean the bean
085     * @return a pointer for a configuration node if the bean is such a node
086     */
087    @Override
088    @SuppressWarnings("unchecked")
089    /*
090     * Type casts are safe here, see above. Also, the hierarchy of node pointers is consistent, so a parent is compatible to
091     * a child.
092     */
093    public NodePointer createNodePointer(final NodePointer parent, final QName name, final Object bean) {
094        if (bean instanceof NodeWrapper) {
095            final NodeWrapper<Object> wrapper = (NodeWrapper<Object>) bean;
096            return new ConfigurationNodePointer<>((ConfigurationNodePointer<Object>) parent, wrapper.getNode(), wrapper.getNodeHandler());
097        }
098        return null;
099    }
100
101    /**
102     * Creates a node wrapper for the specified node and its handler. This wrapper has to be passed to the JXPath context
103     * instead of the original node.
104     *
105     * @param <T> the type of the node
106     * @param node the node
107     * @param handler the corresponding node handler
108     * @return a wrapper for this node
109     */
110    public static <T> Object wrapNode(final T node, final NodeHandler<T> handler) {
111        return new NodeWrapper<>(node, handler);
112    }
113
114    /**
115     * An internally used wrapper class that holds all information for processing a query for a specific node.
116     *
117     * @param <T> the type of the nodes this class deals with
118     */
119    static class NodeWrapper<T> {
120        /** Stores the node. */
121        private final T node;
122
123        /** Stores the corresponding node handler. */
124        private final NodeHandler<T> nodeHandler;
125
126        /**
127         * Creates a new instance of {@code NodeWrapper} and initializes it.
128         *
129         * @param nd the node
130         * @param handler the node handler
131         */
132        public NodeWrapper(final T nd, final NodeHandler<T> handler) {
133            node = nd;
134            nodeHandler = handler;
135        }
136
137        /**
138         * Gets the wrapped node.
139         *
140         * @return the node
141         */
142        public T getNode() {
143            return node;
144        }
145
146        /**
147         * Gets the node handler for the wrapped node.
148         *
149         * @return the node handler
150         */
151        public NodeHandler<T> getNodeHandler() {
152            return nodeHandler;
153        }
154    }
155}