read all objects of this iterator. objects will be placed in cache
550058
private Collection getOwnerObjects()
    {
        Collection owners = new Vector();
        while (hasNext())
        {
            owners.add(next());
        }
        return owners;
    }
1252409
def items(self):
        """"""
        if self._result_cache:
            return self._result_cache.items

        return self.all().items
118813
def iterator(self):
        
        for obj in (self.execute().json().get("items") or []):
            yield self.api_obj_class(self.api, obj)
774415
def all(self):
        
        class_list = list(self.get_class_list())
        if not class_list:
            self.cache = []
            return []

        if self.cache is not None:
            return self.cache

        results = []
        for cls_path in class_list:
            module_name, class_name = cls_path.rsplit('.', 1)
            try:
                module = __import__(module_name, {}, {}, class_name)
                cls = getattr(module, class_name)
                if self.instances:
                    results.append(cls())
                else:
                    results.append(cls)
            except Exception:
                logger.exception('Unable to import {cls}'.format(cls=cls_path))
                continue
        self.cache = results

        return results
162106
def values(self):
        ''''''
        if self.cache.cache is None:
            backend = self.read_backend
            return backend.execute(backend.structure(self).values(),
                                   self.load_values)
        else:
            return self.cache.cache.values()
1298060
def get_cached_data(datatable, **kwargs):
    
    cache_key = '%s%s' % (CACHE_PREFIX, datatable.get_cache_key(**kwargs))
    data = cache.get(cache_key)
    log.debug("Reading data from cache at %r: %r", cache_key, data)
    return data
340062
private synchronized void readObject(java.io.ObjectInputStream stream)
			throws java.io.IOException, ClassNotFoundException
	{
		stream.defaultReadObject();
		this.threadState = (ThreadState) serilizationCache.load(this.threadStateSerilizationHashedId);
		this.threadStateSerilizationHashedId = null;
	}
214621
public function readElements()
  {
    $iterator = new ArrayIterator;
    do
    {
      $object = $this->readElement();
      if($object) $iterator->append($object);
    } while((boolean)$object);

    $this->objects = $iterator;
    return $this->objects;
  }
1079494
def all(cls):
        
        if not hasattr(cls, '_cache'):
            cls._cache = cls._all()
        return cls._cache
1098662
def read_cache(self):
        
        if os.path.exists(self._cache_file):
            self._cache = _read_cache_file(self._cache_file)
        else:
            self._cache = {}
822592
public void clear()
    {
        Iterator it = cachesByClass.values().iterator();
        while (it.hasNext())
        {
            ObjectCache cache = (ObjectCache) it.next();
            if (cache != null)
            {
                cache.clear();
            }
        }
    }
331600
def cached_read(self, kind):
        """"""
        if not kind in self.cache:
            self.pull_stats(kind)
        if self.epochnow() - self.cache[kind]['lastcall'] > self.cache_timeout:
            self.pull_stats(kind)
        return self.cache[kind]['lastvalue']
830892
def iterator(self):
        
        # FIXME: There is no dependency tracking; objects are iterated in
        #        random order.
        for ent_cls in list(self.__entity_set_map.keys()):
            for ent in self.__entity_set_map[ent_cls]:
                yield EntityState.get_state(ent)
300575
def get_all(self):
        
        result = cache.lrange(self.key, 0, -1)
        return (json.loads(item.decode('utf-8')) for item in result if
                item) if self.serialize else result
51962
def read(cls, iprot):
        '''
        
        '''

        init_kwds = {}

        iprot.read_struct_begin()
        while True:
            ifield_name, ifield_type, _ifield_id = iprot.read_field_begin()
            if ifield_type == 0:  # STOP
                break
            elif ifield_name == 'images_per_object':
                init_kwds['images_per_object'] = iprot.read_i32()
            elif ifield_name == 'objects':
                init_kwds['objects'] = iprot.read_i32()
            iprot.read_field_end()
        iprot.read_struct_end()

        return cls(**init_kwds)
1142592
def find(self):
        
        content = self._do_request(self.dump())

        objs = []
        for result in content['results']:
            obj = self._new_object()
            obj._update_data(self._process_result(result))
            objs.append(obj)

        return objs
1264479
void readAll() {
        try {
            try {
                int b = input.read();
                while (b >= 0) {
                    readObject(b);
                    b = input.read();
                }
            } finally {
                input.close();
            }
        } catch (IOException ex) {
            throw new IllegalStateException(ex);
        }
    }