Java Code Examples for java.util.SortedSet

public SortedSet<E> subSet(E fromElement,E toElement){
synchronized (lock) {
    SortedSet set=getSortedSet().subSet(fromElement,toElement);
    return new SynchronizedSortedSet<E>(set,lock);
  }
}
 

public static void main(String[] args){
  SortedSet so1=new TreeSet();
  so1.add("first");
  so1.add("second");
  so1.add("third");
  SortedSet so2=new TreeSet();
  SortedMutableListModel s1=new SortedMutableListModel(so1);
  SortedMutableListModel s2=new SortedMutableListModel(so2);
  JListDataExchangePanel dataEx=new JListDataExchangePanel(s1,s2,"source","dest");
  JFrame frame=new JFrame();
  frame.getContentPane().add(dataEx);
  frame.pack();
  frame.setVisible(true);
}
 

public boolean addBundleDescription(BundleDescription toAdd){
  if (allPlugins == null) {
    return super.addBundleDescription(toAdd);
  }
  SortedSet includedMatches=allPlugins.subSet(new ReachablePlugin(toAdd.getSymbolicName(),ReachablePlugin.WIDEST_RANGE),new ReachablePlugin(toAdd.getSymbolicName(),ReachablePlugin.NARROWEST_RANGE));
  for (Iterator iterator=includedMatches.iterator(); iterator.hasNext(); ) {
    ReachablePlugin constraint=(ReachablePlugin)iterator.next();
    if (constraint.getRange().isIncluded(toAdd.getVersion()))     return super.addBundleDescription(toAdd);
  }
  return false;
}
 

public SortedSet<String> put(String key,SortedSet<String> values,boolean percentEncode){
  if (percentEncode) {
    remove(key);
    for (    String v : values) {
      put(key,v,true);
    }
    return get(key);
  }
 else {
    return wrappedMap.put(key,values);
  }
}
 

public SortedSet<ConfigRecord<?>> inspect(ConfigurationFactory configurationFactory){
  ImmutableSortedSet.Builder<ConfigRecord<?>> builder=ImmutableSortedSet.naturalOrder();
  for (  ConfigurationProvider<?> configurationProvider : configurationFactory.getConfigurationProviders()) {
    builder.add(ConfigRecord.createConfigRecord(configurationProvider));
  }
  return builder.build();
}
 

private static List<TreatmentDefinition> calculateDefinitions(Map<Study,Map<TreatmentDefinition,Arm>> armMap){
  SortedSet<TreatmentDefinition> treatments=new TreeSet<TreatmentDefinition>();
  for (  Map<TreatmentDefinition,Arm> entry : armMap.values()) {
    treatments.addAll(entry.keySet());
  }
  return new ArrayList<TreatmentDefinition>(treatments);
}
 

/** 
 * Get the list of every EggType that the player have access to.
 * @param player used to check the permissions
 * @return
 */
public SortedSet<String> getEggTypeNames(final Player player){
  final SortedSet<String> result=new TreeSet<String>();
  for (  final Entry<Class<? extends EggType<?>>,Permission> entry : permissions.entrySet()) {
    if (entry.getValue() == null) {
      result.add(entry.getKey().getSimpleName());
      continue;
    }
    if (!PermissionManager.hasPerm(player,entry.getValue(),false)) {
      continue;
    }
    result.add(entry.getKey().getSimpleName());
  }
  return result;
}
 

String getRepositoryKey(RemoteRepository repository,String context){
  String key;
  if (repository.isRepositoryManager()) {
    StringBuilder buffer=new StringBuilder(128);
    buffer.append(repository.getId());
    buffer.append('-');
    SortedSet<String> subKeys=new TreeSet<String>();
    for (    RemoteRepository mirroredRepo : repository.getMirroredRepositories()) {
      subKeys.add(mirroredRepo.getId());
    }
    SimpleDigest digest=new SimpleDigest();
    digest.update(context);
    for (    String subKey : subKeys) {
      digest.update(subKey);
    }
    buffer.append(digest.digest());
    key=buffer.toString();
  }
 else {
    key=repository.getId();
  }
  return key;
}
 

/** 
 * Adds a general application privilege for a specific user
 * @throws CantDoThatException If privilege being assigned is MASTER but the user already has other privileges.
 */
protected synchronized void addUserPrivilege(AppUserInfo appUser,PrivilegeType privilegeType) throws CantDoThatException {
  if (privilegeType.equals(PrivilegeType.MASTER)) {
    SortedSet<AppRoleInfo> rolesForUser=this.getRolesForUser(appUser);
    if (rolesForUser.size() > 0) {
      throw new CantDoThatException("If adding a MASTER privilege, the user can't be a member of any roles. User '" + appUser + "' is a member of roles: "+ rolesForUser);
    }
    Set<UserGeneralPrivilegeInfo> userPrivileges=this.getPrivilegesForUser(appUser);
    if (userPrivileges.size() > 0) {
      throw new CantDoThatException("If adding a MASTER privilege, the user musn't have any other privileges. User '" + appUser + "' already has privileges: "+ userPrivileges);
    }
  }
  UserGeneralPrivilegeInfo userPrivilege=new UserGeneralPrivilege(appUser,privilegeType);
  HibernateUtil.currentSession().save(userPrivilege);
  this.getUserPrivilegesDirect().add(userPrivilege);
}
 

@SuppressWarnings({"rawtypes"}) private static ParameterizedTypeHandlerMap<InstanceCreator<?>> createDefaultInstanceCreators(){
  ParameterizedTypeHandlerMap<InstanceCreator<?>> map=new ParameterizedTypeHandlerMap<InstanceCreator<?>>();
  DefaultConstructorAllocator allocator=new DefaultConstructorAllocator(50);
  map.registerForTypeHierarchy(Map.class,new DefaultConstructorCreator<Map>(LinkedHashMap.class,allocator));
  DefaultConstructorCreator<List> listCreator=new DefaultConstructorCreator<List>(ArrayList.class,allocator);
  DefaultConstructorCreator<Queue> queueCreator=new DefaultConstructorCreator<Queue>(LinkedList.class,allocator);
  DefaultConstructorCreator<Set> setCreator=new DefaultConstructorCreator<Set>(HashSet.class,allocator);
  DefaultConstructorCreator<SortedSet> sortedSetCreator=new DefaultConstructorCreator<SortedSet>(TreeSet.class,allocator);
  map.registerForTypeHierarchy(Collection.class,listCreator);
  map.registerForTypeHierarchy(Queue.class,queueCreator);
  map.registerForTypeHierarchy(Set.class,setCreator);
  map.registerForTypeHierarchy(SortedSet.class,sortedSetCreator);
  map.makeUnmodifiable();
  return map;
}
 

private Collection<V> unmodifiableCollectionSubclass(Collection<V> collection){
  if (collection instanceof SortedSet) {
    return Collections.unmodifiableSortedSet((SortedSet<V>)collection);
  }
 else   if (collection instanceof Set) {
    return Collections.unmodifiableSet((Set<V>)collection);
  }
 else   if (collection instanceof List) {
    return Collections.unmodifiableList((List<V>)collection);
  }
 else {
    return Collections.unmodifiableCollection(collection);
  }
}
 

/** 
 * Returns the description of the geographical area the  {@code number} corresponds to.
 * @param number  the phone number to look up
 * @return  the description of the geographical area
 */
String lookup(PhoneNumber number){
  int numOfEntries=areaCodeMapStorage.getNumOfEntries();
  if (numOfEntries == 0) {
    return "";
  }
  long phonePrefix=Long.parseLong(number.getCountryCode() + phoneUtil.getNationalSignificantNumber(number));
  int currentIndex=numOfEntries - 1;
  SortedSet<Integer> currentSetOfLengths=areaCodeMapStorage.getPossibleLengths();
  while (currentSetOfLengths.size() > 0) {
    Integer possibleLength=currentSetOfLengths.last();
    String phonePrefixStr=String.valueOf(phonePrefix);
    if (phonePrefixStr.length() > possibleLength) {
      phonePrefix=Long.parseLong(phonePrefixStr.substring(0,possibleLength));
    }
    currentIndex=binarySearch(0,currentIndex,phonePrefix);
    if (currentIndex < 0) {
      return "";
    }
    int currentPrefix=areaCodeMapStorage.getPrefix(currentIndex);
    if (phonePrefix == currentPrefix) {
      return areaCodeMapStorage.getDescription(currentIndex);
    }
    currentSetOfLengths=currentSetOfLengths.headSet(possibleLength);
  }
  return "";
}
 

public SortedSet<ComparablePoint> getSortedPointSet(Point referencePoint,Collection<Point> intersectionPoints){
  SortedSet<ComparablePoint> sortedPointSet=new TreeSet<ComparablePoint>();
  List<Line> lines=getLines();
  Point firstPoint=points.get(0);
  boolean invertOrder=!firstPoint.equals(referencePoint);
  for (  Point intersection : intersectionPoints) {
    try {
      int i=getIntersectionIndex(invertOrder,intersection);
      if (i < lines.size()) {
        ComparablePoint point=generateComparablePoint(intersection,invertOrder,i);
        sortedPointSet.add(point);
      }
    }
 catch (    NullArgumentException e) {
      e.printStackTrace();
    }
  }
  return sortedPointSet;
}
 

@Test public void testExternalSystem() throws Exception {
  JRubyTemplateParser p=new JRubyTemplateParser();
  Template t=p.parseSystem(new File("src/test/ruby/ex1/system-template-with-external.rb")).get(0);
  Environment env=p.parseEnvironment(new File("src/test/ruby/ex1/env-with-listener.rb")).get(0);
  SystemMap map=t.normalize(env);
  SortedSet<Host> hosts=Sets.newTreeSet(new Comparator<Host>(){
    @Override public int compare(    Host host,    Host host1){
      return host.getId().toExternalForm().compareTo(host1.getId().toExternalForm());
    }
  }
);
  hosts.addAll(map.findLeaves());
  assertThat(hosts.size(),equalTo(3));
  Iterator<Host> itty=hosts.iterator();
  Host one=itty.next();
  System.out.println(one.getId());
  Host two=itty.next();
  System.out.println(two.getId());
  Host three=itty.next();
  System.out.println(three.getId());
}
 

public TreeMapSegmenter(SortedSet<T> leftEndpoints){
  if (leftEndpoints.isEmpty()) {
    throw new IllegalArgumentException("Endpoints must not be empty: " + leftEndpoints);
  }
  int i=0;
  for (  T t : leftEndpoints) {
    index.put(t,i++);
  }
}
 

public static Class getCollection(Class type){
  if (ReflectionUtils.hasDefaultConstructor(type)) {
    return type;
  }
 else   if (SortedSet.class.isAssignableFrom(type)) {
    return TreeSet.class;
  }
 else   if (Set.class.isAssignableFrom(type)) {
    return LinkedHashSet.class;
  }
 else   if (List.class.isAssignableFrom(type)) {
    return ArrayList.class;
  }
 else   if (Queue.class.isAssignableFrom(type)) {
    return LinkedList.class;
  }
 else {
    return ArrayList.class;
  }
}
 

public void inputChanged(Viewer viewer,Object oldInput,Object newInput){
  frameworks.clear();
  Workspace workspace=(Workspace)newInput;
  IConfigurationElement[] configElements=Platform.getExtensionRegistry().getConfigurationElementsFor(Plugin.PLUGIN_ID,"osgiFrameworks");
  for (  IConfigurationElement element : configElements) {
    String frameworkName=element.getAttribute("name");
    String bsn=element.getAttribute("bsn");
    URL iconUrl=null;
    String iconPath=element.getAttribute("icon");
    if (iconPath != null) {
      Bundle contributorBundle=BundleUtils.findBundle(Plugin.getDefault().getBundleContext(),element.getContributor().getName(),null);
      if (contributorBundle != null)       iconUrl=contributorBundle.getEntry(iconPath);
    }
    List<RepositoryPlugin> repositories=(workspace != null) ? workspace.getRepositories() : Collections.<RepositoryPlugin>emptyList();
    for (    RepositoryPlugin repo : repositories) {
      try {
        SortedSet<Version> versions=repo.versions(bsn);
        if (versions != null)         for (        Version version : versions) {
          try {
            File framework=repo.get(bsn,version,null);
            if (framework != null)             frameworks.add(new OSGiFramework(frameworkName,bsn,version,iconUrl));
          }
 catch (          Exception e) {
            logger.logError(String.format("Error finding repository entry for OSGi framework %s, version %s.",bsn,version.toString()),e);
          }
        }
      }
 catch (      Exception e) {
        logger.logError(String.format("Error searching repository for OSGi framework %s.",bsn),e);
      }
    }
  }
}
 

public CategoryHits[] categorize(Reader reader) throws IOException {
  Query query=moreLikeThis.like(reader);
  HashMap<String,CategoryHits> categoryHash=new HashMap<String,CategoryHits>(25);
  for (  ScoreDoc sd : indexSearcher.search(query,maxResults).scoreDocs) {
    String cat=getDocClass(sd.doc);
    if (cat == null)     continue;
    CategoryHits ch=categoryHash.get(cat);
    if (ch == null) {
      ch=new CategoryHits();
      ch.setLabel(cat);
      categoryHash.put(cat,ch);
    }
    ch.incrementScore(sd.score);
  }
  SortedSet<CategoryHits> sortedCats=new TreeSet<CategoryHits>(CategoryHits.byScoreComparator());
  sortedCats.addAll(categoryHash.values());
  return sortedCats.toArray(new CategoryHits[0]);
}
 

private static void replaceContent(Document result,SortedSet<String[]> records){
  Element parentDiv=result.getRootElement().getChild("div",JDOMNamespaceUtil.METS_NS);
  parentDiv.removeContent();
  int ord=1;
  for (  String[] record : records) {
    Element el=new Element("div",parentDiv.getNamespace()).setAttribute("ID",record[0]).setAttribute("ORDER",String.valueOf(ord));
    ord++;
    parentDiv.addContent(el);
  }
}
 

public ModuleDetails(String name,String doc,String license,SortedSet<String> authors,SortedSet<String> versions){
  this.name=name;
  this.doc=toNull(doc);
  this.license=toNull(license);
  this.authors.addAll(authors);
  this.versions.addAll(versions);
}
 

public static List<BoardView> listBoardViews(boolean isSorted){
  if (isSorted) {
    SortedSet<String> sorted=new TreeSet<String>(chessBoards.keySet());
    List<BoardView> res=new ArrayList<BoardView>();
    for (    String name : sorted) {
      res.add(chessBoards.get(name));
    }
    return res;
  }
 else {
    return new ArrayList<BoardView>(chessBoards.values());
  }
}
 

private String formatDeleteEquals(Connection connection,String separator) throws SQLException {
  SortedSet<String> keys=Sets.newTreeSet();
  String[] primaryKeys=getPrimaryKeyColumns(connection);
  for (  String key : primaryKeys) {
    keys.add(key + " = ?");
  }
  return StringUtilities.implodeItems(Lists.newArrayList(keys),separator);
}
 

/** 
 * Helper for visitSoyFileNode(SoyFileNode) to add code to define JS namespaces.
 * @param soyFile The node we're visiting.
 */
private void addCodeToDefineJsNamespaces(SoyFileNode soyFile){
  SortedSet<String> jsNamespaces=Sets.newTreeSet();
  for (  TemplateNode template : soyFile.getChildren()) {
    String templateName=template.getTemplateName();
    Matcher dotMatcher=DOT.matcher(templateName);
    while (dotMatcher.find()) {
      jsNamespaces.add(templateName.substring(0,dotMatcher.start()));
    }
  }
  for (  String jsNamespace : jsNamespaces) {
    boolean hasDot=jsNamespace.indexOf('.') >= 0;
    if (jsSrcOptions.shouldDeclareTopLevelNamespaces() || hasDot) {
      jsCodeBuilder.appendLine("if (typeof ",jsNamespace," == 'undefined') { ",(hasDot ? "" : "var "),jsNamespace," = {}; }");
    }
  }
}
 

private void testIterableCommon(Int2IntFrequencyDistribution fd){
  fd.set(1,1);
  fd.set(4,3);
  fd.set(2,4);
  fd.set(5,7);
  fd.set(6,9);
  fd.set(3,2);
  assertEquals(6,fd.getNumberOfEvents());
  assertEquals(26,fd.getSumOfCounts());
  SortedSet<PairOfInts> list=new TreeSet<PairOfInts>();
  for (  PairOfInts pair : fd) {
    list.add(pair.clone());
  }
  assertEquals(6,list.size());
  Iterator<PairOfInts> iter=list.iterator();
  PairOfInts e=iter.next();
  assertEquals(1,e.getLeftElement());
  assertEquals(1,e.getRightElement());
  e=iter.next();
  assertEquals(2,e.getLeftElement());
  assertEquals(4,e.getRightElement());
  e=iter.next();
  assertEquals(3,e.getLeftElement());
  assertEquals(2,e.getRightElement());
  e=iter.next();
  assertEquals(4,e.getLeftElement());
  assertEquals(3,e.getRightElement());
  e=iter.next();
  assertEquals(5,e.getLeftElement());
  assertEquals(7,e.getRightElement());
  e=iter.next();
  assertEquals(6,e.getLeftElement());
  assertEquals(9,e.getRightElement());
}
 

/** 
 * Returns a sorted set with all configured, persisted and runtime credentials. Note: When calling this method for the first time there may be a slight delay.
 * @return a newly created sorted set containing all currently known keypairs.
 */
public SortedSet<Credentials> getAllCredentials(){
  SortedSet<Credentials> sortedSet=Sets.newTreeSet();
  sortedSet.addAll(ImmutableSet.copyOf(configuredCredentials));
  sortedSet.addAll(ImmutableSet.copyOf(getNodeKeyPairs()));
  return sortedSet;
}
 

private void determineFolderRange(SortedSet<DatasetMetadata> inFolder){
  if (inFolder.isEmpty()) {
    fStart=null;
    fEnd=null;
  }
 else {
    Iterator<DatasetMetadata> it=inFolder.iterator();
    DatasetMetadata ds=it.next();
    fStart=fEnd=ds.getLastFileTimestamp();
    while (it.hasNext()) {
      ds=it.next();
      Date ts=ds.getLastFileTimestamp();
      if (ts.getTime() < fStart.getTime()) {
        fStart=ts;
      }
 else       if (ts.getTime() > fEnd.getTime()) {
        fEnd=ts;
      }
    }
  }
}
 

/** 
 * Verifie que le package <code>currentPackage</code> n'a comme d?endance directe seulement les package se trouvant dans <code>dependsUpon</code>.
 * @param currentPackage Le package a verifier (ex : "net.codjo.orbis")
 * @param dependsUpon    Tableau de package.
 * @throws IllegalArgumentException TODO
 */
protected void assertDependency(String currentPackage,String[] dependsUpon){
  jdepend.analyze();
  JavaPackage testedPack=jdepend.getPackage(currentPackage);
  if (testedPack == null) {
    throw new IllegalArgumentException("Package " + currentPackage + " est inconnu");
  }
  SortedSet<String> trueDependency=new TreeSet<String>();
  for (  Object object : testedPack.getEfferents()) {
    JavaPackage obj=(JavaPackage)object;
    if (!obj.getName().startsWith("java")) {
      trueDependency.add(obj.getName());
    }
  }
  List wantedDepency=Arrays.asList(dependsUpon);
  if (!trueDependency.containsAll(wantedDepency) || !wantedDepency.containsAll(trueDependency)) {
    StringWriter strWriter=new StringWriter();
    doTrace(currentPackage,dependsUpon,new PrintWriter(strWriter));
    fail("Contraintes de Dependance non respect? : \n" + strWriter.toString());
  }
}
 

public static String getNotResolvableArguments(Connection con,int repositoryId,ExecutionListModel executionListModel,DataProcessContext context){
  SortedSet<String> parametersList=new TreeSet<String>();
  List<UserTreatment> userTreatmentList=UserTreatment.orderList(UserTreatment.buildUserTrtListWithPriority(executionListModel.getPriorityMap()));
  try {
    for (    UserTreatment userTrt : userTreatmentList) {
      TreatmentModel trtModel=Repository.getTreatmentById(con,repositoryId,userTrt.getId());
      AbstractTreatment currentTrt=null;
      try {
        currentTrt=TreatmentFactory.buildTreatment(con,trtModel,repositoryId,executionListModel);
      }
 catch (      TreatmentException ex) {
        parametersList.add(ex.getLocalizedMessage());
      }
      if (currentTrt != null) {
        parametersList.addAll(currentTrt.getNotResolvableArguments(context));
      }
    }
  }
 catch (  TreatmentException ex) {
    parametersList.add(ex.getLocalizedMessage());
  }
  List<String> list=new ArrayList<String>();
  list.addAll(parametersList);
  return new ListCodec().encode(list);
}
 

public String toFP_TP_Table(){
  StringBuilder sb=new StringBuilder();
  SortedSet<String> set=new TreeSet<String>(new CompRule());
  set.addAll(Categories.getRules());
  sb.append(String.format(" %6s %3s %3s\n","Regra","TP","FP"));
  for (  String type : set) {
    sb.append(String.format(tpfp,type.replace("xml:",""),zeroOrValue(tpForOutcome.get(type)),zeroOrValue(fpForOutcome.get(type))));
  }
  return sb.toString();
}
 

public void visualize(@Nonnull Writer out) throws IOException {
  Collection<Column> columns=new ArrayList<Column>();
  SortedSet<Version> keyVersions=mappings.getMappedVersions();
  List<T> keys=new ArrayList<T>(mappings.getMappings().keySet());
  Collections.sort(keys,comparator);
  for (  T key : keys) {
    VersionMapping mapping=mappings.getMapping(key);
    List<Version> versions=new ArrayList<Version>();
    for (    Version keyVersion : keyVersions) {
      versions.add(mapping.resolveVersion(keyVersion));
    }
    columns.add(new Column(toString.convert(key),versions));
  }
  writeHeadline(columns,out);
  writeSeparator(columns.size(),out);
  writeContent(new ArrayList<Version>(keyVersions),columns,out);
  writeSeparator(columns.size(),out);
}
 

/** 
 * Allows initial publication of HourlyCharge instances within the notification interval.
 */
@StateChange public boolean addHourlyCharge(HourlyCharge newCharge,boolean publish){
  boolean result=false;
  if (isFixed) {
    log.error("Cannot change Rate " + this.toString());
  }
 else {
    Instant now=getCurrentTime();
    long warning=newCharge.getAtTime().getMillis() - now.getMillis();
    if (warning < noticeInterval && !publish) {
      log.warn("Too late (" + now.toString() + ") to change rate for "+ newCharge.getAtTime().toString());
    }
 else {
      if (probe == null) {
        probe=new ProbeCharge(new Instant(0l),0.0);
        System.out.println("add: probe was null");
      }
      probe.setAtTime(newCharge.getAtTime().plus(1000l));
      SortedSet<HourlyCharge> head=rateHistory.headSet(probe);
      if (head != null && head.size() > 0) {
        HourlyCharge item=head.last();
        if (item.getAtTime() == newCharge.getAtTime()) {
          log.debug("remove " + item.toString());
          rateHistory.remove(item);
        }
      }
      newCharge.setRateId(id);
      rateHistory.add(newCharge);
      log.info("Adding HourlyCharge " + newCharge.getId() + " at "+ newCharge.getAtTime()+ " to "+ this.toString());
      result=true;
    }
  }
  return result;
}
 

/** 
 * A constructor
 * @param project  the project
 * @param root     the repository root
 * @param remote   the remote name or url of remote repository
 * @param tags     the set of tags (might be modified if update button is pressed)
 * @param branches the set of branches (might be modified if update button is pressed)
 */
protected RefspecAddRefsDialog(@NotNull Project project,@NotNull VirtualFile root,@NotNull String remote,@NotNull SortedSet<String> tags,@NotNull SortedSet<String> branches){
  super(project,true);
  setTitle(Bundle.getString("addrefspec.title"));
  setOKButtonText(Bundle.getString("addrefspec.button"));
  myProject=project;
  myRoot=root;
  myRemote=remote;
  myTags=tags;
  myBranches=branches;
  updateTree();
  setupGetReferences();
  init();
  setOKActionEnabled(false);
}
 

@Override public boolean add(String str){
  SortedSet<String> sub=headSet(str);
  if (!sub.isEmpty() && str.startsWith(sub.last())) {
    return false;
  }
  boolean retVal=super.add(str);
  sub=tailSet(str + "\0");
  while (!sub.isEmpty() && sub.first().startsWith(str)) {
    sub.remove(sub.first());
  }
  return retVal;
}
 

@Override public void create(String tableName,byte[][] splitKeys,List<CColumn> columns){
  try {
    this.conn.tableOperations().create(tableName);
    SortedSet<Text> partitionKeys=new TreeSet<Text>();
    for (    byte[] split : splitKeys)     partitionKeys.add(new Text(split));
    this.conn.tableOperations().addSplits(tableName,partitionKeys);
  }
 catch (  Exception e) {
    throw Exceptions.asRuntime(e);
  }
}
 

public SortedSet<String> getTagsAsSortedSet(){
  if (mTags == null) {
    initTags();
  }
  return new TreeSet<String>(mTags);
}
 

void updateSearch(IProgramSketch sketch,SortedSet<String> classes,SortedSet<MethodKey> methods,SortedSet<Long> activations,List<Match> matches){
  LinkedList<ITraceModelProxy> proxies=new LinkedList<ITraceModelProxy>();
  if (classes != null) {
    for (    String c : classes) {
      ITraceModelProxy proxy=TraceModelProxy.forClass(sketch.getTraceData(),c);
      proxies.add(proxy);
    }
    if (methods != null) {
      for (      MethodKey mk : methods) {
        proxies.add(TraceModelProxy.forMethod(sketch.getTraceData(),mk));
      }
      if (activations != null) {
        for (        Long a : activations) {
          proxies.add(TraceModelProxy.forActivation(sketch.getTraceData(),a.longValue()));
        }
      }
    }
  }
  this.results.put(sketch,new Result(proxies,matches));
  for (  Object o : listeners.getListeners()) {
    ISearchResultListener listener=(ISearchResultListener)o;
    listener.searchResultChanged(new TraceSearchResultEvent(this,sketch,proxies));
  }
}
 

/** 
 * @see org.digitalstain.datrie.AbstractDoubleArrayTrie#nextAvailableMove(java.util.SortedSet)
 */
@Override protected int nextAvailableMove(SortedSet<Integer> values){
  if (values.size() == 1) {
    return nextAvailableHop(values.first());
  }
  int minValue=values.first();
  int maxValue=values.last();
  int neededPositions=maxValue - minValue + 1;
  int possible=findConsecutiveFree(neededPositions);
  if (possible - minValue >= 0) {
    return possible - minValue;
  }
  ensureReachableIndex(base.size() + neededPositions);
  return base.size() - neededPositions - minValue;
}
 

public static <T extends Set<?>>Set<?> createNewSet(Class<T> destType){
  Set<Object> result;
  if (SortedSet.class.isAssignableFrom(destType)) {
    result=new TreeSet<Object>();
  }
 else {
    result=new HashSet<Object>();
  }
  return result;
}
 

/** 
 * Validates the specified document - If a service, it is validated, but not saved - If another doctype, all services within the document are validated and saved
 */
@Override public ValidationResultList validateServices(CoreSession session,DocumentModel model) throws Exception {
  DocumentService docService=Framework.getService(DocumentService.class);
  boolean modelIsWorkspace=Workspace.DOCTYPE.equals(model.getType());
  DocumentModel workspace=(modelIsWorkspace) ? model : docService.getWorkspace(session,model);
  DocumentModel referenceEnv=docService.findEnvironment(session,(String)workspace.getProperty(Workspace.SCHEMA,Workspace.PROP_REFERENCEDENVIRONMENT));
  DocumentModelList services=null;
  ValidationResultList validationResultList=new ValidationResultList();
  if (referenceEnv != null) {
    DocumentModelList referenceServices=getAllServices(session,referenceEnv);
    if (Service.DOCTYPE.equals(model.getType())) {
      services=new DocumentModelListImpl();
      services.add(model);
    }
 else {
      services=getAllServices(session,model);
    }
    if (services != null) {
      for (      DocumentModel service : services) {
        DocumentModel matchingService=null;
        SortedSet<CorrelationMatch> matches=findCorrelatedServices(session,service,referenceServices);
        if (!matches.isEmpty()) {
          matchingService=matches.first().getDocumentModel();
        }
        ValidationResult validationResult=validateService(session,service,matchingService,model != service);
        validationResultList.add(validationResult);
      }
    }
  }
 else {
    throw new ClientException("No valid reference environment");
  }
  return validationResultList;
}
 

/** 
 * Returns the ids of all build configurations that has a set of types
 * @param types The types to match against
 * @return The build configurations that have <b>all</b> the specifiedtypes, sorted in case-insensitive alphabetical order.
 */
public SortedSet<String> getBuildConfigurationsOfType(String... types){
  TreeSet<String> result=new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
  for (  IBuildConfiguration cfg : configurations.values()) {
    boolean doAdd=true;
    for (int i=0; i < types.length; i++) {
      doAdd&=cfg.getTypes().contains(types[i]);
    }
    if (doAdd) {
      result.add(cfg.getId());
    }
  }
  return result;
}
 

public ProjectManagerReport getProjectManagerDetailedReport(DateRange reportRange,Integer projectId){
  ProjectManagerReport report=new ProjectManagerReport();
  SortedSet<AssignmentAggregateReportElement> aggregates;
  List<MailLogAssignment> sentMail;
  Project project;
  List<Integer> assignmentIds=new ArrayList<Integer>();
  List<ProjectAssignment> allAssignments;
  AssignmentAggregateReportElement emptyAggregate;
  project=getProjectDAO().findById(projectId);
  report.setProject(project);
  reportRange=getReportRangeForProject(reportRange,project);
  report.setReportRange(reportRange);
  List<Project> projects=new ArrayList<Project>();
  projects.add(new Project(projectId));
  aggregates=new TreeSet<AssignmentAggregateReportElement>(reportAggregatedDAO.getCumulatedHoursPerAssignmentForProjects(projects,reportRange));
  for (  AssignmentAggregateReportElement aggregate : aggregates) {
    assignmentIds.add(aggregate.getProjectAssignment().getAssignmentId());
  }
  allAssignments=projectAssignmentService.getProjectAssignments(project,reportRange);
  for (  ProjectAssignment assignment : allAssignments) {
    if (!assignmentIds.contains(assignment.getAssignmentId())) {
      emptyAggregate=new AssignmentAggregateReportElement();
      emptyAggregate.setProjectAssignment(assignment);
      aggregates.add(emptyAggregate);
    }
  }
  report.setAggregates(aggregates);
  if (assignmentIds.size() > 0) {
    sentMail=mailService.getSentMailForAssignment(assignmentIds.toArray(new Integer[assignmentIds.size()]));
    report.setSentMail(new TreeSet<MailLogAssignment>(sentMail));
  }
  report.deriveTotals();
  return report;
}
 

/** 
 * Create an instance of the specifiec collection.  If the type cannot be instantiated directly, such as List, or Set, we'll try and figure out which type of collection is desired and return the standard implementation for that type, for example ArrayList or HashSet.
 * @param theValueType the type of collection to instantiate
 * @return the instantiated collection
 * @throws RuntimeException if there is no way to instantiate any matching collection
 */
public static Collection<Object> instantiateCollectionFromField(Class theValueType){
  try {
    return (Collection<Object>)theValueType.newInstance();
  }
 catch (  Throwable e) {
    if (List.class.isAssignableFrom(theValueType)) {
      return new ArrayList<Object>();
    }
 else     if (Set.class.isAssignableFrom(theValueType)) {
      if (SortedSet.class.isAssignableFrom(theValueType)) {
        return new TreeSet<Object>();
      }
 else {
        return new LinkedHashSet<Object>();
      }
    }
 else     if (Collection.class.equals(theValueType)) {
      return new LinkedHashSet<Object>();
    }
 else {
      throw new RuntimeException("Unknown or unsupported collection type for a field: " + theValueType);
    }
  }
}
 

private int nextUbTime(){
  SimpleDateFormat sdf=new SimpleDateFormat("HHmm");
  int nowTime=Integer.valueOf(sdf.format(getRealTime().getTime()));
  SortedSet<Integer> tailSet=_ubTimes.tailSet(nowTime);
  if (tailSet.isEmpty()) {
    tailSet=_ubTimes;
  }
  return tailSet.first();
}
 

private void writeAttributesTable(String description,StringBuilder beanInfo,MBeanAttributeInfo[] attributes,boolean nonHtml){
  addNonHtmlCondition(beanInfo,nonHtml);
  beanInfo.append("[options=\"header\", cols=\"20m,36,20m,7,7\"]\n" + "|===\n" + "|Name|Description|Type|Read|Write\n"+ "5.1+^e|").append(description).append('\n');
  SortedSet<String> attributeInfo=new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
  for (  MBeanAttributeInfo attrInfo : attributes) {
    StringBuilder attributeRow=new StringBuilder(512);
    String type=getType(attrInfo.getType());
    Descriptor descriptor=attrInfo.getDescriptor();
    type=getCompositeType(type,descriptor,nonHtml);
    attributeRow.append('|').append(makeBreakable(attrInfo.getName(),nonHtml)).append('|').append(attrInfo.getDescription().replace('\n',' ')).append('|').append(type).append('|').append(attrInfo.isReadable() ? "yes" : "no").append('|').append(attrInfo.isWritable() ? "yes" : "no").append('\n');
    attributeInfo.add(attributeRow.toString());
  }
  for (  String row : attributeInfo) {
    beanInfo.append(row);
  }
  beanInfo.append("|===\n");
  beanInfo.append(ENDIF);
}
 

/** 
 * @param spec
 */
public EPattern(int keyidx,EObject spec){
  this.keyidx=keyidx;
  this.spec=spec;
  SortedSet<Integer> out=new TreeSet<Integer>();
  matcher=spec.compileMatch(out);
  this.out_vars=out.toArray(new Integer[out.size()]);
}
 

/** 
 * Retrieves a collection of  {@link User} that its name or email starts with a term.
 * @param term
 * @return
 */
public Collection<User> getUsersStartingWith(String term){
  Collection<User> searchResultName=this.getAllStartsWith(NAME_ATTRIBUTE,term.toLowerCase());
  Collection<User> searchResultEmail=this.getAllStartsWith(EMAIL_ATTRIBUTE,term.toLowerCase());
  SortedSet<User> result=new TreeSet<User>();
  result.addAll(searchResultEmail);
  result.addAll(searchResultName);
  return result;
}
 

@Test public void pageHistoryShouldHaveStatsForOneTestIfOnePageHistoryFileIsPresent() throws Exception {
  File pageDirectory=addPageDirectory("TestPage");
  addTestResult(pageDirectory,"20090418123103_1_2_3_4");
  history.readHistoryDirectory(resultsDirectory);
  PageHistory pageHistory=history.getPageHistory("TestPage");
  assertEquals(1,pageHistory.size());
  assertEquals(7,pageHistory.maxAssertions());
  SortedSet<Date> dates=pageHistory.datesInChronologicalOrder();
  assertEquals(1,dates.size());
  Date date=dateFormat.parse("20090418123103");
  assertEquals(date,dates.first());
  PageHistory.PassFailBar passFailBar=pageHistory.getPassFailBar(date,50);
  assertEquals(1,passFailBar.getPass());
  assertEquals(6,passFailBar.getFail());
  assertEquals(7,passFailBar.getPassUnits());
  assertEquals(43,passFailBar.getFailUnits());
}
 

private static LinkedList<MidiNote> parseFile(MidiFile mFile){
  LinkedList<MidiNote> tempList=new LinkedList<MidiNote>();
  SortedSet<MidiEvent> eventTreeSet=mFile.getTracks().get(1).getEvents();
  for (  MidiEvent event : eventTreeSet) {
    if (isCorrectMidiNote(event)) {
      MidiNote note=new MidiNote(Note.getToneByMidiFileId(((NoteOn)event).getNoteValue()));
      tempList.add(note);
    }
  }
  return tempList;
}
 

public UserInfo GetAccessToken(String url){
  UserInfo user=null;
  String verifier=url.substring(url.indexOf("oauth_verifier") + "oauth_verifier=".length());
  httpOauthprovider.setOAuth10a(true);
  try {
    httpOauthprovider.retrieveAccessToken(httpOauthConsumer,verifier);
  }
 catch (  Exception e) {
    e.printStackTrace();
    try {
      httpOauthprovider.retrieveAccessToken(httpOauthConsumer,verifier);
    }
 catch (    Exception e1) {
      e.printStackTrace();
      try {
        httpOauthprovider.retrieveAccessToken(httpOauthConsumer,verifier);
      }
 catch (      Exception e2) {
        e.printStackTrace();
      }
    }
  }
  SortedSet<String> user_id=httpOauthprovider.getResponseParameters().get("user_id");
  if (user_id == null) {
    return null;
  }
  String userId=user_id.first();
  String userKey=httpOauthConsumer.getToken();
  String userSecret=httpOauthConsumer.getTokenSecret();
  user=new UserInfo();
  user.setUserId(userId);
  user.setToken(userKey);
  user.setTokenSecret(userSecret);
  return user;
}
 

/** 
 * @return a copy of the set of fileIDs which are currently on the queuewill be normally be used when deciding which data files can be deleted
 */
synchronized SortedSet<Integer> getFileIDs(){
  SortedSet<Integer> fileIDs=new TreeSet<Integer>(backingStore.getReferenceCounts());
  fileIDs.addAll(inflightPuts.getFileIDs());
  fileIDs.addAll(inflightTakes.getFileIDs());
  return fileIDs;
}
 

private String histoSortFreqs(Histogram<T> h){
  if (h.size() == 0)   return "";
  SortedSet<Pair<T,Integer>> s=h.sorted();
  StringBuilder data=null;
  for (  Pair<T,Integer> p : s) {
    if (data == null) {
      data=new StringBuilder();
      data.append(p.getRight());
    }
 else {
      data.append("," + p.getRight());
    }
  }
  return data.toString();
}
 

private String histoSortFreqs(Histogram<T> h){
  if (h.size() == 0)   return "";
  SortedSet<Pair<T,Integer>> s=h.sorted();
  StringBuilder data=null;
  for (  Pair<T,Integer> p : s) {
    if (data == null) {
      data=new StringBuilder();
      data.append(p.getRight());
    }
 else {
      data.append("," + p.getRight());
    }
  }
  return data.toString();
}
 

private List<SortedMap<String,String>> toMapList(Collection<NodeInfo> nis){
  SortedSet<NodeInfo> nis1=new TreeSet<NodeInfo>(new Comparator<NodeInfo>(){
    @Override public int compare(    NodeInfo o1,    NodeInfo o2){
      return o1.getNodeId() - o2.getNodeId();
    }
  }
);
  nis1.addAll(nis);
  List<SortedMap<String,String>> list=new ArrayList<SortedMap<String,String>>(nis.size());
  for (  NodeInfo ni : nis1)   list.add(toMap(ni));
  return list;
}
 

protected Collection<V> newCollection(Collection<V> other){
  if (comparator == null) {
    return new HashSet<V>(other);
  }
 else {
    SortedSet<V> set=new TreeSet<V>(comparator);
    set.addAll(other);
    return set;
  }
}
 

public void testRemoveDuplicates(){
  CustomizationContextComparator comparator=new CustomizationContextComparator("foo");
  SortedSet<SimpleCustomizationContext> contexts=new TreeSet<SimpleCustomizationContext>(comparator);
  contexts.add(s2);
  contexts.add(s2);
  assertEquals(1,contexts.size());
}
 

@SuppressWarnings("unchecked") @Override protected Collection createCollection(Class collectionType,int initialCapacity){
  if (!collectionType.isInterface()) {
    try {
      return (Collection)collectionType.newInstance();
    }
 catch (    Exception ex) {
      throw new IllegalArgumentException("Could not instantiate collection class [" + collectionType.getName() + "]: "+ ex.getMessage());
    }
  }
 else   if (List.class.equals(collectionType)) {
    return new ArrayList(initialCapacity);
  }
 else   if (Set.class.equals(collectionType)) {
    return new LinkedHashSet(initialCapacity);
  }
 else   if (SortedSet.class.equals(collectionType)) {
    return new TreeSet();
  }
 else {
    return new ArrayList(initialCapacity);
  }
}
 

/** 
 * Verify that the test jars are valid.
 * @throws Exception if a problem occurs
 */
public void testTestJars() throws Exception {
  for (int i=0; i < files.length; i++) {
    File file=files[i];
    JarFile jarFile=new JarFile(files[i]);
    String urlString="jar:" + file.toURL() + "!/"+ ENTRY_NAME;
    URL url=new URL(files[i].toURL(),urlString);
    assertStreamContains(ENTRY_VALUE + i,url.openStream());
    jarFile.close();
    URLClassLoader urlClassLoader=new URLClassLoader(new URL[]{file.toURL()});
    Class clazz=urlClassLoader.loadClass(CLASS_NAME);
    assertNotNull(clazz);
    assertTrue(SortedSet.class.isAssignableFrom(clazz));
    clazz=urlClassLoader.loadClass(CLASS_NAME + i);
    assertNotNull(clazz);
    assertTrue(SortedSet.class.isAssignableFrom(clazz));
    InputStream in=urlClassLoader.getResourceAsStream(ENTRY_NAME);
    assertStreamContains("Should have found value from parent " + i,ENTRY_VALUE + i,in);
    in=urlClassLoader.getResourceAsStream(ENTRY_NAME + i);
    assertStreamContains("Should have found value from parent " + i,ENTRY_VALUE + i + ENTRY_VALUE,in);
  }
}
 

public static Set<String> keywords(Event event){
  if (event == null) {
    throw new NullPointerException("event");
  }
  SortedSet<String> keywords=new TreeSet<>();
  String message=event.getMessage();
  if (message != null) {
    keywords(message,keywords);
  }
  Condition condition=event.getCondition();
  if (condition != null) {
    keywords(condition,keywords);
  }
  String marker=event.getMarker();
  if (marker != null) {
    keywords(marker,keywords);
  }
  if (keywords.isEmpty()) {
    return null;
  }
  return keywords;
}
 

@SuppressWarnings("unchecked") private static ParameterizedTypeHandlerMap<InstanceCreator<?>> createDefaultInstanceCreators(){
  ParameterizedTypeHandlerMap<InstanceCreator<?>> map=new ParameterizedTypeHandlerMap<InstanceCreator<?>>();
  DefaultConstructorAllocator allocator=new DefaultConstructorAllocator(50);
  map.registerForTypeHierarchy(Map.class,new DefaultConstructorCreator<Map>(LinkedHashMap.class,allocator),true);
  DefaultConstructorCreator<List> listCreator=new DefaultConstructorCreator<List>(ArrayList.class,allocator);
  DefaultConstructorCreator<Queue> queueCreator=new DefaultConstructorCreator<Queue>(LinkedList.class,allocator);
  DefaultConstructorCreator<Set> setCreator=new DefaultConstructorCreator<Set>(HashSet.class,allocator);
  DefaultConstructorCreator<SortedSet> sortedSetCreator=new DefaultConstructorCreator<SortedSet>(TreeSet.class,allocator);
  map.registerForTypeHierarchy(Collection.class,listCreator,true);
  map.registerForTypeHierarchy(Queue.class,queueCreator,true);
  map.registerForTypeHierarchy(Set.class,setCreator,true);
  map.registerForTypeHierarchy(SortedSet.class,sortedSetCreator,true);
  map.makeUnmodifiable();
  return map;
}
 

@Input public SortedSet<String> getEnabledReportNames(){
  return CollectionUtils.collect(getEnabled(),new TreeSet<String>(),new Transformer<String,Report>(){
    public String transform(    Report report){
      return report.getName();
    }
  }
);
}
 

/** 
 * Set the layer for a node, which means all the two internal structures used for that are updated.
 */
private void setLayer(Node node,int layer){
  Integer oldLayer=node2Layer.get(node);
  if (oldLayer != null) {
    SortedSet<Node> oldLayerNodes=layer2Nodes.get(oldLayer);
    if (oldLayerNodes.remove(node) && oldLayerNodes.isEmpty() && oldLayer == maxLayer)     maxLayer--;
  }
  SortedSet<Node> lnodes=layer2Nodes.get(layer);
  if (lnodes == null) {
    lnodes=new TreeSet<Node>();
    layer2Nodes.put(layer,lnodes);
  }
  lnodes.add(node);
  node2Layer.put(node,layer);
  if (layer > maxLayer)   maxLayer=layer;
}
 

@SuppressWarnings("unchecked") private static ParameterizedTypeHandlerMap<InstanceCreator<?>> createDefaultInstanceCreators(){
  ParameterizedTypeHandlerMap<InstanceCreator<?>> map=new ParameterizedTypeHandlerMap<InstanceCreator<?>>();
  DefaultConstructorAllocator allocator=new DefaultConstructorAllocator(50);
  map.registerForTypeHierarchy(Map.class,new DefaultConstructorCreator<Map>(LinkedHashMap.class,allocator),true);
  DefaultConstructorCreator<List> listCreator=new DefaultConstructorCreator<List>(ArrayList.class,allocator);
  DefaultConstructorCreator<Queue> queueCreator=new DefaultConstructorCreator<Queue>(LinkedList.class,allocator);
  DefaultConstructorCreator<Set> setCreator=new DefaultConstructorCreator<Set>(HashSet.class,allocator);
  DefaultConstructorCreator<SortedSet> sortedSetCreator=new DefaultConstructorCreator<SortedSet>(TreeSet.class,allocator);
  map.registerForTypeHierarchy(Collection.class,listCreator,true);
  map.registerForTypeHierarchy(Queue.class,queueCreator,true);
  map.registerForTypeHierarchy(Set.class,setCreator,true);
  map.registerForTypeHierarchy(SortedSet.class,sortedSetCreator,true);
  map.makeUnmodifiable();
  return map;
}