Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.fs;
 
 
 import java.util.List;
 import java.util.Map;

Copy configuration and command.
 
 public class Copy {
     public static final char DEFAULT_CONTEXT_DELIMITER = ':';
     public static final char DEFAULT_CALL_PREFIX = '@';
     public static final Substitution DEFAULT_SUBST = new Substitution("${{""}}"'\\');
     
     private static final String CONTEXT = "context";
     private static final String CALL = "call";
     
     private final Node sourcedir;

    
applied to sourcedir
 
 	private final Filter filter;
 
 	private final boolean modes;
 	
     private final Substitution path;
     private final Substitution content;
     private final Map<StringStringrootVariables;
     
     private final char contextDelimiter;
     private final Map<CharacterMethodcontextConstructors;
     private final char callPrefix;
     private final Map<StringMethodcalls;
     
 	public Copy(Node srcdir) {
 		this(srcdirsrcdir.getWorld().filter().includeAll());
 	}
 	
     public Copy(Node srcdirFilter filter) {
         this(srcdirfilterfalse);
     }
     
     public Copy(Node srcdirFilter filterboolean modes) {
         this(srcdirfiltermodesnullnull);
     }
     
     public Copy(Node srcdirFilter filterboolean modesMap<StringStringvariables) {
         this(srcdirfiltermodesvariablesvariables == null ? null : );
     }
 
     public Copy(Node srcdirFilter filterboolean modesMap<StringStringvariablesSubstitution subst) {
         this(srcdirfiltermodesvariablessubstsubst
                 variables == null ? 0 : 
                 variables == null ? 0 : );
     }
 
     public Copy(Node srcdirFilter filterboolean modesMap<StringStringvariablesSubstitution pathSubstitution contentchar contextDelimiterchar callPrefix) {
 	    this. = srcdir;
         this. = filter;
         this. = modes;
 		this. = path;
 		this. = content;
 		this. = variables;
 		this. = contextDelimiter;
         this. = new HashMap<CharacterMethod>();
         this. = callPrefix;
         this. = new HashMap<StringMethod>();
         if (!getClass().equals(Copy.class)) {
             initReflection();
         }
     }
     
     private void initReflection() {
         String name;
         char c;
         
        for (Method m : getClass().getDeclaredMethods()) {
            name = m.getName();
            if (name.startsWith()) {
                c = Character.toUpperCase(name.substring(.length()).charAt(0));                
                if (.put(cm) != null) {
                    throw new IllegalArgumentException("duplicate context character: " + c);
                }
            } else if (name.startsWith()) {
                name = name.substring(.length()).toLowerCase();
                if (.put(namem) != null) {
                    throw new IllegalArgumentException("duplicate call: " + name);
                }
            }
        }
    }
	public Node getSourceDir() {
	    return ;
	}

Returns:
Target files or directories created.
	public List<Nodedirectory(Node destdirthrows CopyException {
        List<Noderesult;
        TreeAction action;
        Tree tree;
        
        result = new ArrayList<Node>();
        try {
            .checkDirectory();
            destdir.checkDirectory();
            action = new TreeAction();
            .invoke(action);
        } catch (IOException e) {
            throw new CopyException(destdir"scanning source files failed"e);
        }
		tree = action.getResult();
		if (tree != null) {
		    for (Tree child : tree.children) {
		        copy(destdirchildresult);
		    }
		}
		return result;
	}
	private void copy(Node srcParentNode destParentTree srcList<NoderesultMap<StringStringparentVariablesthrows CopyException {
	    String name;
        Node dest;
        List<Map<StringString>> childVariablesList;
        boolean isDir;
        
        name = src.node.getName();
        dest = null;
        try {
            if ( != 0 && name.length() > 0 && name.charAt(0) == ) {
                result.add(call(namesrc.nodedestParentparentVariables));
            } else {
                childVariablesList = new ArrayList<Map<StringString>>();
                name = splitContext(nameparentVariableschildVariablesList);
                isDir = src.node.isDirectory();
                for (Map<StringStringchildVariables : childVariablesList) {
                    dest = destParent.join( == null ? name : .apply(namechildVariables));
                    if (isDir) {
                        dest.mkdirsOpt();
                    } else {
                        dest.getParent().mkdirsOpt();
                        if ( != null) {
                            dest.writeString(.apply(src.node.readString(), childVariables));
                        } else {
                            src.node.copyFile(dest);
                        }
                    }
                    if () {
                        dest.setMode(src.node.getMode());
                    }
                    result.add(dest);
                    for (Tree child : src.children) {
                        copy(src.nodedestchildresultchildVariables);
                    }
                }
            }
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            if (dest == null) {
                dest = destParent.join(name);
            }
            throw new CopyException(src.nodedeste);
        }
	}
    private Node call(String nameNode srcNode destParentMap<StringStringcontextthrows ReflectionExceptionIOException {
        String fileName;
        String methodName;
        Method m;
        Node dest;
        
        fileName = name.substring(1);
        methodName = normalize(fileName);
        m = .get(methodName);
        if (m == null) {
            throw new ReflectionException("unknown call: " + methodName + " (defined: " + .keySet() + ")");
        }
        dest = destParent.join(fileName);
        if (src.isDirectory()) {
            dest.mkdirsOpt();
            doInvoke(mdestcontext);
        } else {
            dest.writeString((StringdoInvoke(mcontext));
        }
        return dest;
    }
    private static String normalize(String str) {
        StringBuilder builder;
        char ch;
        
        builder = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            ch = str.charAt(i);
            if (Character.isJavaIdentifierPart(ch)) {
                builder.append(Character.toLowerCase(ch));
            }
        }
        return builder.toString();
    }
    
    private String splitContext(String nameMap<StringStringparentList<Map<StringString>> resultthrows ReflectionException {
        int idx;
        char c;
        Method m;
        
        result.add(parent);
        if ( == 0) {
            return name;
        }
        idx = name.indexOf();
        if (idx == -1) {
            return name;
        }
        for (int i = 0; i < idxi++) {
            c = name.charAt(i);
            m = .get(name.charAt(i));
            if (m == null) {
                throw new ReflectionException("unknown context: " + c + " (defined: " + .keySet() + ")");
            }
            apply(mresult);
        }
        return name.substring(idx + 1);
    }
    
    private void apply(Method mList<Map<StringString>> contextsthrows ReflectionException {
        List<Map<StringString>> tmp;
        
        tmp = new ArrayList<Map<StringString>>(contexts);
        contexts.clear();
        for (Map<StringStringmap : tmp) {
            context(mmapcontexts);
        }
    }
    private void context(Method mMap<StringStringparentList<Map<StringString>> resultthrows ReflectionException {
        result.addAll((List<Map<StringString>>) doInvoke(mparent));
    }
    private Object doInvoke(Method mObject ... argsthrows ReflectionException {
        try {
            return m.invoke(thisargs);
        } catch (InvocationTargetException e) {
            throw new ReflectionException(m.getName() + " failed: " + e.getMessage(), e.getTargetException());
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException(m.getName() + ": " + e.getMessage(), e);
        } catch (IllegalAccessException e) {
            throw new IllegalStateException(e);
        }
    }
New to GrepCode? Check out our FAQ X