org.apache.jackrabbit.jcr2spi.hierarchy.HierarchyManagerImpl Maven / Gradle / Ivy

Go to download
/*
 * 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.jcr2spi.hierarchy;

import org.apache.jackrabbit.jcr2spi.state.NodeState;
import org.apache.jackrabbit.jcr2spi.state.PropertyState;
import org.apache.jackrabbit.jcr2spi.state.TransientItemStateFactory;
import org.apache.jackrabbit.jcr2spi.util.LogUtil;
import org.apache.jackrabbit.spi.IdFactory;
import org.apache.jackrabbit.spi.ItemId;
import org.apache.jackrabbit.spi.NodeId;
import org.apache.jackrabbit.spi.Path;
import org.apache.jackrabbit.spi.PathFactory;
import org.apache.jackrabbit.spi.PropertyId;
import org.apache.jackrabbit.spi.commons.conversion.NamePathResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.jcr.ItemNotFoundException;
import javax.jcr.PathNotFoundException;
import javax.jcr.RepositoryException;

/**
 * HierarchyManagerImpl implements the HierarchyManager
 * interface.
 */
public class HierarchyManagerImpl implements HierarchyManager {

    private static Logger log = LoggerFactory.getLogger(HierarchyManagerImpl.class);

    private final NodeEntry rootEntry;
    private final UniqueIdResolver uniqueIdResolver;
    private final IdFactory idFactory;
    private NamePathResolver resolver;

    public HierarchyManagerImpl(TransientItemStateFactory isf, IdFactory idFactory,
                                PathFactory pathFactory) {
        uniqueIdResolver = new UniqueIdResolver(isf);
        rootEntry = new EntryFactory(isf, idFactory, uniqueIdResolver, pathFactory).createRootEntry();
        this.idFactory = idFactory;
    }

    public void setResolver(NamePathResolver resolver) {
        this.resolver = resolver;
        if (rootEntry instanceof HierarchyEntryImpl) {
            ((HierarchyEntryImpl) rootEntry).factory.setResolver(resolver);
        }
    }

    //---------------------------------------------------< HierarchyManager >---
    /**
     * @see HierarchyManager#dispose()
     */
    public void dispose() {
        uniqueIdResolver.dispose();
    }

    /**
     * @see HierarchyManager#getRootEntry()
     */
    public NodeEntry getRootEntry() {
        return rootEntry;
    }

    /**
     * @see HierarchyManager#lookup(ItemId)
     */
    public HierarchyEntry lookup(ItemId workspaceItemId) {
        String uniqueID = workspaceItemId.getUniqueID();
        if (uniqueID == null) {
            return rootEntry.lookupDeepEntry(workspaceItemId.getPath());
        } else {
            NodeEntry nEntry = uniqueIdResolver.lookup(uniqueID);
            Path path = workspaceItemId.getPath();
            if (path == null) {
                return nEntry;
            } else {
                return nEntry != null ? nEntry.lookupDeepEntry(path) : null;
            }
        }
    }

    /**
     * @see HierarchyManager#lookup(Path)
     */
    public HierarchyEntry lookup(Path workspacePath) {
        return rootEntry.lookupDeepEntry(workspacePath);
    }

    /**
     * @see HierarchyManager#getNodeEntry(NodeId)
     */
    public NodeEntry getNodeEntry(NodeId nodeId)
            throws ItemNotFoundException, RepositoryException {
        String uniqueID = nodeId.getUniqueID();
        if (uniqueID == null) {
            return getNodeEntry(nodeId.getPath());
        } else {
            if (nodeId.getPath() == null) {
                NodeEntry nEntry = uniqueIdResolver.resolve(nodeId, rootEntry);
                return nEntry;
            } else {
                NodeEntry nEntry = uniqueIdResolver.resolve(idFactory.createNodeId(uniqueID), rootEntry);
                return nEntry.getDeepNodeEntry(nodeId.getPath());
            }
        }
    }

    /**
     * @see HierarchyManager#getNodeEntry(Path)
     */
    public NodeEntry getNodeEntry(Path qPath) throws PathNotFoundException, RepositoryException {
        NodeEntry rootEntry = getRootEntry();
        // shortcut
        if (qPath.denotesRoot()) {
            return rootEntry;
        }
        if (!qPath.isCanonical()) {
            String msg = "Path is not canonical";
            log.debug(msg);
            throw new RepositoryException(msg);
        }
        return rootEntry.getDeepNodeEntry(qPath);
    }

    /**
     * @see HierarchyManager#getPropertyEntry(PropertyId)
     */
    public PropertyEntry getPropertyEntry(PropertyId propertyId)
            throws ItemNotFoundException, RepositoryException {
        String uniqueID = propertyId.getUniqueID();
        if (uniqueID == null) {
            return getPropertyEntry(propertyId.getPath());
        } else {
            if (propertyId.getPath() == null) {
                // a property id always contains a Path part.
                throw new ItemNotFoundException("No property found for id " + LogUtil.saveGetIdString(propertyId, resolver));
            } else {
                NodeEntry nEntry = uniqueIdResolver.resolve(idFactory.createNodeId(uniqueID), rootEntry);
                return nEntry.getDeepPropertyEntry(propertyId.getPath());
            }
        }
    }

    /**
     * @see HierarchyManager#getPropertyEntry(Path)
     */
    public PropertyEntry getPropertyEntry(Path qPath)
            throws PathNotFoundException, RepositoryException {
        // shortcut
        if (qPath.denotesRoot()) {
            throw new PathNotFoundException("The root path never points to a Property.");
        }
        if (!qPath.isCanonical()) {
            String msg = "Path is not canonical";
            log.debug(msg);
            throw new RepositoryException(msg);
        }
        return getRootEntry().getDeepPropertyEntry(qPath);
    }

    /**
     * @see HierarchyManager#getNodeState(Path)
     */
    public NodeState getNodeState(Path qPath) throws PathNotFoundException, RepositoryException {
        NodeEntry entry = getNodeEntry(qPath);
        try {
            NodeState state = entry.getNodeState();
            if (state.isValid()) {
                return state;
            } else {
                throw new PathNotFoundException(LogUtil.safeGetJCRPath(qPath, resolver));
            }
        } catch (ItemNotFoundException e) {
            throw new PathNotFoundException(e);
        }
    }

    /**
     * @see HierarchyManager#getPropertyState(Path)
     */
    public PropertyState getPropertyState(Path qPath) throws PathNotFoundException, RepositoryException {
        PropertyEntry entry = getPropertyEntry(qPath);
        try {
            PropertyState state = entry.getPropertyState();
            if (state.isValid()) {
                return state;
            } else {
                throw new PathNotFoundException(LogUtil.safeGetJCRPath(qPath, resolver));
            }
        } catch (ItemNotFoundException e) {
            throw new PathNotFoundException(e);
        }
    }

    /**
     * @see HierarchyManager#getDepth(HierarchyEntry)
     */
    public int getDepth(HierarchyEntry hierarchyEntry) throws ItemNotFoundException, RepositoryException {
        int depth = Path.ROOT_DEPTH;
        NodeEntry parentEntry = hierarchyEntry.getParent();
        while (parentEntry != null) {
            depth++;
            hierarchyEntry = parentEntry;
            parentEntry = hierarchyEntry.getParent();
        }
        return depth;
    }

    /**
     * @see HierarchyManager#getRelativeDepth(NodeEntry, HierarchyEntry)
     */
    public int getRelativeDepth(NodeEntry ancestor, HierarchyEntry descendant)
            throws ItemNotFoundException, RepositoryException {
        if (ancestor.equals(descendant)) {
            return 0;
        }
        int depth = 1;
        NodeEntry parent = descendant.getParent();
        while (parent != null) {
            if (parent.equals(ancestor)) {
                return depth;
            }
            depth++;
            descendant = parent;
            parent = descendant.getParent();
        }
        // not an ancestor
        return -1;
    }
}