void removeTaskEntry(String taskid) {
// taskid --> tracker
String tracker = (String) taskidToTrackerMap.remove(taskid);
// tracker --> taskid
TreeSet trackerSet = (TreeSet) trackerToTaskMap.get(tracker);
if (trackerSet != null) {
trackerSet.remove(taskid);
}
// taskid --> TIP
taskidToTIPMap.remove(taskid);
}
/**
* When looking at a result set that consists of a Map/HashTable we cannot rely on the output
* order, as the hashing algorithm or other aspects of the implementation may be different on
* differnt JDKs or platforms. Hence we take the Map, convert the keys to a List, sort them and
* Stringify the Map, which is a bit of a hack, but guarantees that we get the same order on all
* systems. We assume that the keys are strings.
*
* @param m The Map that contains keys we wish to return in sorted order
* @return A string that represents all the keys in sorted order.
*/
public String sortMapToString(Map m) {
System.out.println("Map toString looks like: " + m.toString());
// Pass in crap, and get nothing back
//
if (m == null) {
return null;
}
// Sort the keys in the Map
//
TreeMap nset = new TreeMap(m);
System.out.println("Tree map looks like: " + nset.toString());
return nset.toString();
}
/*public String itemWithNthHighestPeak(int n){
TreeMap peaks = peakResults();
peakResult next = new peakResult();
for(int i=0;peaks.size()>0&&i<n;i++){
next=(peakResult)(peaks.remove(peaks.firstKey()));
}
return next.name;
} */
public String decisionResult(double thresh) {
TreeMap decisions = decisionResults(thresh);
String result;
if (decisions.size() > 0) result = ((decisResult) decisions.firstKey()).name;
else result = "(null)";
return result;
}
private void loadLanguageList() {
TreeMap treemap = new TreeMap();
try {
BufferedReader bufferedreader =
new BufferedReader(
new InputStreamReader(
(net.minecraft.src.StringTranslate.class)
.getResourceAsStream("/lang/languages.txt"),
"UTF-8"));
for (String s = bufferedreader.readLine(); s != null; s = bufferedreader.readLine()) {
String as[] = s.split("=");
if (as != null && as.length == 2) {
treemap.put(as[0], as[1]);
}
}
} catch (IOException ioexception) {
ioexception.printStackTrace();
return;
}
languageList = treemap;
}
private static final Client getClient(File indexDirectory) throws SearchLibException {
clientsLock.r.lock();
try {
Client client = CLIENTS.get(indexDirectory);
if (client != null) return client;
} finally {
clientsLock.r.unlock();
}
int i = 60;
while (isOldClient(indexDirectory) && i > 0) {
ThreadUtils.sleepMs(500);
i--;
}
if (i == 0) throw new SearchLibException("Time out while getting " + indexDirectory);
clientsLock.w.lock();
try {
Client client = CLIENTS.get(indexDirectory);
if (client != null) return client;
client =
ClientFactory.INSTANCE.newClient(
indexDirectory, true, false, ClientFactory.INSTANCE.properties.getSilentBackupUrl());
CLIENTS.put(indexDirectory, client);
return client;
} finally {
clientsLock.w.unlock();
}
}
public static void eraseIndex(User user, String indexName)
throws SearchLibException, NamingException, IOException {
if (user != null && !user.isAdmin()) throw new SearchLibException("Operation not permitted");
File indexDir = getIndexDirectory(indexName);
Client client = null;
synchronized (ClientCatalog.class) {
clientsLock.r.lock();
try {
client = CLIENTS.get(indexDir);
} finally {
clientsLock.r.unlock();
}
if (client != null) {
client.close();
client.delete();
} else FileUtils.deleteDirectory(indexDir);
if (client != null) {
clientsLock.w.lock();
try {
CLIENTS.remove(client.getDirectory());
} finally {
clientsLock.w.unlock();
}
PushEvent.eventClientSwitch.publish(client);
}
}
}
private void exportParameters() {
synchronized (exported_parameters) {
if (!exported_parameters_dirty) {
return;
}
exported_parameters_dirty = false;
try {
TreeMap<String, String> tm = new TreeMap<String, String>();
Set<String> exported_keys = new HashSet<String>();
for (String[] entry : exported_parameters.values()) {
String key = entry[0];
String value = entry[1];
exported_keys.add(key);
if (value != null) {
tm.put(key, value);
}
}
for (Map.Entry<String, String> entry : imported_parameters.entrySet()) {
String key = entry.getKey();
if (!exported_keys.contains(key)) {
tm.put(key, entry.getValue());
}
}
File parent_dir = new File(SystemProperties.getUserPath());
File props = new File(parent_dir, "exported_params.properties");
PrintWriter pw =
new PrintWriter(new OutputStreamWriter(new FileOutputStream(props), "UTF-8"));
try {
for (Map.Entry<String, String> entry : tm.entrySet()) {
pw.println(entry.getKey() + "=" + entry.getValue());
}
} finally {
pw.close();
}
} catch (Throwable e) {
e.printStackTrace();
}
}
}
private void ListSubDirectorySizes(File file) {
File[] files;
files =
file.listFiles(
new FileFilter() {
@Override
public boolean accept(File file) {
// if (!file.isDirectory()){
// return false; //To change body of implemented methods use
// File | Settings | File Templates.
// }else{
// return true;
// }
return true;
}
});
Map<String, Long> dirListing = new HashMap<String, Long>();
for (File dir : files) {
DiskUsage diskUsage = new DiskUsage();
diskUsage.accept(dir);
// long size = diskUsage.getSize() / (1024 * 1024);
long size = diskUsage.getSize();
dirListing.put(dir.getName(), size);
}
ValueComparator bvc = new ValueComparator(dirListing);
TreeMap<String, Long> sorted_map = new TreeMap<String, Long>(bvc);
sorted_map.putAll(dirListing);
PrettyPrint(file, sorted_map);
}
/** Print a full description of all elements in the Tdb */
public void prettyPrint(PrintStream ps) {
ps.println("Tdb");
TreeMap<String, TdbPublisher> sorted =
new TreeMap<String, TdbPublisher>(CatalogueOrderComparator.SINGLETON);
sorted.putAll(getAllTdbPublishers());
for (TdbPublisher tdbPublisher : sorted.values()) {
tdbPublisher.prettyPrint(ps, 2);
}
}
/**
* @param type
* @return
*/
private Collection<String> getCorrectList(String type) {
if (type.equals("prop")) {
return propsList.keySet();
} else if (type.equals("set")) {
return setsList.keySet();
} else {
return charList.keySet();
}
}
/**
* Returns a map that associates probe names to floating point measurement values, all from a
* single experiment. Any probes with missing values in this experiment are omitted from the map.
*
* @param i the index of the experiment to retrieve
* @return
*/
public Map<String, Float> exptValues(int i) {
TreeMap<String, Float> map = new TreeMap<String, Float>();
for (String k : table.keySet()) {
Float v = table.get(k)[i];
if (v != null) {
map.put(k, v);
}
}
return map;
}
public Map<String, Rxn> getReactions(String compartment) {
TreeMap<String, Rxn> crxns = new TreeMap<String, Rxn>();
for (String rn : reactions.keySet()) {
Rxn r = reactions.get(rn);
if (r.getLocation().equals(compartment)) {
crxns.put(rn, r);
}
}
return crxns;
}
// -------------------------------------------
// check lifetime and remove expired entries
// -------------------------------------------
public synchronized void rmExpiredEntry() {
long currtime = System.currentTimeMillis();
Iterator keys = table.keySet().iterator();
while (keys.hasNext()) {
String k = (String) keys.next();
Entry e = (Entry) table.get(k);
if (currtime > (e.getArrivalTS() + e.getLifetime() * 1000)) {
keys.remove();
}
}
}
public static void sortAndPrintMap(Map<String, Double> map) throws FileNotFoundException {
// pr = new PrintStream(new FileOutputStream("/semplest/lluis/keywordExp/wordmap.txt"));
pr = System.out;
ValueComparator bvc = new ValueComparator(map);
TreeMap<String, Double> sorted = new TreeMap<String, Double>(bvc);
sorted.putAll(map);
for (String key : sorted.keySet()) {
pr.println(key + " : " + map.get(key));
}
System.out.println("Number of words : " + map.size());
}
/** Get an initial set of action parameters associated with an upstream node. */
public TreeMap<String, ActionParam> getInitialSourceParams() {
TreeMap<String, ActionParam> params = new TreeMap<String, ActionParam>();
{
ActionParam param =
new IntegerActionParam("Order", "Evaluates the MEL script in this order.", 100);
params.put(param.getName(), param);
}
return params;
}
public int releaseLock(UTF8 src, UTF8 holder) {
TreeSet holders = (TreeSet) activeLocks.get(src);
if (holders != null && holders.contains(holder)) {
holders.remove(holder);
if (holders.size() == 0) {
activeLocks.remove(src);
}
return COMPLETE_SUCCESS;
} else {
return OPERATION_FAILED;
}
}
// ------------------------------------------------------
// for "AttrRqst"
// Return: attrbute list for the URL/"service type"
// format: (attr1=value1),(attr2=value2)
// if tag != "", return ONLY those attributes in tag
// ------------------------------------------------------
public synchronized String getAttrList(String url, String scope, String tag, String ltag) {
if (table.containsKey(ltag + url)) {
Entry e = (Entry) table.get(ltag + url);
if (!e.getDeleted() && scope.equalsIgnoreCase(e.getScope())) {
return e.getAttr(tag);
} else {
return "";
}
} else { // Not URL, try servive type
return typeAttrList(url, scope, tag, ltag);
}
}
/** Replace working files with the selected checked-in files. */
@Override
public void doApply() {
super.doApply();
if (pIsFrozen) return;
TreeMap<String, VersionID> files = new TreeMap<String, VersionID>();
for (JFileSeqPanel panel : pFileSeqPanels.values()) files.putAll(panel.getFilesToRevert());
RevertTask task = new RevertTask(files);
task.start();
}
public void save(String filename) {
if (propertiesMap == null) {
// nothing to save, initialisation not complete
return;
}
/**
* Note - propertiesMap isn't synchronised! We'll clone the map now, because we need to modify
* it. The BEncoding code will create a new map object (TreeMap) because it needs to be sorted,
* so we might as well do it here too.
*/
TreeMap<String, Object> properties_clone = propertiesMap.toTreeMap();
// Remove any transient parameters.
if (!this.transient_properties.isEmpty()) {
properties_clone.keySet().removeAll(this.transient_properties);
}
FileUtil.writeResilientConfigFile(filename, properties_clone);
List<COConfigurationListener> listeners_copy;
synchronized (listenerz) {
listeners_copy = new ArrayList<COConfigurationListener>(listenerz);
}
for (int i = 0; i < listeners_copy.size(); i++) {
COConfigurationListener l = (COConfigurationListener) listeners_copy.get(i);
if (l != null) {
try {
l.configurationSaved();
} catch (Throwable e) {
Debug.printStackTrace(e);
}
} else {
Debug.out("COConfigurationListener is null");
}
}
if (exported_parameters_dirty) {
exportParameters();
}
}
/**
* Clear the entire contents of the cache and delete the backing files. This should only be used
* when the server is reinitializing, because the users are going to lose their files.
*/
public static void purgeCache(Configuration conf, MRAsyncDiskService service) throws IOException {
synchronized (cachedArchives) {
LocalFileSystem localFs = FileSystem.getLocal(conf);
for (Map.Entry<String, CacheStatus> f : cachedArchives.entrySet()) {
try {
deleteLocalPath(service, localFs, f.getValue().localizedLoadPath);
} catch (IOException ie) {
LOG.debug("Error cleaning up cache", ie);
}
}
cachedArchives.clear();
}
}
public int obtainLock(UTF8 src, UTF8 holder, boolean exclusive) {
TreeSet holders = (TreeSet) activeLocks.get(src);
if (holders == null) {
holders = new TreeSet();
activeLocks.put(src, holders);
}
if (exclusive && holders.size() > 0) {
return STILL_WAITING;
} else {
holders.add(holder);
return COMPLETE_SUCCESS;
}
}
public void parseCode() {
// Parse all <code> and <parameter> elements
List codeList = ParseUtils.parseDescendants(root, "code", idMap);
Iterator i = codeList.iterator();
while (i.hasNext()) {
Element codeElt = (Element) i.next();
String codeId = codeElt.getAttributeValue("id");
if (objects.containsKey(codeId)) {
System.out.println("Note: Shadowing definition of <code id=\"" + codeId + "\">");
}
objects.put(codeId, new Code(codeElt, idMap));
}
}
public static final void closeIndex(String indexName) throws SearchLibException {
Client client = null;
clientsLock.w.lock();
try {
File indexDirectory = getIndexDirectory(indexName);
client = CLIENTS.get(indexDirectory);
if (client == null) return;
Logging.info("Closing client " + indexName);
client.close();
CLIENTS.remove(indexDirectory);
} finally {
clientsLock.w.unlock();
}
if (client != null) PushEvent.eventClientSwitch.publish(client);
}
/** Map com a copia dos seguros de um cliente */
public Map<String, Seguro> copiaSeg() {
Map<String, Seguro> segs = new TreeMap<String, Seguro>();
for (Seguro s : seguros.values()) {
segs.put(s.getCodigo(), s.clone());
}
return segs;
}
// ------------------------------------------------
// save database to either the stdout or the file
// ------------------------------------------------
public synchronized void saveDatabase(BufferedWriter o) {
Iterator values = table.values().iterator();
while (values.hasNext()) {
Entry e = (Entry) values.next();
e.prtEntry(daf, o);
}
}
// -----------------------------------------------------------
// for "SrvRqst"
// find the matched URLs with (type, scope, predicate, ltag)
// return: error code (short)
// number of matched URLs (short)
// URL blocks (decided bt previous #URL)
// -----------------------------------------------------------
public synchronized byte[] getMatchedURL(String type, String scope, String pred, String ltag) {
byte[] buf = null;
int ecode = Const.OK;
if (!Util.shareString(daf.getScope(), scope, ",")) {
ecode = Const.SCOPE_NOT_SUPPORTED;
}
b.reset();
try {
int count = 0;
d.writeShort(ecode); // error code
d.writeShort(count); // URL count, place holder
if (ecode == Const.OK) { // no error, find matched URLs
Iterator values = table.values().iterator();
while (values.hasNext()) {
Entry e = (Entry) values.next();
if (e.match(type, scope, pred, ltag)) {
count++;
d.writeByte(0);
d.writeShort(e.getLifetime());
d.writeShort(e.getURL().length());
d.writeBytes(e.getURL());
d.writeByte(0);
}
}
}
buf = b.toByteArray();
if (count > 0) Util.writeInt(buf, 2, count, 2); // update count
} catch (Exception e) {
if (ServiceLocationManager.displayMSLPTrace) e.printStackTrace();
}
return buf;
}
// ----------------------------------------------------------------------
// for "SrvTypeRqst"
// get the list of service types for specified scope & naming authority
// ----------------------------------------------------------------------
public synchronized String getServiceTypeList(String na, String scope) {
Vector typelist = new Vector(5);
Iterator values = table.values().iterator();
while (values.hasNext()) {
Entry e = (Entry) values.next();
if (!e.getDeleted()
&& // nor deleted
scope.equalsIgnoreCase(e.getScope())
&& // match scope
(na.equals("*")
|| // NA wildcard
na.equalsIgnoreCase(e.getNA()))
&& // match NA
!typelist.contains(e.getType())) {
typelist.addElement(e.getType());
}
}
StringBuffer tl = new StringBuffer();
for (int i = 0; i < typelist.size(); i++) {
String s = (String) typelist.elementAt(i);
if (tl.length() > 0) tl.append(",");
tl.append(s);
}
return tl.toString();
}
/**
* Retrieves Strings corresponding to all valid _transition paths from a given node that satisfy a
* given condition.
*
* @param strHashSet a HashSet of Strings to contain all those in the MDAG satisfying {@code
* searchCondition} with {@code conditionString}
* @param searchCondition the SearchCondition enum field describing the type of relationship that
* Strings contained in the MDAG must have with {@code conditionString} in order to be
* included in the result set
* @param searchConditionString the String that all Strings in the MDAG must be related with in
* the fashion denoted by {@code searchCondition} in order to be included in the result set
* @param prefixString the String corresponding to the currently traversed _transition path
* @param transitionTreeMap a TreeMap of Characters to MDAGNodes collectively representing an
* MDAGNode's _transition set
*/
private void getStrings(
HashSet<String> strHashSet,
SearchCondition searchCondition,
String searchConditionString,
String prefixString,
TreeMap<Character, MDAGNode> transitionTreeMap) {
// Traverse all the valid _transition paths beginning from each _transition in
// transitionTreeMap, inserting the
// corresponding Strings in to strHashSet that have the relationship with conditionString
// denoted by searchCondition
for (Entry<Character, MDAGNode> transitionKeyValuePair : transitionTreeMap.entrySet()) {
String newPrefixString = prefixString + transitionKeyValuePair.getKey();
MDAGNode currentNode = transitionKeyValuePair.getValue();
if (currentNode.isAcceptNode()
&& searchCondition.satisfiesCondition(newPrefixString, searchConditionString))
strHashSet.add(newPrefixString);
// Recursively call this to traverse all the valid _transition paths from currentNode
getStrings(
strHashSet,
searchCondition,
searchConditionString,
newPrefixString,
currentNode.getOutgoingTransitions());
}
/////
}
/** @return A Box for selecting an asset type, the old asset and its replacement asset. */
private Box assetChoiceBox() {
TreeSet<String> types = new TreeSet<String>();
types.add(AssetType.CHARACTER.toString());
types.add(AssetType.PROP.toString());
types.add(AssetType.SET.toString());
// JDrawer toReturn;
Box hbox = new Box(BoxLayout.X_AXIS);
{
JCollectionField assetType = UIFactory.createCollectionField(types, diag, sTSize);
assetType.setActionCommand("type");
assetType.addActionListener(this);
JCollectionField oldAsset = UIFactory.createCollectionField(charList.keySet(), diag, sVSize);
JCollectionField newAsset = UIFactory.createCollectionField(charList.keySet(), diag, sVSize);
hbox.add(assetType);
hbox.add(Box.createHorizontalStrut(10));
hbox.add(oldAsset);
hbox.add(Box.createHorizontalStrut(5));
hbox.add(newAsset);
// pPotentials.put(oldAsset, newAsset);
}
list.add(Box.createVerticalStrut(5));
return hbox; // toReturn;
} // return assetChoiceBox
public synchronized void disconnect(Peer p) {
DownloadTask dt = task.remove(p.toString());
if (dt != null) {
dt.end();
dt = null;
}
}