org.apache.jackrabbit.commons.AbstractItem Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jackrabbit-jcr-commons Show documentation
General purpose classes for use with the JCR API
The newest version!
/*
 * 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.commons;

import javax.jcr.AccessDeniedException;
import javax.jcr.Item;
import javax.jcr.ItemNotFoundException;
import javax.jcr.RepositoryException;

/**
 * Abstract base class for implementing the JCR {@link Item} interface.
 * 
 * {@link Item} methods without a default implementation:
 * 

 *   {@link Item#accept(javax.jcr.ItemVisitor)}
 *   {@link Item#getName()}
 *   {@link Item#getParent()}
 *   {@link Item#getPath()}
 *   {@link Item#getSession()}
 *   {@link Item#isModified()}
 *   {@link Item#isNew()}
 *   {@link Item#isNode()}
 *   {@link Item#isSame(Item)}
 *   {@link Item#refresh(boolean)}
 *   {@link Item#remove()}
 *   {@link Item#save()}
 * 
 */
public abstract class AbstractItem implements Item {

    /**
     * Returns the ancestor of this item at the given depth.
     * 
     * The default implementation handles the root node at depth zero and
     * this item at depth equal to the depth of this item as special cases,
     * and uses {@link javax.jcr.Session#getItem(String)} to retrieve other
     * ancestors based on the ancestor path calculated from the path of this
     * node as returned by {@link Item#getPath()}.
     *
     * @param depth depth of the returned ancestor item
     * @return ancestor item
     * @throws ItemNotFoundException if the given depth is negative or greater
     *                               than the depth of this item
     * @throws AccessDeniedException if access to the ancestor item is denied
     * @throws RepositoryException if an error occurs
     */
    public Item getAncestor(int depth)
            throws ItemNotFoundException, AccessDeniedException,
            RepositoryException {
        if (depth < 0) {
            throw new ItemNotFoundException(
                    this + ": Invalid ancestor depth (" + depth + ")");
        } else if (depth == 0) {
            return getSession().getRootNode();
        }

        String path = getPath();
        int slash = 0;
        for (int i = 0; i < depth - 1; i++) {
            slash = path.indexOf('/', slash + 1);
            if (slash == -1) {
                throw new ItemNotFoundException(
                        this + ": Invalid ancestor depth (" + depth + ")");
            }
        }
        slash = path.indexOf('/', slash + 1);
        if (slash == -1) {
            return this;
        }

        try {
            return getSession().getItem(path.substring(0, slash));
        } catch (ItemNotFoundException e) {
            throw new AccessDeniedException(
                    this + ": Ancestor access denied (" + depth + ")");
        }
    }

    /**
     * Returns the depth of this item.
     * 

     * The default implementation determines the depth by counting the
     * slashes in the path returned by {@link Item#getPath()}.
     *
     * @return depth of this item
     * @throws RepositoryException if an error occurs
     */
    public int getDepth() throws RepositoryException {
        String path = getPath();
        if (path.length() == 1) {
            return 0;
        } else {
            int depth = 1;
            int slash = path.indexOf('/', 1);
            while (slash != -1) {
                depth++;
                slash = path.indexOf('/', slash + 1);
            }
            return depth;
        }
    }

    //--------------------------------------------------------------< Object >

    /**
     * Returns a string representation of this item.
     * 
     * The default implementation returns the path of this item and falls
     * back to the {@link Object#toString()} implementation if the item path
     * can not be retrieved.
     *
     * @return string representation of this item
     */
    public String toString() {
        try {
            return getPath();
        } catch (RepositoryException e) {
            return super.toString();
        }
    }

}