List Implementation ------------------------------------------ 

@param length
@returns {*}
@constructor
@function
768613
function List(length) {
        if (arguments.length === 0) {
            length = 0;
        }

        // in this case we create a list with a given length
        if (arguments.length <= 1 && typeof length === 'number') {
            if (this instanceof List) {
                this.length = length;
            }
            else {
                return new List(length);
            }
        }
        else {
            //here we create a list with initial values
            if (!(this instanceof List)) {
                return List.fromArray(arrSlice(arguments));
            }
            else {
                for (var i = 0, l = arguments.length ; i < l ; i++) {
                    this[i] = arguments[i];
                }
                this.length = arguments.length;
            }
        }
    }
343855
function VARCHAR(length) {
    length = length || 255;
    if (!(this instanceof VARCHAR)) {
        return new VARCHAR(length);
    }
    this.length = length;
    this.sql = 'VARCHAR(' + length + ')';
}
544532
function makeArray( length ) {
    var res = new Array( length );
    var i = -1;

    while( ++i < length ) {
        res[i] = _bluebird2.default.resolve( i );
    }

    return res;
}
522397
function randomString (length) {
    length = length || 6;

    var result = [],
        i;

    for (i = 0; i < length; i++) {
        result[i] = ASCII_SOURCE[(Math.random() * ASCII_SOURCE_LENGTH) | 0];
    }

    return result.join(EMPTY);
}
182450
function CHAR(length) {
    length = length || 255;
    if (!(this instanceof CHAR)) {
        return new CHAR(length);
    }
    this.length = length;
    this.sql = 'CHAR(' + length + ')';
}
1322613
function(length) {
  if(typeof length !== "number") return null;
  if(length < 0) return null;

  let len = [];
  let digit = 0;

  do {
    digit = length % 128 | 0;
    length = length / 128 | 0;
    if (length > 0) {
        digit = digit | 0x80;
    }
    len.push(digit);
  } while (length > 0);

  return len;
}
730613
function concat(list, totalLength) {
  if (list.length === 0) return EMPTY_BUFFER;
  if (list.length === 1) return list[0];

  const target = Buffer.allocUnsafe(totalLength);
  let offset = 0;

  for (let i = 0; i < list.length; i++) {
    const buf = list[i];
    buf.copy(target, offset);
    offset += buf.length;
  }

  return target;
}
840781
function(a, length, msg) {
    return assert((this.assertIsArray(a, msg) && a.length <= length), msg);
  }
937945
function toArray( list ) {
    const array = [];
    // iterate backwards ensuring that length is an UInt32
    for ( let i = list.length >>> 0; i--; ) {
        array[ i ] = list[ i ];
    }
    return array;
}
745561
function evalList(scope, list) {
  const length = list.length;
  const result = [];
  for (let i = 0; i < length; i++) {
    result[i] = list[i].evaluate(scope);
  }
  return result;
}
1085351
function(list) {
            if (!isArray(list.value))
                return list;

            var listType, row, rowType;
            rowType  = list.type;
            list     = list.value;
            listType = list[0].type;
            row      = list[0].value;

            list = (isArray(row) ? row : [row]).map(function(col, i) {
                return newLessList(list.map(function(row) {
                    return (isArray(row.value)
                        ? row.value : [row])[i]
                            || new Node();
                }), rowType);
            });

            return newLessList(list, listType);
        }
1129910
public static List<Kontonummer> getKontonummerList(int length) {
		final class NormalKontonrDigitGenerator extends KontonummerDigitGenerator {
			@Override
			String generateKontonummer() {
				StringBuilder kontonrBuffer = new StringBuilder(LENGTH);
				for (int i = 0; i < LENGTH; i++) {
					kontonrBuffer.append((int) (Math.random() * 10));
				}
				return kontonrBuffer.toString();
			}
		}
		return getKontonummerListUsingGenerator(new NormalKontonrDigitGenerator(), length);
	}
612977
static <E> ImmutableList<E> asImmutableList(Object[] elements, int length) {
    switch (length) {
      case 0:
        return of();
      case 1:
        @SuppressWarnings("unchecked") // collection had only Es in it
        ImmutableList<E> list = new SingletonImmutableList<E>((E) elements[0]);
        return list;
      default:
        if (length < elements.length) {
          elements = arraysCopyOf(elements, length);
        }
        return new RegularImmutableList<E>(elements);
    }
  }
883101
function List(name, expiry, maxLength) {
  this.name = name;
  this.expiry = expiry;
  this.maxLength = maxLength;
  this.idGen = new IdGen('id_gen:/'+name);
}
829850
function(list){
		var type = typeof list;
		if(type === "string" || Array.isArray(list)) {
			return true;
		}
		var length = list && (type !== 'boolean' && type !== 'number' && "length" in list) && list.length;

		// var length = "length" in obj && obj.length;
		return typeof list !== "function" &&
			( length === 0 || typeof length === "number" && length > 0 && ( length - 1 ) in list );
	}
374913
function (string, size, begin) {
            var result = [], start, strLen = string.length;

            if (size < 1 || size >= strLen) {
                return [string];
            } else if (size === 1) {
                // split is faster than what I want to do
                return string.split('');
            }

            if (begin === true) {
                start = 0;
                while (start < strLen) {
                    result.push(string.substr(start, size));
                    start += size;
                }

                return result;
            } else {
                start = strLen;
                while (start > 0) {
                    result.push(string.substring(Math.max(0, start - size), start));
                    start -= size;
                }

                return result.reverse();
            }
        }
374408
function(length, opt) {

            var index = this.segmentIndexAtLength(length, opt);
            if (!index) return null;

            return this.getSegment(index);
        }