Returns a {@code Set} representing all the Unicode ranges in
this {@code NumericShaper} that will be shaped.

@return all the Unicode ranges to be shaped.
@since 1.7
437416
public Set<Range> getRangeSet() {
        if (rangeSet != null) {
            return EnumSet.copyOf(rangeSet);
        }
        return Range.maskToRangeSet(mask);
    }
334192
public SortedSet<String> fields() {
		// Optimization: Materialize the fields set
		if (myFieldSet == null)
			myFieldSet = new TreeSet<String>(fields.keySet());
		return myFieldSet;
	}
128960
public Set<String> getTypesWithActiveSchemaFormatters() {

        Set<String> result = Sets.newHashSet(getTypesWithModifiableFormatters());
        for (CmsFormatterChangeSet changeSet : getFormatterChangeSets()) {
            changeSet.applyToTypes(result);
        }
        return result;
    }
592401
public Set<String> names() {
        TreeSet<String> result = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
        for (int i = 0, size = size(); i < size; i++) {
            result.add(name(i));
        }
        return Collections.unmodifiableSet(result);
    }
1215852
public Range[] getRanges() {
		Range[] ranges = new Range[nodes.size()];
		for (int i = 0; i < ranges.length; i++) {
			ranges[i] = nodes.get(i).getRange();
		}
		return ranges;
	}
932764
protected Vec[][] makeTemplates() {
    Vec anyVec = dataset.anyVec();
    final long[][] espcPerSplit = computeEspcPerSplit(anyVec._espc, anyVec.length());
    final int num = dataset.numCols(); // number of columns in input frame
    final int nsplits = espcPerSplit.length; // number of splits
    final String[][] domains = dataset.domains(); // domains
    final boolean[] uuids = dataset.uuids();
    final byte[] times = dataset.times();
    Vec[][] t = new Vec[nsplits][/*num*/]; // resulting vectors for all
    for (int i=0; i<nsplits; i++) {
      // vectors for j-th split
      t[i] = new Vec(Vec.newKey(),espcPerSplit[i/*-th split*/]).makeZeros(num, domains, uuids, times);
    }
    return t;
  }
562142
public Set<String> getExpand()
	{
		List<String> values = parameters.get(WQUriControlField.EXPAND.getName());

		if (values == null || values.isEmpty())
			return Collections.singleton("all");
		else
			return new HashSet<>(values);
	}
321365
public Set<String> stringKeySet() {
        return data.keySet().stream()
                .map(Any2::getRight)
                .flatMap(opt -> opt.map(Stream::of).orElseGet(Stream::empty))
                .collect(Collectors.toSet());
    }
828685
public Set<HttpMethod> getAllow() {
		String value = getFirst(ALLOW);
		if (!StringUtils.isEmpty(value)) {
			List<HttpMethod> allowedMethod = new ArrayList<HttpMethod>(5);
			String[] tokens = value.split(",\\s*");
			for (String token : tokens) {
				allowedMethod.add(HttpMethod.valueOf(token));
			}
			return EnumSet.copyOf(allowedMethod);
		}
		else {
			return EnumSet.noneOf(HttpMethod.class);
		}
	}
445859
public Set tokens() {
        if (tokenSet == null) {
            tokenSet = new AbstractSetView() {
                public long size() {
                    return 0;
                }

                public Iterator iterator() {
                    return new Iterator() {

                        public boolean hasNext()
                        {
                            return false;
                        } // hasNext().

                        public Object next()
                        {
                            throw new java.util.NoSuchElementException();
                        } // next().

                        public boolean hasNext(Transaction transaction)
                                        throws ObjectManagerException
                        {
                            throw new UnsupportedOperationException();
                        } // hasNext().

                        public Object next(Transaction transaction)
                                        throws ObjectManagerException
                        {
                            throw new UnsupportedOperationException();
                        } // next().

                        public Object remove(Transaction transaction)
                                        throws ObjectManagerException
                        {
                            throw new UnsupportedOperationException();
                        } // remove().

                    }; // new Iterator().
                } // iterator().  
            }; // new AbstractSetView().
        } // if (tokenSet == null). 
        return tokenSet;
    }
960323
public static Charset[] getAvailableCharsets() {
        Collection collection = Charset.availableCharsets().values();
        return (Charset[]) collection.toArray(new Charset[collection.size()]);
    }
848959
private ImmutableSet<Class<? super T>> getImmediateRawTypes() {
    // Cast from ImmutableSet<Class<?>> to ImmutableSet<Class<? super T>>
    @SuppressWarnings({"unchecked", "rawtypes"})
    ImmutableSet<Class<? super T>> result = (ImmutableSet) getRawTypes(runtimeType);
    return result;
  }
18971
public OffsetRange<CharOffset> offsets() {
    final CharOffset start = tokens.get(0).offsets().startInclusive();
    final CharOffset end = tokens.reverse().get(0).offsets().endInclusive();
    return OffsetRange.charOffsetRange(start.asInt(), end.asInt());
  }
590048
public Set<String> rangeByLexReverse(final LexRange lexRange) {
        return doWithJedis(new JedisCallable<Set<String>>() {
            @Override
            public Set<String> call(Jedis jedis) {
                if (lexRange.hasLimit()) {
                    return jedis.zrevrangeByLex(getKey(), lexRange.fromReverse(), lexRange.toReverse(), lexRange.offset(), lexRange.count());
                } else {
                    return jedis.zrevrangeByLex(getKey(), lexRange.fromReverse(), lexRange.toReverse());
                }
            }
        });
    }
740561
RangeSet possibleMoves()
    {
        List<RangeSet> list = new ArrayList<>();
        for (NFAState<T> nfa : nfaSet)
        {
            list.add(nfa.getConditions());
        }
        return RangeSet.split(list);
    }
545051
protected Set<String> getPrevExpandedRows() {
		Set<String> prev = getComponentModel().prevExpandedRows;
		if (prev == null) {
			return Collections.emptySet();
		} else {
			return Collections.unmodifiableSet(prev);
		}
	}
6580
public static <T extends Comparable<T>> RangeSet<T> unionRanges(final Iterable<Range<T>> ranges)
  {
    RangeSet<T> rangeSet = null;
    for (Range<T> range : ranges) {
      if (rangeSet == null) {
        rangeSet = TreeRangeSet.create();
      }
      rangeSet.add(range);
    }
    return rangeSet;
  }