@NotNull
@Override
public SuggestedNameInfo suggestUniqueVariableName(
@NotNull final SuggestedNameInfo baseNameInfo,
PsiElement place,
boolean ignorePlaceName,
boolean lookForward) {
final String[] names = baseNameInfo.names;
final LinkedHashSet<String> uniqueNames = new LinkedHashSet<String>(names.length);
for (String name : names) {
if (ignorePlaceName && place instanceof PsiNamedElement) {
final String placeName = ((PsiNamedElement) place).getName();
if (Comparing.strEqual(placeName, name)) {
uniqueNames.add(name);
continue;
}
}
uniqueNames.add(suggestUniqueVariableName(name, place, lookForward));
}
return new SuggestedNameInfo(ArrayUtil.toStringArray(uniqueNames)) {
@Override
public void nameChosen(String name) {
baseNameInfo.nameChosen(name);
}
};
}
public static void determineDependencies(AbstractMetadataRecord p, Command command) {
Collection<GroupSymbol> groups =
GroupCollectorVisitor.getGroupsIgnoreInlineViewsAndEvaluatableSubqueries(command, true);
LinkedHashSet<AbstractMetadataRecord> values = new LinkedHashSet<AbstractMetadataRecord>();
for (GroupSymbol group : groups) {
Object mid = group.getMetadataID();
if (mid instanceof TempMetadataAdapter) {
mid = ((TempMetadataID) mid).getOriginalMetadataID();
}
if (mid instanceof AbstractMetadataRecord) {
values.add((AbstractMetadataRecord) mid);
}
}
Collection<ElementSymbol> elems = ElementCollectorVisitor.getElements(command, true, true);
for (ElementSymbol elem : elems) {
Object mid = elem.getMetadataID();
if (mid instanceof TempMetadataAdapter) {
mid = ((TempMetadataID) mid).getOriginalMetadataID();
}
if (mid instanceof AbstractMetadataRecord) {
values.add((AbstractMetadataRecord) mid);
}
}
p.setIncomingObjects(new ArrayList<AbstractMetadataRecord>(values));
}
public static LinkedHashSet<String> disintegrate(
String text,
String origText,
LinkedHashSet<String> set,
int inputLength,
int origLength,
int subStrLength,
int pos) {
if (text.length() < subStrLength) {
set.add(
(subStrLength < inputLength)
? origText.substring(0, subStrLength + 1)
: origText.substring(0, subStrLength));
return set;
}
if (subStrLength <= text.length()) set.add(text.substring(0, subStrLength));
disintegrate(
text.substring(pos),
origText,
set,
inputLength,
text.substring(1).length(),
subStrLength,
pos);
disintegrate(
origText.substring(pos),
origText,
set,
inputLength,
origText.length(),
++subStrLength,
pos);
return set;
}
@SuppressWarnings("unchecked")
@Override
public String toString() {
LinkedHashSet<Field> fields = new LinkedHashSet<Field>();
for (FieldSpec<KeyAnn> spec : getJsonKeySpecs(getClass())) {
fields.add(spec.field);
}
if (this instanceof Entity) {
for (FieldSpec<ColumnAnn> spec : getTableColumnSpecs((Class<? extends Entity>) getClass())) {
fields.add(spec.field);
}
}
StringBuilder sb = new StringBuilder();
ArrayList<String> fieldVals = new ArrayList<String>();
for (Field field : fields) {
sb.append(field.getName()).append(": ");
try {
sb.append(getFieldVal(this, field));
} catch (Exception e) {
sb.append("n/a");
}
fieldVals.add(sb.toString());
sb.setLength(0);
}
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append(join(fieldVals, ", "));
sb.append("]");
return sb.toString();
}
public void test_toArray$Ljava_lang_Object() {
LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>();
lhs.add(new Integer(1));
lhs.add(new Integer(6));
lhs.add(new Integer(7));
lhs.add(new Integer(8));
lhs.add(new Integer(9));
lhs.add(new Integer(10));
lhs.add(new Integer(11));
lhs.add(new Integer(12));
lhs.add(new Integer(13));
Object[] o1 = new Object[lhs.size()];
Object[] o2 = new Double[lhs.size()];
lhs.toArray(o1);
for (int i = 0; i < o1.length; i++) {
assertTrue(lhs.contains(o1[i]));
}
try {
lhs.toArray(null);
fail("NullPointerException expected");
} catch (NullPointerException e) {
// expected
}
try {
lhs.toArray(o2);
fail("ArrayStoreException expected");
} catch (ArrayStoreException e) {
// expected
}
}
protected Set<ToutElement> listeAny(final String namespace, final String targetNamespace) {
final LinkedHashSet<ToutElement> liste = new LinkedHashSet<ToutElement>();
if (namespace == null || "".equals(namespace) || "##any".equals(namespace)) {
for (final WXSElement el : lTousElements)
if (el.getName() != null && el.getRef() == null && !el.getAbstract()) liste.add(el);
} else if ("##local".equals(namespace)) {
for (final WXSElement el : lTousElements) {
if (el.getName() != null && el.getRef() == null && !el.getAbstract()) {
final String tns = el.getNamespace();
if (tns == null || tns.equals(targetNamespace)) liste.add(el);
}
}
} else if ("##other".equals(namespace)) {
final ArrayList<Element> references = cfg.listeElementsHorsEspace(targetNamespace);
for (Element ref : references) liste.add(new ElementExterne(ref, cfg));
} else {
// liste d'espaces de noms s?par?s par des espaces
final HashSet<String> espaces = new HashSet<String>(Arrays.asList(namespace.split("\\s")));
if (espaces.contains("##targetNamespace")) {
espaces.remove("##targetNamespace");
espaces.add(targetNamespace);
}
if (espaces.contains("##local")) {
espaces.remove("##local");
espaces.add("");
}
final ArrayList<Element> references = cfg.listeElementsDansEspaces(espaces);
for (Element ref : references) liste.add(new ElementExterne(ref, cfg));
}
return (liste);
}
/**
* Creates a map which provides project ids for each working set. If the working set is an
* AggregateWorkingSet then these are the ids of (simple) working sets. Otherwise these are ids of
* the contained projects.
*
* @return
*/
private Map<String, Set<String>> getWorkingSetTable() {
LinkedHashMap<String, Set<String>> table = new LinkedHashMap<String, Set<String>>();
Map<String, IWorkingSet> workingSetMap = getWorkingSetMap();
for (String wsId : workingSetMap.keySet()) {
if (wsId == null) {
System.err.println("Illegal AggregateWorkingSet: key is null");
continue;
}
IWorkingSet ws = workingSetMap.get(wsId);
LinkedHashSet<String> ids = new LinkedHashSet<String>();
if (ws instanceof IAggregateWorkingSet) {
IWorkingSet[] components = ((IAggregateWorkingSet) ws).getComponents();
for (IWorkingSet _ws : components) {
if (_ws == null) {
System.err.println("Illegal AggregateWorkingSet: null component in " + wsId);
continue;
}
String _wsId = _ws.getName();
ids.add(_wsId);
}
} else {
IAdaptable[] elements = ws.getElements();
for (IAdaptable e : elements) {
String pId = ((IProject) e).getName();
ids.add(pId);
}
}
table.put(wsId, ids);
}
return table;
}
/**
* Test importing of Clinical Data File.
*
* @throws DaoException Database Access Error.
* @throws IOException IO Error.
*/
@Test
@Ignore("To be fixed")
public void testImportClinicalDataSurvival() throws Exception {
// TBD: change this to use getResourceAsStream()
File clinicalFile = new File("target/test-classes/clinical_data.txt");
ImportClinicalData importClinicalData = new ImportClinicalData(study, clinicalFile);
importClinicalData.importData();
LinkedHashSet<String> caseSet = new LinkedHashSet<String>();
caseSet.add("TCGA-A1-A0SB");
caseSet.add("TCGA-A1-A0SI");
caseSet.add("TCGA-A1-A0SE");
List<Patient> clinicalCaseList =
DaoClinicalData.getSurvivalData(study.getInternalId(), caseSet);
assertEquals(3, clinicalCaseList.size());
Patient clinical0 = clinicalCaseList.get(0);
assertEquals(new Double(79.04), clinical0.getAgeAtDiagnosis());
assertEquals("DECEASED", clinical0.getOverallSurvivalStatus());
assertEquals("Recurred/Progressed", clinical0.getDiseaseFreeSurvivalStatus());
assertEquals(new Double(43.8), clinical0.getOverallSurvivalMonths());
assertEquals(new Double(15.05), clinical0.getDiseaseFreeSurvivalMonths());
Patient clinical1 = clinicalCaseList.get(1);
assertEquals(new Double(55.53), clinical1.getAgeAtDiagnosis());
assertEquals("LIVING", clinical1.getOverallSurvivalStatus());
assertEquals("DiseaseFree", clinical1.getDiseaseFreeSurvivalStatus());
assertEquals(new Double(49.02), clinical1.getOverallSurvivalMonths());
assertEquals(new Double(49.02), clinical1.getDiseaseFreeSurvivalMonths());
Patient clinical2 = clinicalCaseList.get(2);
assertEquals(null, clinical2.getDiseaseFreeSurvivalMonths());
}
@SuppressWarnings("rawtypes")
private boolean addOrderedElement(Ordered adding) {
boolean added = false;
E[] tempUnorderedElements = (E[]) this.toArray();
if (super.contains(adding)) {
return false;
}
super.clear();
if (tempUnorderedElements.length == 0) {
added = super.add((E) adding);
} else {
Set tempSet = new LinkedHashSet();
for (E current : tempUnorderedElements) {
if (current instanceof Ordered) {
if (this.comparator.compare(adding, current) < 0) {
added = super.add((E) adding);
super.add(current);
} else {
super.add(current);
}
} else {
tempSet.add(current);
}
}
if (!added) {
added = super.add((E) adding);
}
for (Object object : tempSet) {
super.add((E) object);
}
}
return added;
}
@Test
public void testCalculaFreteLocalDiferente() {
LinkedHashSet<Livro> cestaLivro = new LinkedHashSet<Livro>();
cestaLivro.add(new Livro(0, "Guia do exame SCJP", 1));
cestaLivro.add(new Livro(1, "Dominando Hibernate", 2));
assertEquals("Entrega em 15 dias", new Livro().checkout(cestaLivro, "BA", "SP"));
}
/**
* Sets up the fixture, for example, open a network connection. This method is called before a
* test is executed.
*/
protected void setUp() {
objArray = new Object[1000];
for (int i = 0; i < objArray.length; i++) objArray[i] = new Integer(i);
hs = new LinkedHashSet();
for (int i = 0; i < objArray.length; i++) hs.add(objArray[i]);
hs.add(null);
}
/** Format deadlock displaying to a user. */
public static String prettyFormat(Collection<Dependency> deadlock) {
StringBuilder text = new StringBuilder();
LinkedHashSet<LocalThread> threads = new LinkedHashSet<LocalThread>();
Set<Object> seenDependers = new HashSet<>();
Object lastDependsOn = text;
Object lastDepender = text;
for (Dependency dep : deadlock) {
Object depender = dep.getDepender();
Object dependsOn = dep.getDependsOn();
String dependerString;
if (lastDependsOn.equals(depender)) {
dependerString = "which";
} else if (lastDepender.equals(depender)) {
dependerString = "and";
} else {
dependerString = String.valueOf(depender);
}
lastDepender = depender;
lastDependsOn = dependsOn;
String also = seenDependers.contains(depender) ? " also" : "";
seenDependers.add(depender);
if (depender instanceof LocalThread) {
text.append(dependerString)
.append(" is")
.append(also)
.append(" waiting on ")
.append(dependsOn)
.append("\n");
threads.add((LocalThread) depender);
} else if (dependsOn instanceof LocalThread) {
text.append(dependerString).append(" is held by thread ").append(dependsOn).append("\n");
threads.add((LocalThread) dependsOn);
} else {
text.append(dependerString)
.append(" is")
.append(also)
.append(" waiting for ")
.append(dependsOn)
.append("\n");
}
text.append("\n");
}
text.append("\nStack traces for involved threads\n");
for (LocalThread threadInfo : threads) {
text.append(threadInfo.getLocatility())
.append(":")
.append(threadInfo.getThreadStack())
.append("\n\n");
}
return text.toString();
}
/** java.util.LinkedHashSet#add(java.lang.Object) */
public void test_addLjava_lang_Object() {
// Test for method boolean java.util.LinkedHashSet.add(java.lang.Object)
int size = hs.size();
hs.add(new Integer(8));
assertTrue("Added element already contained by set", hs.size() == size);
hs.add(new Integer(-9));
assertTrue("Failed to increment set size after add", hs.size() == size + 1);
assertTrue("Failed to add element to set", hs.contains(new Integer(-9)));
}
/**
* Insert the method's description here. Creation date: (21.12.2000 22:24:23)
*
* @return boolean
* @param object com.cosylab.vdct.graphics.objects.VisibleObject
* @param zoomOnHilited sets the option whether the hilited object should be zoomed in
*/
public boolean setAsHilited(VisibleObject object, boolean zoomOnHilited) {
this.zoomOnHilited = zoomOnHilited;
if (zoomOnHilited) {
DrawingSurface.getInstance().repaint();
hilitedObjects.clear();
if (hilitedObject != null) {
hilitedObjects.add(hilitedObject);
}
}
if (object == null) {
hilitedObjects.clear();
hilitedObject = null;
return false;
}
if (object != hilitedObject || hilitedObjects.size() == 1) {
hilitedObject = object;
// initialization
hilitedObjects.clear();
hilitedObjects.add(hilitedObject);
Object obj = hilitedObject;
// inlinks
Vector outlinks = null;
if (obj instanceof MultiInLink) {
outlinks = ((MultiInLink) obj).getOutlinks();
} else if (obj instanceof InLink) {
outlinks = new Vector();
outlinks.add(((InLink) obj).getOutput());
}
if (!zoomOnHilited) {
if (outlinks != null)
for (int i = 0; i < outlinks.size(); i++) {
obj = outlinks.elementAt(i);
hilitedObjects.add(obj);
while (obj instanceof InLink) {
obj = ((InLink) obj).getOutput();
hilitedObjects.add(obj);
}
}
// outLinks
obj = hilitedObject;
while (obj instanceof OutLink) {
obj = ((OutLink) obj).getInput();
hilitedObjects.add(obj);
}
}
return true;
} else return false;
}
@Override
public Set<Object> getSingletons() {
LinkedHashSet<Object> instances = new LinkedHashSet<Object>();
instances.add(StreamingOutputProvider); // provider
instances.add(new BadResource()); // simulate resource exception
instances.add("bla-bla"); // should be ignored
instances.add(new BadProvider()); // simulate provider exception
instances.add(rootResource); // resource
return instances;
}
@Test
public void testCalculaMaisUmKg() {
LinkedHashSet<Livro> cestaLivro = new LinkedHashSet<Livro>();
cestaLivro.add(new Livro(0, "Guia do exame SCJP", 1));
cestaLivro.add(new Livro(1, "Dominando Hibernate", 2));
cestaLivro.add(new Livro(3, "TomCat Administrador", 1));
cestaLivro.add(new Livro(4, "Core JSF 2.0", 1));
cestaLivro.add(new Livro(5, "Certificação LPI", 1));
assertEquals("Entrega em 5 dias", new Livro().checkout(cestaLivro, "RJ", "rj"));
}
/**
* Builds a list of components (Component) for a form that are ordered in the default focus order.
*/
public static LinkedHashSet buildDefaultFocusPolicy(FormComponent fc) {
System.out.println("buildDefaultFocusPolicy form: " + fc.getId());
final FormComponent theform = fc;
LinkedHashSet default_policy = new LinkedHashSet();
LayoutFocusTraversalPolicy policy =
new LayoutFocusTraversalPolicy() {
protected boolean accept(Component aComponent) {
if (aComponent instanceof StandardComponent) {
if (((StandardComponent) aComponent).getBeanDelegate() == null) return false;
}
if (aComponent == theform) return super.accept(aComponent);
if (aComponent instanceof FormComponent) {
if (((FormComponent) aComponent).isTopLevelForm()) return false;
}
if (aComponent instanceof JTabbedPane) return true;
if (aComponent != null) {
/** handle the case for embedded focus cycle roots such as JTabbedPane forms */
Container cc = aComponent.getParent();
while (cc != null && cc != theform) {
if (cc instanceof FormContainerComponent) {
return false;
}
cc = cc.getParent();
}
}
return super.accept(aComponent);
}
};
Component comp = policy.getFirstComponent(fc);
Component last_comp = policy.getLastComponent(fc);
while (true) {
/** Don't add scroll pane in design mode since the scroll bars might not be visible */
if (FormUtils.isDesignMode()) {
if (!(comp instanceof JScrollPane) && !(comp instanceof JScrollBar)) {
default_policy.add(comp);
}
} else {
default_policy.add(comp);
}
if (comp == last_comp) break;
System.out.println("FormFocusManager.getComponentAfter: " + comp.getClass());
comp = policy.getComponentAfter(fc, comp);
}
return default_policy;
}
/*
* @see java.util.HashSet#add(java.lang.Object)
*/
@Override
public boolean add(E o) {
if (remove(o)) {
super.add(o);
return false;
}
if (size() >= fMaxSize) remove(this.iterator().next());
super.add(o);
return true;
}
public ClassLoaderServiceImpl(
ClassLoader applicationClassLoader,
ClassLoader resourcesClassLoader,
ClassLoader hibernateClassLoader,
ClassLoader environmentClassLoader) {
this.classLoadingClassLoaders = new LinkedHashSet<ClassLoader>();
classLoadingClassLoaders.add(applicationClassLoader);
classLoadingClassLoaders.add(hibernateClassLoader);
classLoadingClassLoaders.add(environmentClassLoader);
this.resourcesClassLoader = resourcesClassLoader;
}
@Override
public Set<String> keySet() {
LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("database");
set.add("table");
for (String key : this.pkKeys) {
set.add(key);
}
return set;
}
public ArrayList<String> IPTrack(
String ipaddr, boolean IPdisp, boolean recursive, boolean override) {
ArrayList<String> output = new ArrayList<String>();
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps =
conn.prepareStatement(
"SELECT `accountname` "
+ "FROM `"
+ table
+ "` "
+ "WHERE `ip` = ? "
+ "ORDER BY `time` DESC");
ps.setString(1, ipaddr);
rs = ps.executeQuery();
LinkedHashSet<String> names = new LinkedHashSet<String>();
while (rs.next()) {
if ((!plugin.untraceable.contains(rs.getString("accountname"))) || (override))
names.add(rs.getString("accountname") + ((IPdisp) ? " (" + ipaddr + ")" : ""));
}
if (recursive) { // OH GOD OH GOD OH GOD
LinkedHashSet<String> names_spent = new LinkedHashSet<String>();
java.util.Iterator<String> names_itr = names.iterator();
while (names_itr.hasNext()) {
String thisName = names_itr.next();
if (names_spent.contains(thisName)) continue;
names_spent.add(thisName);
if (names.addAll(
PlayerTrack(
((thisName.indexOf(" ") != -1)
? thisName.substring(0, thisName.indexOf(" "))
: thisName),
IPdisp,
false,
override,
false,
false))) names_itr = names.iterator();
}
}
output.addAll(names);
} catch (SQLException ex) {
PlayerTracker.log.log(Level.SEVERE, "[P-Tracker] Couldn't execute MySQL statement: ", ex);
}
return output;
}
public void addFile(File file, boolean warn) {
if (contains(file)) {
// discard duplicates
return;
}
if (!fsInfo.exists(file)) {
/* No such file or directory exists */
if (warn) {
log.warning(Lint.LintCategory.PATH, "path.element.not.found", file);
}
super.add(file);
return;
}
File canonFile = fsInfo.getCanonicalFile(file);
if (canonicalValues.contains(canonFile)) {
/* Discard duplicates and avoid infinite recursion */
return;
}
if (fsInfo.isFile(file)) {
/* File is an ordinary file. */
if (!isArchive(file)) {
/* Not a recognized extension; open it to see if
it looks like a valid zip file. */
try {
ZipFile z = new ZipFile(file);
z.close();
if (warn) {
log.warning(Lint.LintCategory.PATH, "unexpected.archive.file", file);
}
} catch (IOException e) {
// FIXME: include e.getLocalizedMessage in warning
if (warn) {
log.warning(Lint.LintCategory.PATH, "invalid.archive.file", file);
}
return;
}
}
}
/* Now what we have left is either a directory or a file name
conforming to archive naming convention */
super.add(file);
canonicalValues.add(canonFile);
if (expandJarClassPaths && fsInfo.isFile(file)) addJarClassPath(file, warn);
}
public static void main(String a[]) {
LinkedHashSet<String> lhs = new LinkedHashSet<String>();
// add elements to HashSet
lhs.add("first");
lhs.add("second");
lhs.add("third");
System.out.println("My LinkedHashSet content:");
System.out.println(lhs);
System.out.println("Clearing LinkedHashSet:");
lhs.clear();
System.out.println("Content After clear:");
System.out.println(lhs);
}
public static <I, S extends AbstractNode<I, S>> LinkedHashSet<S> findAllowedRootsByAffectedNodes(
TreeAndParentMap<I, S> tree, Set<S> affectedNodes) {
final S treeRoot = tree.getTree();
final Map<S, S> parentMap = tree.getParentMap();
LinkedHashSet<S> ret = new LinkedHashSet<>();
for (S affectedNode : affectedNodes) {
S node = affectedNode;
while (node != treeRoot) {
ret.add(node);
node = parentMap.get(node);
}
ret.add(node);
}
return ret;
}
public static LinkedHashSet<String> findJars(LogicalPlan dag, Class<?>[] defaultClasses) {
List<Class<?>> jarClasses = new ArrayList<Class<?>>();
for (String className : dag.getClassNames()) {
try {
Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
jarClasses.add(clazz);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("Failed to load class " + className, e);
}
}
for (Class<?> clazz : Lists.newArrayList(jarClasses)) {
// process class and super classes (super does not require deploy annotation)
for (Class<?> c = clazz; c != Object.class && c != null; c = c.getSuperclass()) {
// LOG.debug("checking " + c);
jarClasses.add(c);
jarClasses.addAll(Arrays.asList(c.getInterfaces()));
}
}
jarClasses.addAll(Arrays.asList(defaultClasses));
if (dag.isDebug()) {
LOG.debug("Deploy dependencies: {}", jarClasses);
}
LinkedHashSet<String> localJarFiles = new LinkedHashSet<String>(); // avoid duplicates
HashMap<String, String> sourceToJar = new HashMap<String, String>();
for (Class<?> jarClass : jarClasses) {
if (jarClass.getProtectionDomain().getCodeSource() == null) {
// system class
continue;
}
String sourceLocation =
jarClass.getProtectionDomain().getCodeSource().getLocation().toString();
String jar = sourceToJar.get(sourceLocation);
if (jar == null) {
// don't create jar file from folders multiple times
jar = JarFinder.getJar(jarClass);
sourceToJar.put(sourceLocation, jar);
LOG.debug("added sourceLocation {} as {}", sourceLocation, jar);
}
if (jar == null) {
throw new AssertionError("Cannot resolve jar file for " + jarClass);
}
localJarFiles.add(jar);
}
String libJarsPath = dag.getValue(LogicalPlan.LIBRARY_JARS);
if (!StringUtils.isEmpty(libJarsPath)) {
String[] libJars = StringUtils.splitByWholeSeparator(libJarsPath, LIB_JARS_SEP);
localJarFiles.addAll(Arrays.asList(libJars));
}
LOG.info("Local jar file dependencies: " + localJarFiles);
return localJarFiles;
}
public LinkedHashSet<Path> scan(FileSystem fs, Path filePath, Set<String> consumedFiles) {
LinkedHashSet<Path> pathSet = Sets.newLinkedHashSet();
try {
LOG.debug("Scanning {} with pattern {}", filePath, this.filePatternRegexp);
FileStatus[] files = fs.listStatus(filePath);
for (FileStatus status : files) {
Path path = status.getPath();
String filePathStr = path.toString();
if (consumedFiles.contains(filePathStr)) {
continue;
}
if (ignoredFiles.contains(filePathStr)) {
continue;
}
if (acceptFile(filePathStr)) {
LOG.debug("Found {}", filePathStr);
pathSet.add(path);
} else {
// don't look at it again
ignoredFiles.add(filePathStr);
}
}
} catch (FileNotFoundException e) {
LOG.warn("Failed to list directory {}", filePath, e);
} catch (IOException e) {
throw new RuntimeException(e);
}
return pathSet;
}
/** {@inheritDoc} */
@Override()
public DynamicGroup newInstance(Entry groupEntry) throws DirectoryException {
ensureNotNull(groupEntry);
// Get the memberURL attribute from the entry, if there is one, and parse
// out the LDAP URLs that it contains.
LinkedHashSet<LDAPURL> memberURLs = new LinkedHashSet<LDAPURL>();
AttributeType memberURLType = DirectoryConfig.getAttributeType(ATTR_MEMBER_URL_LC, true);
List<Attribute> attrList = groupEntry.getAttribute(memberURLType);
if (attrList != null) {
for (Attribute a : attrList) {
for (AttributeValue v : a) {
try {
memberURLs.add(LDAPURL.decode(v.getValue().toString(), true));
} catch (DirectoryException de) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, de);
}
Message message =
ERR_DYNAMICGROUP_CANNOT_DECODE_MEMBERURL.get(
v.getValue().toString(),
String.valueOf(groupEntry.getDN()),
de.getMessageObject());
ErrorLogger.logError(message);
}
}
}
}
return new DynamicGroup(groupEntry.getDN(), memberURLs);
}
/**
* The place where feature sets get added to the classification run. If you're building a new
* feature set, put the symbol here and the add code that instantiates the class after the
* appropriate case statement and add a break
*
* @param featureSetName
*/
public void addFeatureSet(FeatureSetName featureSetName) {
switch (featureSetName) {
case ColorRingScores:
feature_sets.add(new ColorRingScores());
break;
case ColorDiameterScores:
feature_sets.add(new ColorDiameterScores());
break;
case MaxLineScores:
feature_sets.add(new MaxLineScores());
break;
case EdgeRingScores:
feature_sets.add(new EdgeRingScores());
break;
}
}
@Override
public void run() {
timer.scheduleAtFixedRate(
new TimerTask() {
@Override
public void run() {
for (String ip : ips) {
int idx = Math.abs(ip.hashCode() % ip_cnts.length);
if (ip_cnts[idx] > DISC_THRESHOLD) {
log.warning("Many disconnects for IP: " + ip + " - " + ip_cnts[idx]);
}
ip_cnts[idx] = 0;
}
}
},
CLEANUP_RATE,
CLEANUP_RATE);
while (!stopped) {
try {
String ip = queue.poll(10, TimeUnit.SECONDS);
if (ip != null) {
int idx = Math.abs(ip.hashCode()) % ip_cnts.length;
++ip_cnts[idx];
if (ips.size() < MAX_SIZE) {
ips.add(ip);
}
}
} catch (Exception e) {
log.warning("Error processing queue: " + e);
}
}
timer.cancel();
}
public void bePatternConfiguration(List<PsiClass> classes, PsiMethod method) {
data.TEST_OBJECT = TestType.PATTERN.getType();
final String suffix;
if (method != null) {
data.METHOD_NAME = method.getName();
suffix = "," + data.METHOD_NAME;
} else {
suffix = "";
}
LinkedHashSet<String> patterns = new LinkedHashSet<String>();
for (PsiClass pattern : classes) {
patterns.add(JavaExecutionUtil.getRuntimeQualifiedName(pattern) + suffix);
}
data.setPatterns(patterns);
final Module module =
RunConfigurationProducer.getInstance(TestNGPatternConfigurationProducer.class)
.findModule(this, getConfigurationModule().getModule(), patterns);
if (module == null) {
data.setScope(TestSearchScope.WHOLE_PROJECT);
setModule(null);
} else {
setModule(module);
}
setGeneratedName();
}
