a copy sorted by time  of the all the state useful for analysis.
@return
503432
public SortedSet<NotificationsByObservable<?>> getNotificationsByObservable() {
        SortedSet<NotificationsByObservable<?>> notificationsByObservableSnapshot = new TreeSet<NotificationsByObservable<?>>();
        for (Entry<Subscriber<?>, Queue<SimpleContext<?>>> notificationsForObservable : notificationsByObservable.entrySet()) {
            notificationsByObservableSnapshot.add(new NotificationsByObservable(notificationsForObservable));
        }
        return notificationsByObservableSnapshot;
    }
242469
private boolean sort() {
		// We cache all variables for faster access
		final int[] d = this.d;
		//System.err.println("Visiting...");
		if (LOGGER.isDebugEnabled()) LOGGER.debug("Peeling hypergraph...");

		top = 0;
		for(int i = 0; i < numVertices; i++) if (d[i] == 1) peel(i);

		if (LOGGER.isDebugEnabled()) LOGGER.debug(top == numEdges ? "Peeling completed." : "Visit failed: peeled " + top + " edges out of " + numEdges + ".");

		return top == numEdges;
	}
1195426
public Set<NFAState<T>> getAll()
    {
        Set<NFAState<T>> set = new NumSet<>();
        Map<NFAState<T>,Integer> indexOf = new NumMap<>();
        Deque<NFAState<T>> stack = new ArrayDeque<>();
        for (NFAState<T> state : this)
        {
            if (!indexOf.containsKey(state))
            {
                collect(state, indexOf, stack, set);
            }

        }
        return set;
    }
1011389
public InternalPartition[] getPartitionsCopy() {
        NopPartitionListener listener = new NopPartitionListener();
        InternalPartition[] result = new InternalPartition[partitions.length];
        for (int i = 0; i < partitionCount; i++) {
            result[i] = partitions[i].copy(listener);
        }
        return result;
    }
66207
public Object getPersistentState() {
   Map<String, Object> persistentState = new HashMap<String, Object>();
   persistentState.put("processDefinitionId", this.processDefinitionId);
   persistentState.put("businessKey", this.businessKey);
   persistentState.put("activityId", this.activityId);
   persistentState.put("isActive", this.isActive);
   persistentState.put("isConcurrent", this.isConcurrent);
   persistentState.put("isScope", this.isScope);
   persistentState.put("isEventScope", this.isEventScope);
   persistentState.put("parentId", parentId);
   persistentState.put("name", name);
   persistentState.put("lockTime", lockTime);
   persistentState.put("superExecution", this.superExecutionId);
   persistentState.put("rootProcessInstanceId", this.rootProcessInstanceId);
   if (forcedUpdate) {
     persistentState.put("forcedUpdate", Boolean.TRUE);
   }
   persistentState.put("suspensionState", this.suspensionState);
   persistentState.put("startTime", this.startTime);
   persistentState.put("startUserId", this.startUserId);
   persistentState.put("eventSubscriptionCount", eventSubscriptionCount);
   persistentState.put("taskCount", taskCount);
   persistentState.put("jobCount", jobCount);
   persistentState.put("timerJobCount", timerJobCount);
   persistentState.put("suspendedJobCount", suspendedJobCount);
   persistentState.put("deadLetterJobCount", deadLetterJobCount);
   persistentState.put("variableCount", variableCount);
   persistentState.put("identityLinkCount", identityLinkCount);
   return persistentState;
 }
48916
public Map<T, Integer> getAllSorted()
    {
        Map<T, Integer> map = styles;
        TreeMap<T, Integer> smap = new TreeMap<T, Integer>(new StyleCountComparator(map));
        smap.putAll(map);
        return smap;
    }
851425
public Set<T> getTransitions(S state) {
		getStateId(state);
		return validTransitions.get(state);
	}
700968
public List<OrderingType<WebFragmentType<T>>> getAllOrdering()
   {
      List<OrderingType<WebFragmentType<T>>> list = new ArrayList<OrderingType<WebFragmentType<T>>>();
      List<Node> nodeList = childNode.get("ordering");
      for(Node node: nodeList)
      {
         OrderingType<WebFragmentType<T>>  type = new OrderingTypeImpl<WebFragmentType<T>>(this, "ordering", childNode, node);
         list.add(type);
      }
      return list;
   }
244485
public ArrayList getChunks() {
		ArrayList tmp = new ArrayList();
		for (Iterator i = arrayList.iterator(); i.hasNext(); ) {
			tmp.addAll(((Element) i.next()).getChunks());
		}
		return tmp;
	}
907605
public RawKeyValueIterator sort() {
    MergeSort m = new MergeSort(this);
    int count = super.count;
    if (count == 0) return null;
    int [] pointers = super.pointers;
    int [] pointersCopy = new int[count];
    System.arraycopy(pointers, 0, pointersCopy, 0, count);
    m.mergeSort(pointers, pointersCopy, 0, count);
    return new MRSortResultIterator(super.keyValBuffer, pointersCopy, 
                                    super.startOffsets, super.keyLengths, super.valueLengths);
  }
959096
public List<E> order() {
		int index = 0;
		for (E item : input) {
			index = output.indexOf(item);
			if (index == -1) {
				insert(item, item);
			}
		}

		return output;
	}
956891
public Map<String, Serializable> getState() {
    Map<String, Serializable> ret = new HashMap<>();
    // get potential eviction policy state
    if (evictionPolicy.getState() != null) {
      ret.put(EVICTION_STATE_KEY, (Serializable) evictionPolicy.getState());
    }
    // get potential trigger policy state
    if (triggerPolicy.getState() != null) {
      ret.put(TRIGGER_STATE_KEY, (Serializable) triggerPolicy.getState());
    }
    ret.put(QUEUE, (Serializable) this.queue);
    ret.put(EXPIRED_EVENTS, (Serializable) this.expiredEvents);
    ret.put(PRE_WINDOW_EVENTS, (Serializable) this.prevWindowEvents);
    ret.put(EVENTS_SINCE_LAST_EXPIRY, this.eventsSinceLastExpiry.get());
    return ret;
  }
919533
public List<Permutation> all() {
        final List<Permutation> permutations = new ArrayList<Permutation>();
        Backtracker counter = new Backtracker() {

            @Override
            public void applyTo(Permutation p) {
                permutations.add(p);
            }

            @Override
            public boolean isFinished() {
                return false;
            }
        };
        this.apply(counter);
        return permutations;
    }
188767
public synchronized Collection<T> getAll() {
    List<T> all = new ArrayList<T>(size);
    for (T e = head; e != null; e = e.getNext()) {
      all.add(e);
    }
    return all;
  }
208597
public long[] snapshot() {
        this.increment(0);  //  refresh just in case it's been idle a long time
        final long[] range = new long[this.buckets.length];
        if (this.indexOfOldest != 0) {
            final int lengthOfFirstSection = this.buckets.length - this.indexOfOldest;
            System.arraycopy(this.buckets, this.indexOfOldest, range, 0, lengthOfFirstSection);
            System.arraycopy(this.buckets, 0, range, lengthOfFirstSection, this.buckets.length - lengthOfFirstSection); //  wrap around
        } else {
            System.arraycopy(this.buckets, this.indexOfOldest, range, 0, this.buckets.length);
        }
        Collections.reverse(Longs.asList(range));
        return range;
    }
599039
public @Nonnull Collection<FingerprintFacet> getSortedFacets() {
        List<FingerprintFacet> r = new ArrayList<>(getFacets());
        r.sort(new Comparator<FingerprintFacet>() {
            public int compare(FingerprintFacet o1, FingerprintFacet o2) {
                long a = o1.getTimestamp();
                long b = o2.getTimestamp();
                if (a < b) return -1;
                if (a == b) return 0;
                return 1;
            }
        });
        return r;
    }
186705
@SuppressWarnings("unchecked")
  public T compareAll() {
    this.compareInputFormat().compareOutputFormat().compareIsCompressed().compareIsStoredAsSubDirs().compareNumBuckets()
        .compareBucketCols().compareRawLocation().compareParameters();
    return (T) this;
  }