Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014 Attila Szegedi, Daniel Dekany, Jonathan Revusky
   * 
   * Licensed 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 freemarker.ext.dom;
 
 import java.util.List;
 import java.util.Map;
 
 
 import  org.jaxen.BaseXPath;
 import  org.jaxen.Function;
 import  org.jaxen.FunctionCallException;
 import  org.jaxen.FunctionContext;
 import  org.jaxen.JaxenException;
 import  org.jaxen.NamespaceContext;
 import  org.jaxen.Navigator;
 import  org.jaxen.UnresolvableException;
 import  org.jaxen.VariableContext;
 import  org.jaxen.XPathFunctionContext;
 import  org.jaxen.dom.DocumentNavigator;
 
 
 class JaxenXPathSupport implements XPathSupport {
     
     private static final CustomAttribute cache = 
             protected Object create() {
                 return new HashMap();
             }
         };
 
     private final static ArrayList EMPTY_ARRAYLIST = new ArrayList();
 
     public TemplateModel executeQuery(Object contextString xpathQuerythrows TemplateModelException {
         try {
             BaseXPath xpath;
             Map xpathCache = (Map).get();
             synchronized(xpathCache) {
                 xpath = (BaseXPath) xpathCache.get(xpathQuery);
                 if (xpath == null) {
                     xpath = new BaseXPath(xpathQuery);
                     xpath.setNamespaceContext();
                     xpath.setFunctionContext();
                     xpath.setVariableContext();
                     xpathCache.put(xpathQueryxpath);
                 }
             }
             List result = xpath.selectNodes(context != null ? context : );
             if (result.size() == 1) {
                 return ..wrap(result.get(0));
             }
             NodeListModel nlm = new NodeListModel(resultnull);
             nlm.xpathSupport = this;
             return nlm;
         } catch (UndeclaredThrowableException e) {
             Throwable t  = e.getUndeclaredThrowable();
             if(t instanceof TemplateModelException) {
                 throw (TemplateModelException)t;
             }
            throw e;
        } catch (JaxenException je) {
            throw new TemplateModelException(je);
        }
    }
    static private final NamespaceContext customNamespaceContext = new NamespaceContext() {
        
        public String translateNamespacePrefixToUri(String prefix) {
            if (prefix.equals(.)) {
                return Environment.getCurrentEnvironment().getDefaultNS();
            }
            return Environment.getCurrentEnvironment().getNamespaceForPrefix(prefix);
        }
    };
    private static final VariableContext fmVariableContext = new VariableContext() {
        public Object getVariableValue(String namespaceURIString prefixString localName)
        throws 
            UnresolvableException
        {
            try {
                TemplateModel model = Environment.getCurrentEnvironment().getVariable(localName);
                if(model == null) {
                    throw new UnresolvableException("Variable " + localName + " not found.");
                }
                if(model instanceof TemplateScalarModel) {
                    return ((TemplateScalarModel)model).getAsString();
                }
                if(model instanceof TemplateNumberModel) {
                    return ((TemplateNumberModel)model).getAsNumber();
                }
                if(model instanceof TemplateDateModel) {
                    return ((TemplateDateModel)model).getAsDate();
                }
                if(model instanceof TemplateBooleanModel) {
                    return Boolean.valueOf(((TemplateBooleanModel)model).getAsBoolean());
                }
            }
            catch(TemplateModelException e) {
                throw new UndeclaredThrowableException(e);
            }
            throw new UnresolvableException("Variable " + localName + " is not a string, number, date, or boolean");
        }
    };
     
    private static final FunctionContext fmFunctionContext = new XPathFunctionContext() {
        public Function getFunction(String namespaceURIString prefixString localName)
        throws UnresolvableException {
            try {
                return super.getFunction(namespaceURIprefixlocalName);
            } 
            catch(UnresolvableException e) {
                return super.getFunction(nullnulllocalName);
            }
        }
    };
    
    private static final CustomAttribute cachedTree = new CustomAttribute(.);
     
    private static final Navigator fmDomNavigator = new DocumentNavigator() {
        public Object getDocument(String urithrows FunctionCallException
        {
            try
            {
                Template raw = getTemplate(uri);
                Document doc = (Document).get(raw);
                if(doc == null) {
                    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                    factory.setNamespaceAware(true);
                    DocumentBuilder builder = factory.newDocumentBuilder();
                    FmEntityResolver er = new FmEntityResolver();
                    builder.setEntityResolver(er);
                    doc = builder.parse(createInputSource(nullraw));
                    // If the entity resolver got called 0 times, the document
                    // is standalone, so we can safely cache it
                    if(er.getCallCount() == 0) {
                        .set(docraw);
                    }
                }
                return doc;
            }
            catch (Exception e)
            {
                throw new FunctionCallException("Failed to parse document for URI: " + urie);
            }
        }
    };
    static Template getTemplate(String systemIdthrows IOException {
        Environment env = Environment.getCurrentEnvironment();
        String encoding = env.getTemplate().getEncoding();
        if (encoding == null) {
            encoding = env.getConfiguration().getEncoding(env.getLocale());
        }
        String templatePath = env.getTemplate().getName();
        int lastSlash = templatePath.lastIndexOf('/');
        templatePath = lastSlash == -1 ? "" : templatePath.substring(0, lastSlash + 1);
        systemId = env.toFullTemplateName(templatePathsystemId);
        Template raw = env.getConfiguration().getTemplate(systemIdenv.getLocale(), encodingfalse);
        return raw;
    }
    private static InputSource createInputSource(String publicIdTemplate rawthrows IOExceptionSAXException {
        StringWriter sw = new StringWriter();
        try {
            raw.process(.sw);
        }
        catch(TemplateException e) {
            throw new SAXException(e);
        }
        InputSource is = new InputSource();
        is.setPublicId(publicId);
        is.setSystemId(raw.getName());
        is.setCharacterStream(new StringReader(sw.toString()));
        return is;
    }
    private static class FmEntityResolver implements EntityResolver {
        private int callCount = 0;
        
        public InputSource resolveEntity(String publicIdString systemId)
        throws SAXExceptionIOException {
            ++;
            return createInputSource(publicIdgetTemplate(systemId));
        }
        
        int getCallCount() {
            return ;
        }
    };
New to GrepCode? Check out our FAQ X