public DependentLoaderImplementation cloneLoader(
DependentLoader loader, String aditionalDependency) {
DependentLoaderImplementation otherAsImplementation = (DependentLoaderImplementation) loader;
DependentLoaderImplementation newLoader =
new DependentLoaderImplementation(
otherAsImplementation.artifact,
loader.getURLs(),
exposed,
otherAsImplementation.parent);
newLoader.dependencies = otherAsImplementation.dependencies;
if (!"".equals(aditionalDependency)) {
DependentLoaderImplementation dependency =
enshureDependencyJarLoaded(otherAsImplementation.artifact, aditionalDependency);
ArrayList<DependentLoaderImplementation> depList =
new ArrayList<DependentLoaderImplementation>();
for (DependentLoaderImplementation dependentLoaderImplementation : newLoader.dependencies) {
depList.add(dependentLoaderImplementation);
}
depList.add(dependency);
newLoader.setDependencies(depList.toArray(new DependentLoaderImplementation[depList.size()]));
}
visitLoader(newLoader);
return newLoader;
}
private boolean startLauncher(File dir) {
try {
Runtime rt = Runtime.getRuntime();
ArrayList<String> command = new ArrayList<String>();
command.add("java");
command.add("-jar");
command.add("Launcher.jar");
String[] cmdarray = command.toArray(new String[command.size()]);
Process proc = rt.exec(cmdarray, null, dir);
return true;
} catch (Exception ex) {
System.err.println("Unable to start the Launcher program.\n" + ex.getMessage());
return false;
}
}
public Object tryArgument(String arg) throws Exception {
try {
ArrayList<Object> retval = new ArrayList<Object>();
String[] values = arg.split(separator);
if (values.length == 0) {
throw new Exception("Invalid argument");
}
if (values.length == 1) {
return handler.tryArgument(values[0]);
}
if (values.length > maxEntries) {
throw new Exception(String.format("Cannot exceed %d entries", maxEntries));
}
for (String v : values) {
Object param = handler.tryArgument(v);
if (param == null) {
throw new Exception(String.format("Invalid member of list: %s", v));
}
retval.add(param);
}
return retval;
} catch (Exception e) {
throw e;
}
}
private ArrayList<Path> holeLaufwerkeUnix() {
ArrayList<Path> laufwerksRoot = new ArrayList<>();
for (FileStore store : FileSystems.getDefault().getFileStores()) {
if (store.name().contains("/dev/sd")) {
laufwerksRoot.add(
Paths.get(store.toString().substring(0, store.toString().indexOf(' '))));
}
}
return laufwerksRoot;
}
private ArrayList<Path> holeLaufwerkeWindows() {
ArrayList<Path> laufwerksRoot = new ArrayList<>();
Iterable<Path> rootDirectories = FileSystems.getDefault().getRootDirectories();
for (Path path : rootDirectories) {
laufwerksRoot.add(path.getRoot());
}
return laufwerksRoot;
}
public DependentLoaderImplementation[] getLoaded(String filter) {
DefaultArtifact asArtifact = new DefaultArtifact(filter);
DependentLoaderImplementation theLoader = findOverride(asArtifact);
if (theLoader != null) {
DependentLoaderImplementation[] retVal = {theLoader};
return retVal;
}
if (loaderMap.containsKey(filter)) {
DependentLoaderImplementation[] retVal = {loaderMap.get(filter)};
return retVal;
}
ArrayList<DependentLoaderImplementation> result = new ArrayList();
for (String key : loaderMap.keySet()) {
if (key.startsWith(filter)) {
result.add(loaderMap.get(key));
}
}
;
return Arrays.copyOf(result.toArray(), result.size(), DependentLoaderImplementation[].class);
}
public PalindromeTest() {
ArrayList<String> words = new ArrayList<String>();
ArrayList<String> palis;
try {
for (String line : Files.readAllLines(Paths.get("com/jsanders/web2"))) {
words.add(line);
}
} catch (IOException ex) {
System.out.println("IO error");
System.exit(1);
}
palis = Palindrome.palindromes(words);
assertEquals(palis.size(), 161, 0.01);
int shortest = Word.shortestLength(words);
assertEquals(shortest, 1, 0.01);
int longest = Word.longestLength(words);
assertEquals(longest, 24, 0.01);
ArrayList<String> shortestWords = Word.shortestWords(words);
assertEquals(shortestWords.size(), 52, 0.01);
ArrayList<String> longestWords = Word.longestWords(words);
assertEquals(longestWords.size(), 5, 0.01);
int totalWords = Word.totalWords(words);
double avgLen = Word.averageLength(words);
assertEquals(totalWords, 235886, 0.01);
assertEquals(avgLen, 9.56, 0.01);
ArrayList<Double> letterFreq = Word.letterFrequency(words);
assertEquals(letterFreq.get(0), 0.087, 0.01);
double properFreq = Word.properFrequency(words);
assertEquals(properFreq, 0.106, 0.01);
ArrayList<Integer> startFreq = Word.startFrequency(words);
assertEquals(startFreq.get(0), 17096, 0.01);
ArrayList<String> sameStartEnd = Word.startEndWords(words);
assertEquals(sameStartEnd.size(), 11505, 0.01);
try {
PrintWriter f = new PrintWriter("short.txt");
for (String w : shortestWords) f.println(w);
f.close();
f = new PrintWriter("long.txt");
for (String w : longestWords) f.println(w);
f.close();
f = new PrintWriter("same.txt");
for (String w : sameStartEnd) f.println(w);
f.close();
f = new PrintWriter("statistics.txt");
f.println("avg word len: " + avgLen);
f.println("freq of letters: " + letterFreq);
f.println("freq of proper nouns/names: " + properFreq);
f.println("words that start with each letter:: " + startFreq);
f.close();
} catch (IOException ex) {
System.out.println("IO error");
System.exit(1);
}
}
/** Decode the buffer, returning an ACL */
private static List<AclEntry> decode(long address, int n) {
ArrayList<AclEntry> acl = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
long offset = address + i * SIZEOF_ACE_T;
int uid = unsafe.getInt(offset + OFFSETOF_UID);
int mask = unsafe.getInt(offset + OFFSETOF_MASK);
int flags = (int) unsafe.getShort(offset + OFFSETOF_FLAGS);
int type = (int) unsafe.getShort(offset + OFFSETOF_TYPE);
// map uid and flags to UserPrincipal
UnixUserPrincipals.User who = null;
if ((flags & ACE_OWNER) > 0) {
who = UnixUserPrincipals.SPECIAL_OWNER;
} else if ((flags & ACE_GROUP) > 0) {
who = UnixUserPrincipals.SPECIAL_GROUP;
} else if ((flags & ACE_EVERYONE) > 0) {
who = UnixUserPrincipals.SPECIAL_EVERYONE;
} else if ((flags & ACE_IDENTIFIER_GROUP) > 0) {
who = UnixUserPrincipals.fromGid(uid);
} else {
who = UnixUserPrincipals.fromUid(uid);
}
AclEntryType aceType = null;
switch (type) {
case ACE_ACCESS_ALLOWED_ACE_TYPE:
aceType = AclEntryType.ALLOW;
break;
case ACE_ACCESS_DENIED_ACE_TYPE:
aceType = AclEntryType.DENY;
break;
case ACE_SYSTEM_AUDIT_ACE_TYPE:
aceType = AclEntryType.AUDIT;
break;
case ACE_SYSTEM_ALARM_ACE_TYPE:
aceType = AclEntryType.ALARM;
break;
default:
assert false;
}
Set<AclEntryPermission> aceMask = EnumSet.noneOf(AclEntryPermission.class);
if ((mask & ACE_READ_DATA) > 0) aceMask.add(AclEntryPermission.READ_DATA);
if ((mask & ACE_WRITE_DATA) > 0) aceMask.add(AclEntryPermission.WRITE_DATA);
if ((mask & ACE_APPEND_DATA) > 0) aceMask.add(AclEntryPermission.APPEND_DATA);
if ((mask & ACE_READ_NAMED_ATTRS) > 0) aceMask.add(AclEntryPermission.READ_NAMED_ATTRS);
if ((mask & ACE_WRITE_NAMED_ATTRS) > 0) aceMask.add(AclEntryPermission.WRITE_NAMED_ATTRS);
if ((mask & ACE_EXECUTE) > 0) aceMask.add(AclEntryPermission.EXECUTE);
if ((mask & ACE_DELETE_CHILD) > 0) aceMask.add(AclEntryPermission.DELETE_CHILD);
if ((mask & ACE_READ_ATTRIBUTES) > 0) aceMask.add(AclEntryPermission.READ_ATTRIBUTES);
if ((mask & ACE_WRITE_ATTRIBUTES) > 0) aceMask.add(AclEntryPermission.WRITE_ATTRIBUTES);
if ((mask & ACE_DELETE) > 0) aceMask.add(AclEntryPermission.DELETE);
if ((mask & ACE_READ_ACL) > 0) aceMask.add(AclEntryPermission.READ_ACL);
if ((mask & ACE_WRITE_ACL) > 0) aceMask.add(AclEntryPermission.WRITE_ACL);
if ((mask & ACE_WRITE_OWNER) > 0) aceMask.add(AclEntryPermission.WRITE_OWNER);
if ((mask & ACE_SYNCHRONIZE) > 0) aceMask.add(AclEntryPermission.SYNCHRONIZE);
Set<AclEntryFlag> aceFlags = EnumSet.noneOf(AclEntryFlag.class);
if ((flags & ACE_FILE_INHERIT_ACE) > 0) aceFlags.add(AclEntryFlag.FILE_INHERIT);
if ((flags & ACE_DIRECTORY_INHERIT_ACE) > 0) aceFlags.add(AclEntryFlag.DIRECTORY_INHERIT);
if ((flags & ACE_NO_PROPAGATE_INHERIT_ACE) > 0)
aceFlags.add(AclEntryFlag.NO_PROPAGATE_INHERIT);
if ((flags & ACE_INHERIT_ONLY_ACE) > 0) aceFlags.add(AclEntryFlag.INHERIT_ONLY);
// build the ACL entry and add it to the list
AclEntry ace =
AclEntry.newBuilder()
.setType(aceType)
.setPrincipal(who)
.setPermissions(aceMask)
.setFlags(aceFlags)
.build();
acl.add(ace);
}
return acl;
}