Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.jackrabbit.spi2dav;
 
 
 import java.util.Map;

URIResolverImpl...
 
 class URIResolverImpl implements URIResolver {
 
     private final URI repositoryUri;
     private final RepositoryServiceImpl service;
     private final Document domFactory;
 
     // TODO: to-be-fixed. uri/id-caches don't get updated
     // for each workspace a separate idUri-cache is created
     private final Map<StringIdURICacheidURICaches = new HashMap<StringIdURICache>();
 
     URIResolverImpl(URI repositoryUriRepositoryServiceImpl serviceDocument domFactory) {
         this. = repositoryUri;
         this. = service;
         this. = domFactory;
     }
 
     private IdURICache getCache(String workspaceName) {
         if (.containsKey(workspaceName)) {
             return .get(workspaceName);
         } else {
             IdURICache c = new IdURICache(getWorkspaceUri(workspaceName));
             .put(workspaceNamec);
             return c;
         }
     }
 
     String getRepositoryUri() {
         return .getEscapedURI();
     }
 
     String getWorkspaceUri(String workspaceName) {
         String workspaceUri = getRepositoryUri();
         if (workspaceName != null) {
             workspaceUri += Text.escape(workspaceName);
         }
         return workspaceUri;
     }
 
     String getRootItemUri(String workspaceName) {
         return getWorkspaceUri(workspaceName) + Text.escapePath(.);
     }
 
     String getItemUri(ItemId itemIdString workspaceNameSessionInfo sessionInfo)
             throws RepositoryException {
         IdURICache cache = getCache(workspaceName);
        // check if uri is available from cache
        if (cache.containsItemId(itemId)) {
            return cache.getUri(itemId);
        } else {
            StringBuffer uriBuffer = new StringBuffer();
            Path path = itemId.getPath();
            String uniqueID = itemId.getUniqueID();
            // resolver uuid part
            if (uniqueID != null) {
                ItemId uuidId = (path == null) ? itemId : .getIdFactory().createNodeId(uniqueID);
                if (path != null && cache.containsItemId(uuidId)) {
                    // append uri of parent node, that is already cached
                    uriBuffer.append(cache.getUri(uuidId));
                } else {
                    // try to request locate-by-uuid report to build the uri
                    ReportInfo rInfo = new ReportInfo(..);
                    rInfo.setContentElement(DomUtil.hrefToXml(uniqueID));
                    ReportMethod rm = null;
                    try {
                        String wspUri = getWorkspaceUri(workspaceName);
                        rm = new ReportMethod(wspUrirInfo);
                        .getClient(sessionInfo).executeMethod(rm);
                        MultiStatus ms = rm.getResponseBodyAsMultiStatus();
                        if (ms.getResponses().length == 1) {
                            String absoluteUri = resolve(wspUrims.getResponses()[0].getHref());
                            uriBuffer.append(absoluteUri);
                            cache.add(absoluteUriuuidId);
                        } else {
                            throw new ItemNotFoundException("Cannot identify item with uniqueID " + uniqueID);
                        }
                    } catch (IOException e) {
                        throw new RepositoryException(e.getMessage());
                    } catch (DavException e) {
                        throw ExceptionConverter.generate(e);
                    } finally {
                        if (rm != null) {
                            rm.releaseConnection();
                        }
                    }
                }
            } else {
                // start build uri from root-item
                uriBuffer.append(getRootItemUri(workspaceName));
            }
            // resolve relative-path part unless it denotes the root-item
            if (path != null && !path.denotesRoot()) {
                String jcrPath = .getNamePathResolver(sessionInfo).getJCRPath(path);
                if (!path.isAbsolute() && !uriBuffer.toString().endsWith("/")) {
                    uriBuffer.append("/");
                }
                uriBuffer.append(Text.escapePath(jcrPath));
            }
            String itemUri = uriBuffer.toString();
            if (!cache.containsItemId(itemId)) {
                cache.add(itemUriitemId);
            }
            return itemUri;
        }
    }

    
Resolve the given href obtained from multistatus against base URI
    private static String resolve(String wspUriString hrefthrows RepositoryException {
        try {
            java.net.URI base = new java.net.URI(wspUri);
            java.net.URI rel = new java.net.URI(href);
            return base.resolve(rel).toString();
        }
        catch (URISyntaxException ex) {
            throw new RepositoryException(ex);
        }
    }
    protected NodeId buildNodeId(NodeId parentIdString baseUriMultiStatusResponse response,
                       String workspaceNameNamePathResolver resolverthrows RepositoryException {
        IdURICache cache = getCache(workspaceName);
        NodeId nodeId;
        DavPropertySet propSet = response.getProperties(.);
        String uniqueID = .getUniqueID(propSet);
        if (uniqueID != null) {
            nodeId = .getIdFactory().createNodeId(uniqueID);
        } else {
            Name qName = .getQName(propSetresolver);
            if (..equals(qName)) {
                nodeId = .getIdFactory().createNodeId((Stringnull.getPathFactory().getRootPath());
            } else {
                int index = .getIndex(propSet);
                nodeId = .getIdFactory().createNodeId(parentId.getPathFactory().create(qNameindex));
            }
        }
        // cache
        cache.add(resolve(baseUriresponse.getHref()), nodeId);
        return nodeId;
    }
                               String workspaceNameNamePathResolver resolverthrows RepositoryException {
        IdURICache cache = getCache(workspaceName);
        if (cache.containsUri(response.getHref())) {
            ItemId id = cache.getItemId(response.getHref());
            if (!id.denotesNode()) {
                return (PropertyIdid;
            }
        }
        try {
            DavPropertySet propSet = response.getProperties(.);
            Name name = resolver.getQName(propSet.get(..).getValue().toString());
            PropertyId propertyId = .getIdFactory().createPropertyId(parentIdname);
            cache.add(response.getHref(), propertyId);
            return propertyId;
        } catch (NameException e) {
            throw new RepositoryException(e);
        }
    }
    void clearCacheEntries(ItemId itemIdSessionInfo sessionInfo) {
        IdURICache cache = getCache(sessionInfo.getWorkspaceName());
        if (cache.containsItemId(itemId)) {
            cache.remove(itemId);
        }
    }
    void clearCacheEntries(SessionInfo sessionInfo) {
        IdURICache cache = getCache(sessionInfo.getWorkspaceName());
        cache.clear();
    }
    private static boolean isSameURI(String uri1String uri2) {
        return getCleanURI(uri1).equals(getCleanURI(uri2));
    }
    private static String getCleanURI(String uri) {
        if (uri.endsWith("/")) {
            return uri.substring(0, uri.length() - 1);
        } else {
            return uri;
        }
    }
    private NodeId getNodeId(String uriSessionInfo sessionInfoboolean nodeIsGonethrows RepositoryException {
        IdURICache cache = getCache(sessionInfo.getWorkspaceName());
        if (cache.containsUri(uri)) {
            // id has been accessed before and is cached
            ItemId id = cache.getItemId(uri);
            if (id.denotesNode()) {
                return (NodeIdid;
            }
        }
        if (nodeIsGone) {
            throw new RepositoryException("Can't reconstruct nodeId from URI when the remote node is gone.");
        }
        
        // retrieve parentId from cache or by recursive calls
        NodeId parentId;
        if (isSameURI(urigetRootItemUri(sessionInfo.getWorkspaceName()))) {
            parentId = null;
        } else {
            String parentUri = Text.getRelativeParent(uri, 1, true);
            parentId = getNodeId(parentUrisessionInfofalse);
        }
        DavPropertyNameSet nameSet = new DavPropertyNameSet();
        DavMethodBase method = null;
        try {
            method = new PropFindMethod(urinameSet.);
            .getClient(sessionInfo).executeMethod(method);
            MultiStatusResponse[] responses = method.getResponseBodyAsMultiStatus().getResponses();
            if (responses.length != 1) {
                throw new ItemNotFoundException("Unable to retrieve the node with id " + uri);
            }
            return buildNodeId(parentIduriresponses[0], sessionInfo.getWorkspaceName(), .getNamePathResolver(sessionInfo));
        } catch (IOException e) {
            throw new RepositoryException(e);
        } catch (DavException e) {
            throw ExceptionConverter.generate(e);
        } finally {
            if (method != null) {
                method.releaseConnection();
            }
        }
    }
    //-------------------------------------------------------< URI resolver >---
    

InheritDoc:
    public Path getQPath(String uriSessionInfo sessionInfothrows RepositoryException {
        String rootUri = getRootItemUri(sessionInfo.getWorkspaceName());
        String jcrPath;
        if (uri.startsWith(rootUri)) {
            jcrPath = uri.substring(rootUri.length());
        } else {
            // todo: probably rather an error?
            jcrPath = uri;
        }
        try {
            return .getNamePathResolver(sessionInfo).getQPath(Text.unescape(jcrPath));
        } catch (NameException e) {
            throw new RepositoryException(e);
        }
    }

    

InheritDoc:
    public NodeId getNodeId(String uriSessionInfo sessionInfothrows RepositoryException {
        return getNodeId(urisessionInfofalse);
    }
    
    

InheritDoc:
    public NodeId getNodeIdAfterEvent(String uriSessionInfo sessionInfoboolean nodeIsGonethrows RepositoryException {
        return getNodeId(urisessionInfonodeIsGone);
    }
    
    

InheritDoc:
    public PropertyId getPropertyId(String uriSessionInfo sessionInfothrows RepositoryException {
        IdURICache cache = getCache(sessionInfo.getWorkspaceName());
        if (cache.containsUri(uri)) {
            ItemId id = cache.getItemId(uri);
            if (!id.denotesNode()) {
                return (PropertyIdid;
            }
        }
        // separate parent uri and property JCRName
        String parentUri = Text.getRelativeParent(uri, 1, true);
        // make sure propName is unescaped
        String propName = Text.unescape(Text.getName(uritrue));
        // retrieve parent node id
        NodeId parentId = getNodeId(parentUrisessionInfofalse);
        // build property id
        try {
            Name name = .getNamePathResolver(sessionInfo).getQName(propName);
            PropertyId propertyId = .getIdFactory().createPropertyId(parentIdname);
            cache.add(uripropertyId);
            return propertyId;
        } catch (NameException e) {
            throw new RepositoryException(e);
        }
    }
New to GrepCode? Check out our FAQ X