/*
* Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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 General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.apple.internal.jobjc.generator;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Pattern;
import com.apple.internal.jobjc.generator.model.Framework;
import com.apple.internal.jobjc.generator.model.Framework.FrameworkDependency;
import com.apple.internal.jobjc.generator.utils.Fp;
public class Utils {
public static boolean isLeopard = System.getProperty("os.version").startsWith("10.5");
public static boolean isSnowLeopard = System.getProperty("os.version").startsWith("10.6");
@SuppressWarnings("unchecked")
public static <T> List<T> list(final Object...args) {
final ArrayList<Object> list = new ArrayList<Object>(args.length);
for (final Object arg : args) list.add(arg);
return (List<T>)list;
}
/**
* A small implementation of UNIX find.
* @param matchRegex Only collect paths that match this regex.
* @param pruneRegex Don't recurse down a path that matches this regex. May be null.
* @throws IOException if File.getCanonicalPath() fails.
*/
public static List<File> find(final File startpath, final String matchRegex, final String pruneRegex) throws IOException{
final Pattern matchPattern = Pattern.compile(matchRegex, Pattern.CASE_INSENSITIVE);
final Pattern prunePattern = pruneRegex == null ? null : Pattern.compile(pruneRegex, Pattern.CASE_INSENSITIVE);
final Set<String> visited = new HashSet<String>();
final List<File> found = new ArrayList<File>();
class Search{
void search(final File path) throws IOException{
if(prunePattern != null && prunePattern.matcher(path.getAbsolutePath()).matches()) return;
String cpath = path.getCanonicalPath();
if(!visited.add(cpath)) return;
if(matchPattern.matcher(path.getAbsolutePath()).matches())
found.add(path);
if(path.isDirectory())
for(File sub : path.listFiles())
search(sub);
}
}
new Search().search(startpath);
return found;
}
public static String joinWComma(final List<?> list) { return Fp.join(", ", list); }
public static String joinWComma(final Object[] list) { return Fp.join(", ", Arrays.asList(list)); }
public static class Substituter {
String str;
public Substituter(final String str) {
this.str = str.replaceAll("\\#", "\t").replaceAll("\\~", "\n");
}
public void replace(final String key, final String value) {
str = str.replaceAll("\\$" + key, value);
}
/**
* Apply String.format first, and then pass through Substituter.
*/
public static String format(String format, Object... args){
return new Substituter(String.format(format, args)).toString();
}
@Override public String toString() {
return str;
}
}
static Map<String, String> getArgs(final String...args) {
final Map<String, String> argMap = new HashMap<String, String>();
for (final String arg : args) {
final String[] splitArg = arg.split("\\=");
if (splitArg.length != 2) continue;
argMap.put(splitArg[0], splitArg[1]);
}
return argMap;
}
static void recDelete(final File file) {
if (!file.exists()) return;
if (file.isDirectory()) for (final File f : file.listFiles()) recDelete(f);
file.delete();
}
public static String capitalize(String s){
if(s.length() == 0) return s;
return Character.toString(Character.toUpperCase(s.charAt(0))) + s.substring(1);
}
/**
* Sort frameworks by dependencies. If A is a dependency of B,
* then A will come before B in the list.
*/
public static void topologicalSort(final List<Framework> frameworks) {
final Set<Framework> visited = new TreeSet<Framework>();
final List<Framework> sorted = new ArrayList<Framework>(frameworks.size());
class Rec{
void visit(final Framework fw){
if(!visited.add(fw)) return;
for(FrameworkDependency dep : fw.dependencies)
if(dep.object != null)
visit(dep.object);
sorted.add(fw);
}
}
for(Framework fw : frameworks) new Rec().visit(fw);
frameworks.clear();
frameworks.addAll(sorted);
}
/**
* If there is a cycle it is returned. Otherwise null is returned.
*/
public static List<Framework> getDependencyCycle(List<Framework> frameworks) {
@SuppressWarnings("serial")
class FoundCycle extends Throwable{
public final List<Framework> cycle;
public FoundCycle(List<Framework> cycle){
this.cycle = cycle;
}
};
class Rec{
void visit(final Framework fw, List<Framework> visited) throws FoundCycle{
visited = new LinkedList<Framework>(visited);
if(visited.contains(fw)){
visited.add(fw);
throw new FoundCycle(visited);
}
visited.add(fw);
for(FrameworkDependency dep : fw.dependencies)
if(dep.object != null)
visit(dep.object, visited);
}
}
try{ for(Framework fw : frameworks){ new Rec().visit(fw, new LinkedList<Framework>()); }}
catch(FoundCycle x){ return x.cycle; }
return null;
}
public static String getCanonicalPath(File file) throws RuntimeException{
try {
return file.getCanonicalPath();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}