Returns a constant pool item.
976890
public ConstantPoolEntry getConstantArg()
  {
    switch (getOpcode()) {
    case LDC:
      return _javaClass.getConstantPool().getEntry(getByteArg());
      
    case LDC_W:
      return _javaClass.getConstantPool().getEntry(getShortArg());

    default:
      throw new UnsupportedOperationException();
    }
  }
1114650
def getitem(self, index, context=None):
        
        return _container_getitem(self, self.elts, index, context=context)
199324
def _make_resource(self):
        
        with self._lock:
            for i in self._unavailable_range():
                if self._reference_queue[i] is None:
                    rtracker = _ResourceTracker(
                        self._factory(**self._factory_arguments))

                    self._reference_queue[i] = rtracker
                    self._size += 1

                    return rtracker

            raise PoolFullError
655830
@Nonnull
    StringBuilder get() {
        if( pool.size() == 0 ) {
            return new StringBuilder();
        } else {
            StringBuilder builder = pool.pollLast();
            builder.setLength( 0 );
            return builder;
        }
    }
1276153
def connection(self):
        """"""
        if self._connections:
            if not self._connections.acquire(self._blocking):
                raise TooManyConnections
        try:
            con = self._cache.get(0)
        except Empty:
            con = self.steady_connection()
        return PooledPgConnection(self, con)
482616
def get():
        """"""
        return {
            attr: getattr(Conf, attr)
            for attr in dir(Conf()) if not callable(getattr(Conf, attr)) and not attr.startswith("__")
        }
1207715
def max_pool(x, dim):
        """"""
        return tf.nn.max_pool(
            x, ksize=[1, dim, dim, 1], strides=[1, dim, dim, 1],
            padding='SAME')
185823
public ObjectPool<MemcachedClientIF> getObjectPool() {
        val pool = new GenericObjectPool<MemcachedClientIF>(this);
        pool.setMaxIdle(memcachedProperties.getMaxIdle());
        pool.setMinIdle(memcachedProperties.getMinIdle());
        pool.setMaxTotal(memcachedProperties.getMaxTotal());
        return pool;
    }
50850
def pool(self, host, port, db, pools={}, **options):
        '''
        
        '''
        key = (host, port, db)
        rval = pools.get(key)
        if not isinstance(rval, ConnectionPool):
            rval = ConnectionPool(host=host, port=port, db=db, **options)
            pools[key] = rval

        return rval
109700
def pick_things(pools, key, n):
    ""
    pool = pools.get(key)
    if not pool:
        return []
    things = pool[:n]
    del pool[:n]
    return things
574632
static DBaseFileAttributePool getPool(URL dbaseFile) {
		DBaseFileAttributePool pool = null;
		if (dbaseFile != null) {
			if (pools == null) {
				pools = new WeakValueTreeMap<>();
			}
			pool = pools.get(dbaseFile.toExternalForm());
			if (pool == null) {
				pool = new DBaseFileAttributePool(dbaseFile);
				pools.put(dbaseFile.toExternalForm(), pool);
			}
		}
		return pool;
	}
403619
def retrieve_pool_stats(self, pool, **_params):
        """"""
        return self.get(self.pool_path_stats % (pool), params=_params)
569458
def pool_exists(service, name):
    """"""
    try:
        out = check_output(['rados', '--id', service, 'lspools'])
        if six.PY3:
            out = out.decode('UTF-8')
    except CalledProcessError:
        return False

    return name in out.split()
502421
def show_lbaas_pool(self, lbaas_pool, **_params):
        """"""
        return self.get(self.lbaas_pool_path % (lbaas_pool),
                        params=_params)
308844
function getRealMonthPool(monthPool) {
  let lastRealMonthIndex = 0;
  let realMonthLen = 0;
  monthPool.forEach((m, idx) => {
    if (Array.isArray(m)) {
      lastRealMonthIndex = idx;
      realMonthLen += 1;
    }
  });
  const firstRealMonthIndex = (lastRealMonthIndex - realMonthLen) + 1;
  return {
    firstRealMonthIndex,
    lastRealMonthIndex,
    realMonthLen,
  };
}
1210979
def mk_pools(things, keyfnc=lambda x: x):
    ""
    pools = {}
    sthings = sorted(things, key=keyfnc)
    for key, thingz in groupby(sthings, key=keyfnc):
        pools.setdefault(key, []).extend(list(thingz))
    return pools
46699
def random_product(*args, repeat=1):
    ""
    pools = [tuple(pool) for pool in args] * repeat
    return tuple(random.choice(pool) for pool in pools)