/*
    * 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;
  
  import java.lang.ref.SoftReference;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Vector;
  
  import org.apache.commons.jxpath.CompiledExpression;
  import org.apache.commons.jxpath.ExceptionHandler;
  import org.apache.commons.jxpath.Function;
  import org.apache.commons.jxpath.Functions;
  import org.apache.commons.jxpath.JXPathContext;
  import org.apache.commons.jxpath.JXPathException;
  import org.apache.commons.jxpath.JXPathFunctionNotFoundException;
  import org.apache.commons.jxpath.JXPathInvalidSyntaxException;
  import org.apache.commons.jxpath.JXPathNotFoundException;
  import org.apache.commons.jxpath.JXPathTypeConversionException;
  import org.apache.commons.jxpath.Pointer;
  import org.apache.commons.jxpath.ri.axes.InitialContext;
  import org.apache.commons.jxpath.ri.axes.RootContext;
  import org.apache.commons.jxpath.ri.compiler.Expression;
  import org.apache.commons.jxpath.ri.compiler.LocationPath;
  import org.apache.commons.jxpath.ri.compiler.Path;
  import org.apache.commons.jxpath.ri.compiler.TreeCompiler;
  import org.apache.commons.jxpath.ri.model.NodePointer;
  import org.apache.commons.jxpath.ri.model.NodePointerFactory;
  import org.apache.commons.jxpath.ri.model.VariablePointerFactory;
  import org.apache.commons.jxpath.ri.model.beans.BeanPointerFactory;
  import org.apache.commons.jxpath.ri.model.beans.CollectionPointerFactory;
  import org.apache.commons.jxpath.ri.model.container.ContainerPointerFactory;
  import org.apache.commons.jxpath.ri.model.dynamic.DynamicPointerFactory;
  import org.apache.commons.jxpath.util.ClassLoaderUtil;
  import org.apache.commons.jxpath.util.ReverseComparator;
  import org.apache.commons.jxpath.util.TypeUtils;
  
  /**
   * The reference implementation of JXPathContext.
   */
  public class JXPathContextReferenceImpl extends JXPathContext {
  
      /**
       * Change this to {@code false} to disable soft caching of CompiledExpressions.
       */
      public static final boolean USE_SOFT_CACHE = true;
      private static final Compiler COMPILER = new TreeCompiler();
      private static Map<String, Object> compiled = new HashMap<>();
      private static int cleanupCount;
      private static NodePointerFactory[] nodeFactoryArray;
      // The frequency of the cache cleanup
      private static final int CLEANUP_THRESHOLD = 500;
      private static final Vector<NodePointerFactory> nodeFactories = new Vector<>();
      static {
          nodeFactories.add(new CollectionPointerFactory());
          nodeFactories.add(new BeanPointerFactory());
          nodeFactories.add(new DynamicPointerFactory());
          nodeFactories.add(new VariablePointerFactory());
          // DOM factory is only registered if DOM support is on the classpath
          final NodePointerFactory domFactory = (NodePointerFactory) allocateConditionally("org.apache.commons.jxpath.ri.model.dom.DOMPointerFactory",
                  "org.w3c.dom.Node");
          if (domFactory != null) {
              nodeFactories.add(domFactory);
          }
          // JDOM factory is only registered if JDOM is on the classpath
          final NodePointerFactory jdomFactory = (NodePointerFactory) allocateConditionally("org.apache.commons.jxpath.ri.model.jdom.JDOMPointerFactory",
                  "org.jdom.Document");
          if (jdomFactory != null) {
              nodeFactories.add(jdomFactory);
          }
          // DynaBean factory is only registered if BeanUtils are on the classpath
          final NodePointerFactory dynaBeanFactory = (NodePointerFactory) allocateConditionally(
                  "org.apache.commons.jxpath.ri.model.dynabeans." + "DynaBeanPointerFactory", "org.apache.commons.beanutils.DynaBean");
          if (dynaBeanFactory != null) {
              nodeFactories.add(dynaBeanFactory);
          }
          nodeFactories.add(new ContainerPointerFactory());
          createNodeFactoryArray();
      }
 
     /**
      * Call this with a custom NodePointerFactory to add support for additional types of objects. Make sure the factory returns a name that puts it in the right
      * position on the list of factories.
      *
      * @param factory NodePointerFactory to add
      */
     public static void addNodePointerFactory(final NodePointerFactory factory) {
         synchronized (nodeFactories) {
             nodeFactories.add(factory);
             nodeFactoryArray = null;
         }
     }
 
     /**
      * Checks if existenceCheckClass exists on the class path. If so, allocates an instance of the specified class, otherwise returns null.
      *
      * @param className               to instantiate
      * @param existenceCheckClassName guard class
      * @return className instance
      */
     public static Object allocateConditionally(final String className, final String existenceCheckClassName) {
         try {
             try {
                 ClassLoaderUtil.getClass(existenceCheckClassName, true);
             } catch (final ClassNotFoundException ex) {
                 return null;
             }
             return ClassLoaderUtil.getClass(className, true).getConstructor().newInstance();
         } catch (final Exception ex) {
             throw new JXPathException("Cannot allocate " + className, ex);
         }
     }
 
     /**
      * Create the default node factory array.
      */
     private static synchronized void createNodeFactoryArray() {
         if (nodeFactoryArray == null) {
             nodeFactoryArray = nodeFactories.toArray(new NodePointerFactory[nodeFactories.size()]);
             Arrays.sort(nodeFactoryArray, (a, b) -> {
                 final int orderA = a.getOrder();
                 final int orderB = b.getOrder();
                 return orderA - orderB;
             });
         }
     }
 
     /**
      * Gets the registered NodePointerFactories.
      *
      * @return NodePointerFactory[]
      */
     public static NodePointerFactory[] getNodePointerFactories() {
         return nodeFactoryArray;
     }
 
     /**
      * Removes support for additional types of objects.
      *
      * @param factory NodePointerFactory to remove
      * @return true if this implementation contained the specified element
      * @since 1.4.0.0
      */
     public static boolean removeNodePointerFactory(final NodePointerFactory factory) {
         synchronized (nodeFactories) {
             final boolean remove = nodeFactories.remove(factory);
             nodeFactoryArray = null;
             return remove;
         }
     }
 
     /** Namespace resolver */
     protected NamespaceResolver namespaceResolver;
     private Pointer rootPointer;
     private Pointer contextPointer;
 
     /**
      * Constructs a new JXPathContextReferenceImpl.
      *
      * @param parentContext parent context
      * @param contextBean   Object
      */
     protected JXPathContextReferenceImpl(final JXPathContext parentContext, final Object contextBean) {
         this(parentContext, contextBean, null);
     }
 
     /**
      * Constructs a new JXPathContextReferenceImpl.
      *
      * @param parentContext  parent context
      * @param contextBean    Object
      * @param contextPointer context pointer
      */
     public JXPathContextReferenceImpl(final JXPathContext parentContext, final Object contextBean, final Pointer contextPointer) {
         super(parentContext, contextBean);
         synchronized (nodeFactories) {
             createNodeFactoryArray();
         }
         if (contextPointer != null) {
             this.contextPointer = contextPointer;
             this.rootPointer = NodePointer.newNodePointer(new QName(null, "root"), contextPointer.getRootNode(), getLocale());
         } else {
             this.contextPointer = NodePointer.newNodePointer(new QName(null, "root"), contextBean, getLocale());
             this.rootPointer = this.contextPointer;
         }
         NamespaceResolver parentNR = null;
         if (parentContext instanceof JXPathContextReferenceImpl) {
             parentNR = ((JXPathContextReferenceImpl) parentContext).getNamespaceResolver();
         }
         namespaceResolver = new NamespaceResolver(parentNR);
         namespaceResolver.setNamespaceContextPointer((NodePointer) this.contextPointer);
     }
 
     /**
      * Checks if the path follows the JXPath restrictions on the type of path that can be passed to create... methods.
      *
      * @param expr Expression to check
      */
     private void checkSimplePath(final Expression expr) {
         if (!(expr instanceof LocationPath) || !((LocationPath) expr).isSimplePath()) {
             throw new JXPathInvalidSyntaxException(
                     "JXPath can only create a path if it uses exclusively " + "the child:: and attribute:: axes and has " + "no context-dependent predicates");
         }
     }
 
     /**
      * Compile the given expression.
      *
      * @param xpath to compile
      * @return Expression
      */
     private Expression compileExpression(final String xpath) {
         Expression expr;
         synchronized (compiled) {
             if (USE_SOFT_CACHE) {
                 expr = null;
                 final SoftReference<Expression> ref = (SoftReference) compiled.get(xpath);
                 if (ref != null) {
                     expr = ref.get();
                 }
             } else {
                 expr = (Expression) compiled.get(xpath);
             }
         }
         if (expr != null) {
             return expr;
         }
         expr = (Expression) Parser.parseExpression(xpath, getCompiler());
         synchronized (compiled) {
             if (USE_SOFT_CACHE) {
                 if (cleanupCount++ >= CLEANUP_THRESHOLD) {
                     final Iterator<Entry<String, Object>> it = compiled.entrySet().iterator();
                     while (it.hasNext()) {
                         final Entry<String, ?> me = it.next();
                         if (((SoftReference<Expression>) me.getValue()).get() == null) {
                             it.remove();
                         }
                     }
                     cleanupCount = 0;
                 }
                 compiled.put(xpath, new SoftReference<>(expr));
             } else {
                 compiled.put(xpath, expr);
             }
         }
         return expr;
     }
 
     @Override
     protected CompiledExpression compilePath(final String xpath) {
         return new JXPathCompiledExpression(xpath, compileExpression(xpath));
     }
 //    private Object getNativeContextNode(Expression expression) {
 //        Object node = getNativeContextNode(getContextBean());
 //        if (node == null) {
 //            return null;
 //        }
 //
 //        List vars = expression.getUsedVariables();
 //        if (vars != null) {
 //            return null;
 //        }
 //
 //        return node;
 //    }
 //    private Object getNativeContextNode(Object bean) {
 //        if (bean instanceof Number || bean instanceof String || bean instanceof Boolean) {
 //            return bean;
 //        }
 //        if (bean instanceof Node) {
 //            return (Node)bean;
 //        }
 //
 //        if (bean instanceof Container) {
 //            bean = ((Container)bean).getValue();
 //            return getNativeContextNode(bean);
 //        }
 //
 //        return null;
 //    }
 
     @Override
     public Pointer createPath(final String xpath) {
         return createPath(xpath, compileExpression(xpath));
     }
 
     /**
      * Create the given path.
      *
      * @param xpath String
      * @param expr  compiled Expression
      * @return resulting Pointer
      */
     public Pointer createPath(final String xpath, final Expression expr) {
         try {
             final Object result = expr.computeValue(getEvalContext());
             Pointer pointer;
             if (result instanceof Pointer) {
                 pointer = (Pointer) result;
             } else if (result instanceof EvalContext) {
                 final EvalContext ctx = (EvalContext) result;
                 pointer = ctx.getSingleNodePointer();
             } else {
                 checkSimplePath(expr);
                 // This should never happen
                 throw new JXPathException("Cannot create path:" + xpath);
             }
             return ((NodePointer) pointer).createPath(this);
         } catch (final Throwable ex) {
             throw new JXPathException("Exception trying to create XPath " + xpath, ex);
         }
     }
 
     /**
      * Create the given path setting its value to value.
      *
      * @param xpath String
      * @param expr  compiled Expression
      * @param value Object
      * @return resulting Pointer
      */
     public Pointer createPathAndSetValue(final String xpath, final Expression expr, final Object value) {
         try {
             return setValue(xpath, expr, value, true);
         } catch (final Throwable ex) {
             throw new JXPathException("Exception trying to create XPath " + xpath, ex);
         }
     }
 
     @Override
     public Pointer createPathAndSetValue(final String xpath, final Object value) {
         return createPathAndSetValue(xpath, compileExpression(xpath), value);
     }
 
     /**
      * Gets the absolute root context.
      *
      * @return EvalContext
      */
     public EvalContext getAbsoluteRootContext() {
         return new InitialContext(new RootContext(this, getAbsoluteRootPointer()));
     }
 
     /**
      * Gets absolute root pointer.
      *
      * @return NodePointer
      */
     private NodePointer getAbsoluteRootPointer() {
         return (NodePointer) rootPointer;
     }
 
     /**
      * Returns a static instance of TreeCompiler.
      *
      * Override this to return an alternate compiler.
      *
      * @return Compiler
      */
     protected Compiler getCompiler() {
         return COMPILER;
     }
 
     @Override
     public Pointer getContextPointer() {
         return contextPointer;
     }
 
     /**
      * Gets the evaluation context.
      *
      * @return EvalContext
      */
     private EvalContext getEvalContext() {
         return new InitialContext(new RootContext(this, (NodePointer) getContextPointer()));
     }
 
     /**
      * Gets the named Function.
      *
      * @param functionName name
      * @param parameters   function args
      * @return Function
      */
     public Function getFunction(final QName functionName, final Object[] parameters) {
         final String namespace = functionName.getPrefix();
         final String name = functionName.getName();
         JXPathContext funcCtx = this;
         Function func;
         Functions funcs;
         while (funcCtx != null) {
             funcs = funcCtx.getFunctions();
             if (funcs != null) {
                 func = funcs.getFunction(namespace, name, parameters);
                 if (func != null) {
                     return func;
                 }
             }
             funcCtx = funcCtx.getParentContext();
         }
         throw new JXPathFunctionNotFoundException("Undefined function: " + functionName.toString());
     }
 
     @Override
     public Pointer getNamespaceContextPointer() {
         return namespaceResolver.getNamespaceContextPointer();
     }
 
     /**
      * Gets the namespace resolver.
      *
      * @return NamespaceResolver
      */
     public NamespaceResolver getNamespaceResolver() {
         namespaceResolver.seal();
         return namespaceResolver;
     }
 
     @Override
     public String getNamespaceURI(final String prefix) {
         return namespaceResolver.getNamespaceURI(prefix);
     }
 
     @Override
     public Pointer getPointer(final String xpath) {
         return getPointer(xpath, compileExpression(xpath));
     }
 
     /**
      * Gets a pointer to the specified path/expression.
      *
      * @param xpath String
      * @param expr  compiled Expression
      * @return Pointer
      */
     public Pointer getPointer(final String xpath, final Expression expr) {
         Object result = expr.computeValue(getEvalContext());
         if (result instanceof EvalContext) {
             result = ((EvalContext) result).getSingleNodePointer();
         }
         if (result instanceof Pointer) {
             if (!isLenient() && !((NodePointer) result).isActual()) {
                 throw new JXPathNotFoundException("No pointer for xpath: " + xpath);
             }
             return (Pointer) result;
         }
         return NodePointer.newNodePointer(null, result, getLocale());
     }
 
     /**
      * {@inheritDoc}
      *
      * @see org.apache.commons.jxpath.JXPathContext#getPrefix(java.lang.String)
      */
     @Override
     public String getPrefix(final String namespaceURI) {
         return namespaceResolver.getPrefix(namespaceURI);
     }
 
     @Override
     public JXPathContext getRelativeContext(final Pointer pointer) {
         final Object contextBean = pointer.getNode();
         if (contextBean == null) {
             throw new JXPathException("Cannot create a relative context for a non-existent node: " + pointer);
         }
         return new JXPathContextReferenceImpl(this, contextBean, pointer);
     }
 
     /**
      * Traverses the XPath and returns the resulting object. Primitive types are wrapped into objects.
      *
      * @param xpath expression
      * @return Object found
      */
     @Override
     public Object getValue(final String xpath) {
         final Expression expression = compileExpression(xpath);
 // TODO: (work in progress) - trying to integrate with Xalan
 //        Object ctxNode = getNativeContextNode(expression);
 //        if (ctxNode != null) {
 //            System.err.println("WILL USE XALAN: " + xpath);
 //            CachedXPathAPI api = new CachedXPathAPI();
 //            try {
 //                if (expression instanceof Path) {
 //                    Node node = api.selectSingleNode((Node)ctxNode, xpath);
 //                    System.err.println("NODE: " + node);
 //                    if (node == null) {
 //                        return null;
 //                    }
 //                    return new DOMNodePointer(node, null).getValue();
 //                }
 //                else {
 //                    XObject object = api.eval((Node)ctxNode, xpath);
 //                    switch (object.getType()) {
 //                    case XObject.CLASS_STRING: return object.str();
 //                    case XObject.CLASS_NUMBER: return new Double(object.num());
 //                    case XObject.CLASS_BOOLEAN: return new Boolean(object.bool());
 //                    default:
 //                        System.err.println("OTHER TYPE: " + object.getTypeString());
 //                    }
 //                }
 //            }
 //            catch (TransformerException e) {
 //                // TODO Auto-generated catch block
 //                e.printStackTrace();
 //            }
 //            return
 //        }
         return getValue(xpath, expression);
     }
 
     /**
      * Calls getValue(xpath), converts the result to the required type and returns the result of the conversion.
      *
      * @param xpath        expression
      * @param requiredType Class
      * @return Object
      */
     @Override
     public Object getValue(final String xpath, final Class requiredType) {
         final Expression expr = compileExpression(xpath);
         return getValue(xpath, expr, requiredType);
     }
 
     /**
      * Gets the value indicated.
      *
      * @param xpath String
      * @param expr  Expression
      * @return Object
      */
     public Object getValue(final String xpath, final Expression expr) {
         Object result = expr.computeValue(getEvalContext());
         if (result == null) {
             if (expr instanceof Path && !isLenient()) {
                 throw new JXPathNotFoundException("No value for xpath: " + xpath);
             }
             return null;
         }
         if (result instanceof EvalContext) {
             final EvalContext ctx = (EvalContext) result;
             result = ctx.getSingleNodePointer();
             if (!isLenient() && result == null) {
                 throw new JXPathNotFoundException("No value for xpath: " + xpath);
             }
         }
         if (result instanceof NodePointer) {
             result = ((NodePointer) result).getValuePointer();
             if (!isLenient()) {
                 NodePointer.verify((NodePointer) result);
             }
             result = ((NodePointer) result).getValue();
         }
         return result;
     }
 
     /**
      * Gets the value indicated.
      *
      * @param xpath        expression
      * @param expr         compiled Expression
      * @param requiredType Class
      * @return Object
      */
     public Object getValue(final String xpath, final Expression expr, final Class requiredType) {
         Object value = getValue(xpath, expr);
         if (value != null && requiredType != null) {
             if (!TypeUtils.canConvert(value, requiredType)) {
                 throw new JXPathTypeConversionException("Invalid expression type. '" + xpath + "' returns " + value.getClass().getName()
                         + ". It cannot be converted to " + requiredType.getName());
             }
             value = TypeUtils.convert(value, requiredType);
         }
         return value;
     }
 
     /**
      * Gets a VariablePointer for the given variable name.
      *
      * @param qName variable name
      * @return NodePointer
      */
     public NodePointer getVariablePointer(final QName qName) {
         return NodePointer.newNodePointer(qName, VariablePointerFactory.contextWrapper(this), getLocale());
     }
 
     /**
      * Traverses the XPath and returns a Iterator of all results found for the path. If the XPath matches no properties in the graph, the Iterator will not be
      * null.
      *
      * @param xpath expression
      * @return Iterator
      */
     @Override
     public Iterator iterate(final String xpath) {
         return iterate(xpath, compileExpression(xpath));
     }
 
     /**
      * Traverses the XPath and returns a Iterator of all results found for the path. If the XPath matches no properties in the graph, the Iterator will not be
      * null.
      *
      * @param xpath expression
      * @param expr  compiled Expression
      * @return Iterator
      */
     public Iterator iterate(final String xpath, final Expression expr) {
         return expr.iterate(getEvalContext());
     }
 
     /**
      * Traverses the XPath and returns an Iterator of Pointers. A Pointer provides easy access to a property. If the XPath matches no properties in the graph,
      * the Iterator be empty, but not null.
      *
      * @param xpath expression
      * @return Iterator
      */
     @Override
     public Iterator<Pointer> iteratePointers(final String xpath) {
         return iteratePointers(xpath, compileExpression(xpath));
     }
 
     /**
      * Traverses the XPath and returns an Iterator of Pointers. A Pointer provides easy access to a property. If the XPath matches no properties in the graph,
      * the Iterator be empty, but not null.
      *
      * @param xpath expression
      * @param expr  compiled Expression
      * @return Iterator
      */
     public Iterator<Pointer> iteratePointers(final String xpath, final Expression expr) {
         return expr.iteratePointers(getEvalContext());
     }
 
     @Override
     public void registerNamespace(final String prefix, final String namespaceURI) {
         if (namespaceResolver.isSealed()) {
             namespaceResolver = (NamespaceResolver) namespaceResolver.clone();
         }
         namespaceResolver.registerNamespace(prefix, namespaceURI);
     }
 
     @Override
     public void removeAll(final String xpath) {
         removeAll(xpath, compileExpression(xpath));
     }
 
     /**
      * Remove all matching nodes.
      *
      * @param xpath expression
      * @param expr  compiled Expression
      */
     public void removeAll(final String xpath, final Expression expr) {
         try {
             final ArrayList<NodePointer> list = new ArrayList<>();
             Iterator<NodePointer> it = expr.iteratePointers(getEvalContext());
             while (it.hasNext()) {
                 list.add(it.next());
             }
             Collections.sort(list, ReverseComparator.INSTANCE);
             it = list.iterator();
             if (it.hasNext()) {
                 final NodePointer pointer = it.next();
                 pointer.remove();
                 while (it.hasNext()) {
                     removePath(it.next().asPath());
                 }
             }
         } catch (final Throwable ex) {
             throw new JXPathException("Exception trying to remove all for xpath " + xpath, ex);
         }
     }
 
     @Override
     public void removePath(final String xpath) {
         removePath(xpath, compileExpression(xpath));
     }
 
     /**
      * Remove the specified path.
      *
      * @param xpath expression
      * @param expr  compiled Expression
      */
     public void removePath(final String xpath, final Expression expr) {
         try {
             final NodePointer pointer = (NodePointer) getPointer(xpath, expr);
             if (pointer != null) {
                 pointer.remove();
             }
         } catch (final Throwable ex) {
             throw new JXPathException("Exception trying to remove XPath " + xpath, ex);
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setExceptionHandler(final ExceptionHandler exceptionHandler) {
         if (rootPointer instanceof NodePointer) {
             ((NodePointer) rootPointer).setExceptionHandler(exceptionHandler);
         }
     }
 
     @Override
     public void setNamespaceContextPointer(final Pointer pointer) {
         if (namespaceResolver.isSealed()) {
             namespaceResolver = (NamespaceResolver) namespaceResolver.clone();
         }
         namespaceResolver.setNamespaceContextPointer((NodePointer) pointer);
     }
 
     /**
      * Sets the value of XPath to value.
      *
      * @param xpath path
      * @param expr  compiled Expression
      * @param value Object
      */
     public void setValue(final String xpath, final Expression expr, final Object value) {
         try {
             setValue(xpath, expr, value, false);
         } catch (final Throwable ex) {
             throw new JXPathException("Exception trying to set value with XPath " + xpath, ex);
         }
     }
 
     /**
      * Sets the specified value.
      *
      * @param xpath  path
      * @param expr   compiled Expression
      * @param value  destination value
      * @param create whether to create missing node(s)
      * @return Pointer created
      */
     private Pointer setValue(final String xpath, final Expression expr, final Object value, final boolean create) {
         final Object result = expr.computeValue(getEvalContext());
         Pointer pointer;
         if (result instanceof Pointer) {
             pointer = (Pointer) result;
         } else if (result instanceof EvalContext) {
             final EvalContext ctx = (EvalContext) result;
             pointer = ctx.getSingleNodePointer();
         } else {
             if (create) {
                 checkSimplePath(expr);
             }
             // This should never happen
             throw new JXPathException("Cannot set value for xpath: " + xpath);
         }
         if (create) {
             pointer = ((NodePointer) pointer).createPath(this, value);
         } else {
             pointer.setValue(value);
         }
         return pointer;
     }
 
     @Override
     public void setValue(final String xpath, final Object value) {
         setValue(xpath, compileExpression(xpath), value);
     }
 }