Creates a {@link RubyRange} by given chars.

@param start
of the range
@param end
of the range
@return {@link RubyRange}
488107
public static RubyRange<Character> range(char start, char end) {
    return new RubyRange<>(CharacterSuccessor.getInstance(), start, end,
        Interval.CLOSED);
  }
105591
public StrBuilder del(int start, int end) {
		if (start < 0) {
			start = 0;
		}
		if (end > this.position) {
			end = this.position;
		}
		if (start > end) {
			throw new StringIndexOutOfBoundsException("Start is greater than End.");
		}
		if (end == this.position) {
			this.position = start;
		}

		int len = end - start;
		if (len > 0) {
			System.arraycopy(value, start + len, value, start, this.position - end);
			this.position -= len;
		}
		return this;
	}
748363
public static RubyRange<LocalDateTime> range(LocalDateTime start,
      LocalDateTime end) {
    return new RubyRange<>(LocalDateTimeSuccessor.getInstance(), start, end,
        Interval.CLOSED);
  }
1311337
private Range getRange(final URI uri) {
        int start = 0;
        int end = Integer.MAX_VALUE;
        String startId = null;
        String endId = null;

        final String fragment = uri.getFragment();
        if (fragment != null) {
            // RFC 5147
            final Matcher m = Pattern.compile("^line=(?:(\\d+)|(\\d+)?,(\\d+)?)$").matcher(fragment);
            if (m.matches()) {
                if (m.group(1) != null) {
                    start = Integer.parseInt(m.group(1));
                    end = start;
                } else {
                    if (m.group(2) != null) {
                        start = Integer.parseInt(m.group(2));
                    }
                    if (m.group(3) != null) {
                        end = Integer.parseInt(m.group(3)) - 1;
                    }
                }
                return new LineNumberRange(start, end).handler(this);
            } else {
                final Matcher mc = Pattern.compile("^line-range\\((\\d+)(?:,\\s*(\\d+))?\\)$").matcher(fragment);
                if (mc.matches()) {
                    start = Integer.parseInt(mc.group(1)) - 1;
                    if (mc.group(2) != null) {
                        end = Integer.parseInt(mc.group(2)) - 1;
                    }
                    return new LineNumberRange(start, end).handler(this);
                } else {
                    final Matcher mi = Pattern.compile("^token=([^,\\s)]*)(?:,\\s*([^,\\s)]+))?$").matcher(fragment);
                    if (mi.matches()) {
                        if (mi.group(1) != null && mi.group(1).length() != 0) {
                            startId = mi.group(1);
                        }
                        if (mi.group(2) != null) {
                            endId = mi.group(2);
                        }
                        return new AnchorRange(startId, endId).handler(this);
                    }
                }
            }
        }

        return new AllRange().handler(this);
    }
1319335
public void append(long start, long end) {
        assert(start <= end && (m_map.isEmpty() || start > end(m_map.span())));
        addRange(start, end);
    }
249725
private static int findStart( char[] buffer, int start, int end )
    {
        int pos, cp;
        for ( pos = start; pos < end && isWhitespace( cp = codePointAt( buffer, pos ) ); pos += charCount( cp ) )
        {
            if ( cp == '\n' )
            {
                start = pos + 1;
            }
        }
        return pos >= end ? end : start;
    }
521562
public static RubyRange<Long> range(long start, long end) {
    return new RubyRange<>(LongSuccessor.getInstance(), start, end,
        Interval.CLOSED);
  }
771883
public char[] toCharArray(int start, int end) {
        int length = end - start;
        if (length == 0) {
            return EmptyArrays.EMPTY_CHARS;
        }

        if (isOutOfBounds(start, length, length())) {
            throw new IndexOutOfBoundsException("expected: " + "0 <= start(" + start + ") <= srcIdx + length("
                            + length + ") <= srcLen(" + length() + ')');
        }

        final char[] buffer = new char[length];
        for (int i = 0, j = start + arrayOffset(); i < length; i++, j++) {
            buffer[i] = b2c(value[j]);
        }
        return buffer;
    }
928489
public Query range(String start, String end) {
    return range(wrapKey(start), wrapKey(end));
  }
754940
public static IParseTree[] findSpanningLogicalRange( IParseTree start, IParseTree end )
  {
    while( end != null )
    {
      IParseTree deepestAtStart = start;
      while( deepestAtStart != null )
      {
        if( deepestAtStart.isSiblingOf( end ) )
        {
          IParseTree[] returnVal = new IParseTree[2];

          if( deepestAtStart.getOffset() < end.getOffset() )
          {
            returnVal[0] = deepestAtStart;
          }
          else
          {
            returnVal[0] = end;
          }

          if( deepestAtStart.getExtent() > end.getExtent() )
          {
            returnVal[1] = deepestAtStart;
          }
          else
          {
            returnVal[1] = end;
          }

          return returnVal;
        }
        deepestAtStart = deepestAtStart.getParent();
      }
      end = end.getParent();
    }
    return null;
  }
965823
function setSelectionRange(input, start, end){
    if (arguments.length < 3)
      end = start;

    if (input.setSelectionRange)
      input.setSelectionRange(start, end);
    else
      if (input.createTextRange)
      {
        // IE
        var range = input.createTextRange();
        range.collapse(true);
        range.moveStart('character', start);
        range.moveEnd('character', end - start);
        range.select();
      }
  }
374260
public static String[] subarrayOf
            (final String[] array,
             final int start,
             final int end)
        {
        final int subarraySize = end - start;
        final String[] subarray = new String[subarraySize];

        for (int i = 0; i < subarraySize; ++i)
            {
            subarray[i] = array[i + start];
            }

        return (subarray);
        }
57116
def getrange(self, key, start, end, *, encoding=_NOTSET):
        
        if not isinstance(start, int):
            raise TypeError("start argument must be int")
        if not isinstance(end, int):
            raise TypeError("end argument must be int")
        return self.execute(b'GETRANGE', key, start, end, encoding=encoding)
652026
DialectSqlItem[] seperateCharsToItems(char[] chars, int start, int end) {
		List<DialectSqlItem> items = new ArrayList<DialectSqlItem>();
		SearchResult result = findFirstResult(chars, start, end);
		while (result != null) {
			items.add(result.item);
			result = findFirstResult(chars, result.leftStart, result.leftEnd);
		}
		return items.toArray(new DialectSqlItem[items.size()]);
	}
717474
public String substring(int start, int end) {
        int length = end - start;
        if (start > pos || length > pos) {
            throw new IndexOutOfBoundsException();
        }
        return new String(chars, start, length);
    }
632676
function RangeIterator(start, end, step) {
    this.start = start;
    this.end = (end !== undefined) ? end : Math.pow(2,32);    // or should this be Number.MAX_VALUE
    this.step = (step !== undefined)
        ? step
        : (this.end >= this.start)
            ? 1
            : -1;
    this.reset();
}
826925
public function fillRange(Scope $head,$start,$end)
    {
        
        $start_index  = Utf8::ord($start);
        $ending_index = Utf8::ord($end);
        
        if($ending_index < $start_index ) {
            throw new ParserException(sprintf('Character class range %s - %s is out of order',$start,$end));
        }
        
        for($i = $start_index; $i <= $ending_index; $i++) {
            $head->setLiteral($i,Utf8::chr($i));
        }    
    }