Same as get. But retuns the elements one by one, much more efficient for large outputs
550056
def iterGet(self, objectType, *args, **coolArgs) :
		""""""

		for e in self._makeLoadQuery(objectType, *args, **coolArgs).iterRun() :
			if issubclass(objectType, pyGenoRabaObjectWrapper) :
				yield objectType(wrapped_object_and_bag = (e, self.bagKey))
			else :
				yield e
1099780
public Iterable<String> get(String index, String... keys) {
        return get(index, Arrays.asList(keys));
    }
335854
function get ( text ) {
	var result = {};
	each(cache, function ( value, index ) {
		if ( value.text === trim(text) ) {
			result = value;
			return false;
		}
	});
	return toarray(result.results);
}
1136201
def each
      return to_enum unless block_given?
      super do |resource|
        begin
          original, resource.collection = resource.collection, self
          yield resource
        ensure
          resource.collection = original
        end
      end
    end
110306
def getting(self):
        
        c = Counter(self._get.copy())
        return [(n, t) for t, n in c.items()]
1166314
function getter (index) {
  debug('getting array[%d]', index)
  var size = this.constructor.BYTES_PER_ELEMENT
  var baseType = this.constructor.type
  var offset = size * index
  var end = offset + size
  var buffer = this.buffer
  if (buffer.length < end) {
    debug('reinterpreting buffer from %d to %d', buffer.length, end)
    buffer = _ref.reinterpret(buffer, end)
  }
  return _ref.get(buffer, offset, baseType)
}
646934
def permute(elements):
    
    if len(elements) <= 1:
        return [elements]
    else:
        tmp = []
        for perm in permute(elements[1:]):
            for i in range(len(elements)):
                tmp.append(perm[:i] + elements[0:1] + perm[i:])
        return tmp
985763
function (elements, fn) {
            var _arr = [];
            if (vQ.isArrayLike(elements)) {
                for (var i = 0; i < elements.length; i++) {
                    var val1 = fn(elements[i], i);
                    if (val1 != null) {
                        _arr.push(val1);
                    }
                }
            } else {
                for (var key in elements) {
                    var val2 = fn(elements[key], key);
                    if (val2 != null) {
                        _arr.push(val2);
                    }
                }
            }
            return _arr;
        }
662142
function multiread(stream, get) {
    if (stream._multiread === undefined) {
        stream._multiread = stream._multiread || [];
        stream._multireading = stream._multireading || 0;
        stream._multireadmax = stream._multireadmax || concurrency;
    }
    if (stream._multiread.length) {
        push();
    } else {
        stream.once('_push', push);
    }
    while ((stream._multiread.length + stream._multireading) < stream._multireadmax) {
        stream._multireading++;
        if (!get(done)) break;
    }

    function done(item) {
        stream._multireading--;
        if (item === null && !stream._multireading) {
            stream.emit('_push');
        } else if (item) {
            stream._multiread.push(item);
            stream.emit('_push');
        }
    }

    function push() {
        if (stream._multiread.length) {
            stream.push(stream._multiread.shift());
        } else {
            stream.push(null);
        }
    }
}
753944
def copy(self):
        """"""
        result = self.space.element()
        result.assign(self)
        return result
467903
private static <T> T get(ListIterator<? extends T> i, int index) {
        T obj = null;
        int pos = i.nextIndex();
        if (pos <= index) {
            do {
                obj = i.next();
            } while (pos++ < index);
        } else {
            do {
                obj = i.previous();
            } while (--pos > index);
        }
        return obj;
    }
250057
function iterateElements(array) {
  return {
    __iterator__: function() {
      var index = 0;
      var current;
      return {
        get current() {
          return current;
        },
        moveNext: function() {
          if (index < array.length) {
            current = array[index++];
            return true;
          }
          return false;
        }
      };
    }
  };
}
828591
function() {
			var content = '', files = [];
			if (this.$element[0].files === undefined) {
				files[0] = {
					'name' : this.$element[0] && this.$element[0].value
				};
			} else {
				files = this.$element[0].files;
			}

			for (var i = 0; i < files.length; i++) {
				content += files[i].name.split("\\").pop() + ', ';
			}

			if (content !== '') {
				this.$elementFilestyle.find(':text').val(content.replace(/\, $/g, ''));
			} else {
				this.$elementFilestyle.find(':text').val('');
			}
			
			return files;
		}
554887
def chunks(iterable, size=1):
    """"""
    iterator = iter(iterable)

    for element in iterator:
        yield chain([element], islice(iterator, size - 1))
274898
function () {
            var self = this, o = {}, a, attrs = self.getAttrs();
            for (a in attrs) {
                o[a] = self.get(a);
            }
            return o;
        }
235413
function() {
            	var V = this.dup();
            	switch (V.elements.length) {
            	case 3: break;
            	case 2: V.elements.push(0); break;
            	default: return null;
            	}
            	return V;
                }
1337733
@SuppressWarnings("unchecked")
    @Override
    public E get(int index) {

        _tailLock.lock();
        try {

            _headLock.lock();
            try {
                if (index < 0 || index >= _size.get())
                    throw new IndexOutOfBoundsException("!(" + 0 + "<" + index + "<=" + _size + ")");
                int i = _indexes[HEAD_OFFSET] + index;
                int capacity = _elements.length;
                if (i >= capacity)
                    i -= capacity;
                return (E) _elements[i];
            } finally {
                _headLock.unlock();
            }
        } finally {
            _tailLock.unlock();
        }
    }