Method reports all currently known ME's in a Enumeration format

@return  An Enumeration of all the Neighbours.
422848
Enumeration reportAllNeighbours()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "reportAllNeighbours");

    // Call out to the Neighbours class to get the list of Neighbours.
    final Enumeration neighbours = _neighbours.getAllNeighbours();

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "reportAllNeighbours");

    return neighbours;
  }
369497
public ArrayList<Integer> getOccurrences() {
    ArrayList<Integer> res = new ArrayList<Integer>(this.occurrences.size());
    for (Integer e : this.occurrences) {
      res.add(e);
    }
    return res;
  }
673598
@Override
  public int[] calculateInDegrees() {
    final int[] in_degrees = new int[size()];
    for(int i = 0; i < size(); ++i) {
      final IAdjacencyListPair<TVertex> p = pairAt(i);
      final TVertex d = p.getVertex();

      for(int j = 0; j < size(); ++j) {
        for(IVertex dep : pairAt(j).getOutNeighbors()) {
          if (d.equals(dep))
            ++in_degrees[i];
        }
      }
    }
    return in_degrees;
  }
409006
public List<Address> getClusterMembers() {
		if (currentView != null) {
			return Collections.unmodifiableList(currentView);
		}
		else {
			final Address localAddress = getLocalAddress();
			if (localAddress == null) {
				return Collections.emptyList();
			}
			else {
				final List<Address> list = new ArrayList<Address>();
				list.add(localAddress);
				return Collections.unmodifiableList(list);
			}
		}
	}
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;
    }
1236533
public int getNumPoints() {
		if (isEmpty()) {
			return 0;
		}
		int total = exteriorRing.getNumPoints();
		if (interiorRings != null) {
			for (LinearRing interiorRing : interiorRings) {
				total += interiorRing.getNumPoints();
			}
		}
		return total;
	}
945047
public ClientsResult calculateAllNodesResult() {
		final List<String> childNodePaths = getChildren(electionRootPath, false);
		_logger.info("Total peers = {} ", childNodePaths.size());
		Collections.sort(childNodePaths);

		int index = childNodePaths.indexOf(clientNodePath.substring(clientNodePath.lastIndexOf('/') + 1));
		return new ClientsResult(index, childNodePaths.size());
	}
740398
@SuppressWarnings("unchecked")
    public Map<String, Class<?>> getAllEntries() {
        return (Map<String, Class<?>>) MapUtils.unmodifiableMap(entries);
    }
817688
public Enumeration getAll() {
		LinkedList strings = new LinkedList();
		for (Iterator iter = names.iterator(); iter.hasNext();) {
			LdapRdn rdn = (LdapRdn) iter.next();
			strings.add(rdn.getLdapEncoded());
		}

		return Collections.enumeration(strings);
	}
213123
public IntStream getAllOccurrencesAsRanges() {
        IntStream result = IntStream.empty();
        // with/or without end
        for (int i = start; i < end; i++) {
            // every i is one occurrence
            int token_position = tokenIndex.suffix_array[i];
            IntStream range = IntStream.range(token_position, token_position + length);
            result = IntStream.concat(result, range);
        }
        return result;
    }
108477
@Override
    public Enumeration getAllIds() {
        Set ids = this.coreCache.getCacheIds();
        ValueSet idvs = new ValueSet(ids.iterator());
        return idvs.elements();
    }
542607
public Coordinate[] getCoordinates() {
		if (isEmpty()) {
			return null;
		}
		int len = getNumPoints();
		Coordinate[] coordinates = new Coordinate[len];
		int count;
		for (count = 0; count < exteriorRing.getNumPoints(); count++) {
			coordinates[count] = exteriorRing.getCoordinateN(count);
		}
		if (interiorRings != null) {
			for (LinearRing interiorRing : interiorRings) {
				for (int n = 0; n < interiorRing.getNumPoints(); n++) {
					coordinates[count++] = interiorRing.getCoordinateN(n);
				}
			}
		}
		return coordinates;
	}
623492
public SortedMap<Integer, RangeSet> getRelationship(AbstractProject that) {
        TreeMap<Integer,RangeSet> r = new TreeMap<Integer,RangeSet>(REVERSE_INTEGER_COMPARATOR);

        checkAndRecord(that, r, this.getBuilds());
        // checkAndRecord(that, r, that.getBuilds());

        return r;
    }
847106
public Set<Tile> getNeighbours() {
        Set<Tile> neighbours = new HashSet<Tile>(8);
        neighbours.add(getLeft());
        neighbours.add(getAboveLeft());
        neighbours.add(getAbove());
        neighbours.add(getAboveRight());
        neighbours.add(getRight());
        neighbours.add(getBelowRight());
        neighbours.add(getBelow());
        neighbours.add(getBelowLeft());
        return neighbours;
    }
1016184
public List<T> getAll() {
		List<T> result = new ArrayList<T>();
		if (nodes != null)
			for(Node element : nodes) 
				result.add(getCachedOrNewRepresentation(element));
		return result;
	}
	
	public int size() {
		return nodes.size();
	}
	
	public T get(int index) {
		return getCachedOrNewRepresentation(nodes.get(index));
	}
		
	public Iterator<T> iterator() {
		return getAll().iterator();
	}
}
812617
public ArrayList<Integer> getUnvisited() {
    if (0 == this.unvisitedCount) {
      return new ArrayList<Integer>();
    }
    ArrayList<Integer> res = new ArrayList<Integer>(this.unvisitedCount);
    for (int i = 0; i < this.registry.length; i++) {
      if (ZERO == this.registry[i]) {
        res.add(i);
      }
    }
    return res;
  }
1226209
def getNeighbouringDevices(self):
        
        print '%s call getNeighbouringDevices' % self.port
        neighbourList = []

        # get parent info
        parentAddr = self.getParentAddress()
        if parentAddr != 0:
            neighbourList.append(parentAddr)

        # get ED/SED children info
        childNeighbours = self.getChildrenInfo()
        if childNeighbours != None and len(childNeighbours) > 0:
            for entry in childNeighbours:
                neighbourList.append(entry)

        # get neighboring routers info
        routerNeighbours = self.getNeighbouringRouters()
        if routerNeighbours != None and len(routerNeighbours) > 0:
            for entry in routerNeighbours:
                neighbourList.append(entry)

        print neighbourList
        return neighbourList