Java tutorial
/* * 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.standalone.cli; import java.io.PrintWriter; import java.util.Iterator; import java.util.ResourceBundle; import javax.jcr.Item; import javax.jcr.Node; import javax.jcr.NodeIterator; import javax.jcr.PathNotFoundException; import javax.jcr.PropertyIterator; import javax.jcr.Repository; import javax.jcr.RepositoryException; import javax.jcr.Session; import org.apache.commons.chain.Context; import org.apache.commons.collections.IteratorUtils; /** * Utility class for getting and setting context attributes. */ public final class CommandHelper { /** bundle */ private static ResourceBundle bundle = ResourceBundle .getBundle(CommandHelper.class.getPackage().getName() + ".resources"); /** Current node key */ public static final String CURRENT_NODE_KEY = "jcr.current"; /** repository key */ public static final String REPOSITORY_KEY = "jcr.repository"; /** session key */ public static final String SESSION_KEY = "jcr.session"; /** output key */ public static final String OUTPUT_KEY = "jcr.output"; /** address key */ public static final String REPO_ADDRESS_KEY = "jcr.repo.address"; /** * should never get called */ private CommandHelper() { super(); } /** * Sets the current <code>PrintWriter</code>. * @param ctx * the <code>Context</code> * @param out * the <code>PrintWriter</code> */ public static void setOutput(Context ctx, PrintWriter out) { if (out == null) { ctx.remove(OUTPUT_KEY); } else { ctx.put(OUTPUT_KEY, out); } } /** * Sets the current working <code>Node</code>. * @param ctx * the <code>Context</code> * @param node * the current working <code>Node</code>. */ public static void setCurrentNode(Context ctx, Node node) { if (node == null) { ctx.remove(CURRENT_NODE_KEY); } else { ctx.put(CURRENT_NODE_KEY, node); } } /** * Sets the current working <code>Repository</code> * @param ctx * the <code>Context</code> * @param repository * the current working <code>Repository</code> */ public static void setRepository(Context ctx, Repository repository, String address) { if (repository == null) { ctx.remove(REPOSITORY_KEY); ctx.remove(REPO_ADDRESS_KEY); } else { ctx.put(REPOSITORY_KEY, repository); ctx.put(REPO_ADDRESS_KEY, address); } } /** * Sets the current working <code>Session</code> * @param ctx * the <code>Context</code> * @param session * the current working <code>Session</code> * @throws CommandException if there's an open working <code>Session</code> */ public static void setSession(Context ctx, Session session) throws CommandException { if (session == null) { ctx.remove(SESSION_KEY); } else { if (ctx.get(SESSION_KEY) != null) { throw new CommandException("exception.already.logged.in"); } ctx.put(SESSION_KEY, session); } } /** * Gets the current <code>PrintWriter</code> * @param ctx * the <code>Context</code> * @return the current <code>PrintWriter</code> */ public static PrintWriter getOutput(Context ctx) { PrintWriter out = (PrintWriter) ctx.get(OUTPUT_KEY); if (out == null) { out = new PrintWriter(System.out, true); } return out; } /** * Gets the current working <code>Node</code> * @param ctx * the <code>Context</code> * @return the current working <code>Node</code> * @throws CommandException * if the current working <code>Node</code> can't be found. */ public static Node getCurrentNode(Context ctx) throws CommandException { Node n = (Node) ctx.get(CURRENT_NODE_KEY); if (n == null) { throw new CommandException("exception.no.current.node"); } return n; } /** * Gets the current working <code>Repository</code> * @param ctx * the <code>Context</code> * @return the current working <code>Repository</code> * @throws CommandException * if the current working <code>Repository</code> is unset. */ public static Repository getRepository(Context ctx) throws CommandException { Repository r = (Repository) ctx.get(REPOSITORY_KEY); if (r == null) { throw new CommandException("exception.no.current.repository"); } return r; } public static String getRepositoryAddress(Context ctx) throws CommandException { String a = (String) ctx.get(REPO_ADDRESS_KEY); if (a == null) { throw new CommandException("exception.no.current.repository"); } return a; } /** * Gets the current working <code>Session</code> * @param ctx * the <code>Context</code> * @return the current working <code>Session</code> * @throws CommandException * if the current working <code>Session</code> is unset. */ public static Session getSession(Context ctx) throws CommandException { Session s = (Session) ctx.get(SESSION_KEY); if (s == null) { throw new CommandException("exception.no.current.session"); } return s; } /** * Gets the <code>Node</code> at the given path. * @param ctx * the <code>Context</code> * @param path * the path to the <code>Node</code> * @return the <code>Node</code> at the given path * @throws CommandException * if the <code>Node</code> isn't found. * @throws RepositoryException * if the underlying repository throws a * <code>RepositoryException</code> */ public static Node getNode(Context ctx, String path) throws CommandException, RepositoryException { try { Item i = getItem(ctx, path); if (!i.isNode()) { throw new CommandException("exception.no.node.at", new String[] { path }); } return (Node) i; } catch (PathNotFoundException e) { throw new CommandException("exception.no.node.at", new String[] { path }); } } /** * Gets the <code>Item</code> at the given path. <br> * If the path is null it returns the current working <code>Node</code>. * @param ctx * the <code>Context</code> * @param path * the path to the <code>Item</code> * @return the <code>Item</code> at the given path * @throws CommandException * if a <code>Command</code> internal error occurs. * @throws PathNotFoundException * if there's no <code>Node</code> at the given path. * @throws RepositoryException * if the underlying repository throws a * <code>RepositoryException</code> */ public static Item getItem(Context ctx, String path) throws CommandException, PathNotFoundException, RepositoryException { Node current = getCurrentNode(ctx); Item i = null; if (path == null) { i = current; } else if (path.equals("/")) { i = current.getSession().getRootNode(); } else if (path.startsWith("/")) { i = current.getSession().getItem(path); } else { String newPath = current.getPath(); // handle the root node if (!newPath.endsWith("/")) { newPath += "/"; } newPath += path; i = current.getSession().getItem(newPath); } return i; } /** * Checks <code>Node</code> existence. * @param ctx * the <code>Context</code> * @param path * the path to the <code>Node</code> * @return true if the <code>Node</code> exists at the given path * @throws CommandException * if the current working <code>Session</code> is unset. * @throws RepositoryException * if the underlying repository throws a * <code>RepositoryException</code> */ public static boolean hasNode(Context ctx, String path) throws CommandException, RepositoryException { Session s = getSession(ctx); if (path.equals("/")) { return true; } else if (path.startsWith("/")) { return s.getRootNode().hasNode(path.substring(1)); } else { Node current = (Node) ctx.get(CURRENT_NODE_KEY); return current.hasNode(path); } } /** * Gets the <code>Node</code> s under the given <code>Node</code> that * match the given pattern. * @param ctx * the <code>Context</code> * @param node * the parent <code>Node</code> * @param pattern * the pattern * @return an <code>Iterator</code> that contains the matching nodes * @throws RepositoryException * if the underlying repository throws a * <code>RepositoryException</code> */ public static NodeIterator getNodes(Context ctx, Node node, String pattern) throws RepositoryException { if (pattern != null) { return node.getNodes(pattern); } else { return node.getNodes(); } } /** * Gets the <code>Property</code> s under the current working node for the * given pattern * @param ctx * the <code>Context</code> * @param node * the parent <code>Node</code> * @param pattern * the pattern * @return a <code>PropertyIterator</code> * @throws RepositoryException * if the underlying repository throws a * <code>RepositoryException</code> */ public static PropertyIterator getProperties(Context ctx, Node node, String pattern) throws RepositoryException { if (pattern != null) { return node.getProperties(pattern); } else { return node.getProperties(); } } /** * @return the default <code>ResourceBundle</code> */ public static ResourceBundle getBundle() { return bundle; } /** * Gets the <code>Item</code> s under the given <code>Node</code> that * match the pattern * @param ctx * the <code>Context</code> * @param node * the parent <code>Node</code> * @param pattern * the pattern * @return an <code>Iterator</code> with the <code>Item</code> s that * match the given pattern. * @throws RepositoryException * if the underlying repository throws a * <code>RepositoryException</code> */ public static Iterator getItems(Context ctx, Node node, String pattern) throws RepositoryException { return IteratorUtils.chainedIterator(getNodes(ctx, node, pattern), getProperties(ctx, node, pattern)); } }