{@inheritDoc}
@param fromElement
@param inclusive
@return
495643
@Override
    public NavigableSet<E> tailSet(E fromElement, boolean inclusive)
    {
        int low = lowIndexOf(fromElement, inclusive);
        return new BinarySet(comparator, list.subList(low, list.size()), false);
    }
747302
public static <T extends Comparable<? super T>> Predicates<T> betweenExclusive(T from, T to)
    {
        Predicates.failIfDifferentTypes(from, to);
        return new BetweenExclusive<T>(from, to);
    }
618833
public Object transform( int from, int to, Object input ) {
        return transform( from, to, input, null );
    }
225771
Set<MapElementContainer> getOverlappingElements(Tile from, Tile to) {
        if (overlapData.containsKey(from) && overlapData.get(from).containsKey(to)) {
            return overlapData.get(from).get(to);
        }
        return new HashSet<MapElementContainer>(0);
    }
18349
public function indexOf($searchElement, $fromIndex = 0)
    {
        $result = array_search($searchElement, $this->getArrayCopy(), true);

        return $result === false ? -1 : $result + $fromIndex;

        // if ($fromIndex < 0) {
        //     $fromIndex = $this->length() + $fromIndex;
        // }
        // $result = array_search($searchElement, $this->slice($fromIndex)->getArrayCopy(), true);

        // return $result === false ? -1 : $result + $fromIndex;
    }
1331670
protected Text extractText(Element fromElement) {
        fromElement.normalize();
        NodeList fromNodeList = fromElement.getChildNodes(); 
        Node currentNode;
        for (int i=0; i < fromNodeList.getLength(); ++i) {
            currentNode = fromNodeList.item(i);
            if (currentNode.getNodeType() == Node.TEXT_NODE) {
                return (Text) currentNode;
            }
        }
        return null;
    }
267157
public final <A extends Number & Comparable<?>> BooleanExpression between(@Nullable A from, @Nullable A to) {
        if (from == null) {
            if (to != null) {
                return loe(to);
            } else {
                throw new IllegalArgumentException("Either from or to needs to be non-null");
            }
        } else if (to == null) {
            return goe(from);
        } else {
            return between(ConstantImpl.create(cast(from)), ConstantImpl.create(cast(to)));
        }
    }
932124
private String simpleElement(StructureDefinition sd, ElementDefinition ed, String typ) {
    String addldef = "";
    ElementDefinition.ElementDefinitionBindingComponent binding = ed.getBinding();
    if(binding.hasStrength() && binding.getStrength() == Enumerations.BindingStrength.REQUIRED && "code".equals(typ)) {
      ValueSet vs = resolveBindingReference(sd, binding.getValueSet());
      if (vs != null) {
        addldef = tmplt(VALUESET_DEFN_TEMPLATE).add("vsn", vsprefix(vs.getUrl())).render();
        required_value_sets.add(vs);
      }
    }
    // TODO: check whether value sets and fixed are mutually exclusive
    if(ed.hasFixed()) {
      addldef = tmplt(FIXED_VALUE_TEMPLATE).add("val", ed.getFixed().primitiveValue()).render();
    }
    return tmplt(SIMPLE_ELEMENT_DEFN_TEMPLATE).add("typ", typ).add("vsdef", addldef).render();
  }
503872
@Nonnull
  public static <ELEMENTTYPE> Enumeration <ELEMENTTYPE> getEnumeration (@Nullable final Iterable <ELEMENTTYPE> aCont)
  {
    return CollectionHelper.isEmpty (aCont) ? new EmptyEnumeration <> () : getEnumeration (aCont.iterator ());
  }
746600
private void convertNullSafeWrapperToPrimitive(
			LightweightTypeReference wrapper,
			LightweightTypeReference primitive,
			XExpression context,
			ITreeAppendable appendable,
			Later expression) {
		// BEGIN Specific
		final String defaultValue = primitive.isType(boolean.class) ? "false" : "0"; //$NON-NLS-1$ //$NON-NLS-2$
		// END Specific
		final XExpression normalized = normalizeBlockExpression(context);
		if (normalized instanceof XAbstractFeatureCall && !(context.eContainer() instanceof XAbstractFeatureCall)) {
			// Avoid javac bug
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=410797
			// TODO make that dependent on the compiler version (javac 1.7 fixed that bug)
			final XAbstractFeatureCall featureCall = (XAbstractFeatureCall) normalized;
			if (featureCall.isStatic()) {
				final JvmIdentifiableElement feature = featureCall.getFeature();
				if (feature instanceof JvmOperation) {
					if (!((JvmOperation) feature).getTypeParameters().isEmpty()) {
						// BEGIN Specific
						appendable.append("(("); //$NON-NLS-1$
						expression.exec(appendable);
						appendable.append(") == null ? "); //$NON-NLS-1$
						appendable.append(defaultValue);
						appendable.append(" : "); //$NON-NLS-1$
						// END Specific
						appendable.append("("); //$NON-NLS-1$
						appendable.append(primitive);
						appendable.append(") "); //$NON-NLS-1$
						expression.exec(appendable);
						// BEGIN Specific
						appendable.append(") "); //$NON-NLS-1$
						// END Specific
						return;
					}
				}
			}
		}

		// BEGIN Specific
		appendable.append("(("); //$NON-NLS-1$
		expression.exec(appendable);
		appendable.append(") == null ? "); //$NON-NLS-1$
		appendable.append(defaultValue);
		appendable.append(" : "); //$NON-NLS-1$
		// END Specific
		final boolean mustInsertTypeCast;
		try {
			mustInsertTypeCast = (Boolean) this.reflect.invoke(this, "mustInsertTypeCast", context, wrapper); //$NON-NLS-1$
		} catch (Exception exception) {
			throw new Error(exception);
		}
		if (mustInsertTypeCast) {
			appendable.append("("); //$NON-NLS-1$
			appendable.append(wrapper);
			appendable.append(") "); //$NON-NLS-1$
		}
		// BEGIN Specific
		appendable.append("("); //$NON-NLS-1$
		expression.exec(appendable);
		appendable.append(")"); //$NON-NLS-1$
		// END Specific
		appendable.append("."); //$NON-NLS-1$
		appendable.append(primitive);
		appendable.append("Value())"); //$NON-NLS-1$
	}
1290231
public void removeElements(final int from, final int to) {
        CharArrays.ensureFromTo(size, from, to);
        System.arraycopy(a, to, a, from, size - to);
        size -= (to - from);
    }
931158
public static <E> OqlBuilder<E> from(final String from) {
    OqlBuilder<E> query = new OqlBuilder<E>();
    query.newFrom(from);
    return query;
  }
240960
@Pure
	@SuppressWarnings("checkstyle:cyclomaticcomplexity")
	public static Class<? extends MapElement> fromESRI(ShapeElementType type) {
		switch (type) {
		case MULTIPOINT:
		case MULTIPOINT_M:
		case MULTIPOINT_Z:
			return MapMultiPoint.class;
		case POINT:
		case POINT_M:
		case POINT_Z:
			return MapPoint.class;
		case POLYGON:
		case POLYGON_M:
		case POLYGON_Z:
			return MapPolygon.class;
		case POLYLINE:
		case POLYLINE_M:
		case POLYLINE_Z:
			return MapPolyline.class;
			//$CASES-OMITTED$
		default:
		}
		throw new IllegalArgumentException();
	}
668693
private Set<TypeMirror> getExcludedAnnotationTypes(Element element) {
    Optional<AnnotationMirror> maybeAnnotation =
        getAnnotationMirror(element, COPY_ANNOTATIONS_NAME);
    if (!maybeAnnotation.isPresent()) {
      return ImmutableSet.of();
    }

    @SuppressWarnings("unchecked")
    List<AnnotationValue> excludedClasses =
        (List<AnnotationValue>) getAnnotationValue(maybeAnnotation.get(), "exclude").getValue();
    return excludedClasses
        .stream()
        .map(annotationValue -> (DeclaredType) annotationValue.getValue())
        .collect(toCollection(TypeMirrorSet::new));
  }
593642
public final <A extends Number & Comparable<?>> BooleanExpression between(@Nullable Expression<A> from, @Nullable Expression<A> to) {
        if (from == null) {
            if (to != null) {
                return Expressions.booleanOperation(Ops.LOE, mixin, to);
            } else {
                throw new IllegalArgumentException("Either from or to needs to be non-null");
            }
        } else if (to == null) {
            return Expressions.booleanOperation(Ops.GOE, mixin, from);
        } else {
            return Expressions.booleanOperation(Ops.BETWEEN, mixin, from, to);
        }
    }
921834
@SafeVarargs
    /* #end */
  public static <KType> KTypeArrayList<KType> from(KType... elements) {
    final KTypeArrayList<KType> list = new KTypeArrayList<KType>(elements.length);
    list.add(elements);
    return list;
  }
338212
public static <T extends Comparable<? super T>> Predicates<T> betweenInclusiveFrom(T from, T to)
    {
        Predicates.failIfDifferentTypes(from, to);
        return new BetweenInclusiveFrom<T>(from, to);
    }