might as well add more keys for paging.
180125
def configure(*val , &block)
      case val.size
      when 1
        return @config[val[0]]
      when 2
        @config[val[0]] = val[1]
        instance_variable_set("@#{val[0]}", val[1]) 
      end
      instance_eval &block if block_given?
    end
590289
def add_child key, page = nil
      if key.is_a? Page
        page, key = key, (self.keys.length + 1).to_sym
      end
      page.parent = self
      page.url = key
      self[key] = page
    end
173179
def cache_page(page_cache, page_hash, cache_size):
    """"""
    page_cache.append(page_hash)
    if len(page_cache) > cache_size:
        page_cache.pop(0)
1122246
def add_subkey(self, subkey):
        
        if self.key.lower() == 'atoms' or not self.has_subkey(subkey):
            self.subkeys.append(subkey)
1237291
def extend(self, items):
        
        if items:
            if self.serialized:
                items = list(map(self._dumps, items))
            self._client.rpush(self.key_prefix, *items)
641356
def more
      if more?
        url = Addressable::URI.parse(http_response.links[:next])
        self.class.new(
          @connection,
          url.path,
          @klass,
          @parent
        ).tap do |collection|
          collection.parameters = url.query_values
        end
      else
        raise PaginationError, %{Collection has no 'Link: <url>; rel="next"' header}
      end
    end
1325282
private void enlargeCapacity(int key) {
	int diff = offCount - offset;

	int newSize = arr.length;
	if (newSize < 1) newSize = 1;
	while (newSize < key + offset + diff) {
	    newSize *= 2;
	}
	if (newSize > arr.length) {
	    Object[] na = new Object[newSize];
	    for (int i = offset; i < offset + size; i++) {
		na[i + diff] = arr[i];
	    }
	    arr = na;
	    offset += diff;
	}
    }
1328439
private Queue<List<Data>> createBatchChunks(List<Data> keys) {
        Queue<List<Data>> chunks = new LinkedList<>();
        int loadBatchSize = getLoadBatchSize();
        int page = 0;
        List<Data> tmpKeys;
        while ((tmpKeys = getBatchChunk(keys, loadBatchSize, page++)) != null) {
            chunks.add(tmpKeys);
        }
        return chunks;
    }
688240
def add(self, key, value,
            description='',
            history_max_size=None):
        """"""
        if key not in self.stats_history:
            self.stats_history[key] = GlancesAttribute(key,
                                                       description=description,
                                                       history_max_size=history_max_size)
        self.stats_history[key].value = value
583245
def extend(self, *args, **kwargs):
        """"""
        if len(args) > 1:
            raise TypeError('expected at most 1 arguments, got %d' % len(args))

        iterable = args[0] if args else None
        if iterable:
            if isinstance(iterable, Mapping) or hasattr(iterable, 'items'):
                for key, value in iterable.items():
                    self.append(key, value)
            elif hasattr(iterable, 'keys'):
                for key in iterable.keys():
                    self.append(key, iterable[key])
            else:
                for key, value in iterable:
                    self.append(key, value)

        for key, value in kwargs.items():
            self.append(key, value)
1357528
def _expand_one_key_dictionary(_dict):
    '''
    
    '''
    key = next(six.iterkeys(_dict))
    value = _dict[key]
    return key, value
888243
public function addKeys($keys) {
		foreach ((array)$keys as $position => $key) {
			$this->keys[$position] = $key;
		}
		return $this;
	}
815462
def add_to_query(self, query):
        '''
        
        '''
        self.handle = win32pdh.AddCounter(query, self.path)
247504
def add2set(self, pid, key, value):
    """"""
    prop = self.property_entries[pid]

    current = prop.objects.get(key, None)
    current_local_key = prop.references.get(key, None)

    if current and current is not value:
        current.detach()

    if current_local_key is None:
        prop.references[key] = prop.next_free_key
        prop.next_free_key += 1

    prop.objects[key] = value

    if prop.parent.dir:
        ref = prop.index_ref_name(key)
        dir_entry = prop.parent.dir.get(ref)
        if dir_entry is None:
            dir_entry = prop.parent.dir.makedir(ref)
        if value.dir != dir_entry:
            value.attach(dir_entry)
        prop.mark_modified()
784039
def consume_keys(self):
        
        print("\nLooking up " + self.input_queue.qsize().__str__() + " keys from " + self.source_name + "\n")
        self.data_worker(**self.worker_args)
287476
private void grow() {
        char[][] newPages;

        if (lastFilled != pageSize) {
            throw new IllegalStateException();
        }
        lastNo++;
        if (lastNo >= pages.length) {
            newPages = new char[lastNo * 5 / 2][];
            System.arraycopy(pages, 0, newPages, 0, lastNo);
            pages = newPages;
        }
        if (pages[lastNo] == null) {
            pages[lastNo] = new char[pageSize];
        }
        lastFilled = 0;
    }
371208
function(fnName, fn) {
        var pageCount = this.cfg.getProperty(DEF_CFG.PAGES.key);
    
        for (var p=0;p<pageCount;++p) {
            this.pages[p][fnName] = fn;
        }
    }