Returns an unmodifiable view of the list that will be returned by {@link
Datatype#getNestedClasses()}. Changes to this builder will be reflected in the view.
553110
public List<Excerpt> getNestedClasses() {
    if (nestedClasses instanceof ImmutableList) {
      nestedClasses = new ArrayList<>(nestedClasses);
    }
    return Collections.unmodifiableList(nestedClasses);
  }
935228
public ListMultimap<Class<?>, Object> getParamsForType() {
		ArrayListMultimap<Class<?>, Object> retVal = ArrayListMultimap.create();
		myParams.entries().forEach(entry -> retVal.put(entry.getKey(), unwrapValue(entry.getValue())));
		return Multimaps.unmodifiableListMultimap(retVal);
	}
478806
public Set<Class<?>> getPrevented() {
        if (this.prevent == null) {
            return Collections.emptySet();
        }
        return Collections.unmodifiableSet(this.prevent);
    }
997681
@Nonnull
    public ImmutableList<T> toList() {
        return this.foldAbelian((v, acc) -> acc.cons(v), ImmutableList.empty());
    }
361464
public String[] getAvailableDictionaryClasses() {
        List<String> classList = new ArrayList<String>();
        for (IImplementationSpecification spec : speclist) {
            String[] tmp = getDictionaryClass(spec);
            if (tmp != null) classList.addAll(Arrays.asList(tmp));
        }
        Set<String> uniqueClasses = new HashSet<String>(classList);
        return (String[]) uniqueClasses.toArray(new String[]{});
    }
29979
public static <T> Set<T> immutableSetView(Set<T> set) {
        if (set instanceof ImmutableSet<?>) {
            return set;
        }
        return Collections.unmodifiableSet(set);
    }
740398
@SuppressWarnings("unchecked")
    public Map<String, Class<?>> getAllEntries() {
        return (Map<String, Class<?>>) MapUtils.unmodifiableMap(entries);
    }
340402
public List<IfClassNotAvailable<Exclude<T>>> getAllIfClassNotAvailable()
   {
      List<IfClassNotAvailable<Exclude<T>>> list = new ArrayList<IfClassNotAvailable<Exclude<T>>>();
      List<Node> nodeList = childNode.get("if-class-not-available");
      for(Node node: nodeList)
      {
         IfClassNotAvailable<Exclude<T>>  type = new IfClassNotAvailableImpl<Exclude<T>>(this, "if-class-not-available", childNode, node);
         list.add(type);
      }
      return list;
   }
426811
public Set<Classification> getChildClassifications()
        throws CacheReloadException
    {
        final Set<Classification> ret = new HashSet<>();
        for (final Long id : this.children) {
            final Classification child = Classification.get(id);
            ret.add(child);
        }
        return Collections.unmodifiableSet(ret);
    }
42261
@Inline(value="$2.$3unmodifiableSet($1)", imported=Collections.class)
	public static <T> Set<T> unmodifiableView(Set<? extends T> set) {
		return Collections.unmodifiableSet(set);
	}
948130
public List<MappedSuperclass<OrmDescriptor>> getAllMappedSuperclass()
   {
      List<MappedSuperclass<OrmDescriptor>> list = new ArrayList<MappedSuperclass<OrmDescriptor>>();
      List<Node> nodeList = model.get("mapped-superclass");
      for(Node node: nodeList)
      {
         MappedSuperclass<OrmDescriptor>  type = new MappedSuperclassImpl<OrmDescriptor>(this, "mapped-superclass", model, node);
         list.add(type);
      }
      return list;
   }
947962
@Override
    public List<ComponentType> children() {
        synchronized (this) {
            List<ComponentType> children = new ArrayList<ComponentType>();
            for (ComponentVertex child : this.children) {
                children.add(child.component());
            }
            return Collections.unmodifiableList(children);
        }
    }
128938
public Set<ClassDescriptor> getDirectSubtypes(ClassDescriptor classDescriptor) throws ClassNotFoundException {

        ClassVertex startVertex = resolveClassVertex(classDescriptor);

        Set<ClassDescriptor> result = new HashSet<>();
        Iterator<InheritanceEdge> i = graph.incomingEdgeIterator(startVertex);
        while (i.hasNext()) {
            InheritanceEdge edge = i.next();
            result.add(edge.getSource().getClassDescriptor());
        }

        return result;
    }
704760
public static <T> List<T> toImmutableList(final List<? extends T> list) {
    switch (list.size()) {
      case 0:
        return Collections.emptyList();
      case 1:
        return Collections.singletonList(list.get(0));
      default:
        return Collections.unmodifiableList(list);
    }
  }
718209
public ClassInfoList getAllAnnotations() {
        if (closed.get()) {
            throw new IllegalArgumentException("Cannot use a ScanResult after it has been closed");
        }
        if (!scanSpec.enableClassInfo || !scanSpec.enableAnnotationInfo) {
            throw new IllegalArgumentException(
                    "Please call ClassGraph#enableClassInfo() and #enableAnnotationInfo() before #scan()");
        }
        return ClassInfo.getAllAnnotationClasses(classNameToClassInfo.values(), scanSpec);
    }
964882
private static <T> List<T> unmodifiableList(List<T> list) {
        if (list == null) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(list);
    }
137678
public final ImmutableList<ObjectType> getImplementedInterfaces() {
    FunctionType superCtor = isConstructor() ? getSuperClassConstructor() : null;
    if (superCtor == null) {
      return implementedInterfaces;
    }
    ImmutableList.Builder<ObjectType> builder = ImmutableList.builder();
    builder.addAll(implementedInterfaces);
    while (superCtor != null) {
      builder.addAll(superCtor.implementedInterfaces);
      superCtor = superCtor.getSuperClassConstructor();
    }
    return builder.build();
  }