(see Proxy#store)
483009
def store(key, value, options = {})
      @stack.each {|s| s.store(key, value, options) }
      value
    end
1162598
def get(key, default=None):
    '''
    
    '''
    store = load()

    if isinstance(key, six.string_types):
        return store.get(key, default)
    elif default is None:
        return [store[k] for k in key if k in store]
    else:
        return [store.get(k, default) for k in key]
698183
async def start_store(app, url, workers=0, **kw):
    '''
    '''
    store = create_store(url, **kw)
    if store.name == 'pulsar':
        client = store.client()
        try:
            await client.ping()
        except ConnectionRefusedError:
            host = localhost(store._host)
            if not host:
                raise
            cfg = await send('arbiter', 'run', start_pulsar_ds,
                             host, workers)
            store._host = cfg.addresses[0]
            dsn = store.buildurl()
            store = create_store(dsn, **kw)
    app.cfg.set('data_store', store.dsn)
1248966
def raw
      @raw_store ||=
        begin
          store = with(raw: true, only: [:load, :store, :create, :delete])
          store.instance_variable_set(:@raw_store, store)
          store
        end
    end
291284
def fetch(key, parameters = {}, conditions = {}, &blk)
      read(key, parameters) ||
        @stores.capture_first {|s| s.fetch(key, parameters, conditions, &blk)} ||
        blk.call
    end
580730
function get(key){
      if(isObject(key)){
        if(!isExtensible(key))return frozenStore(this).get(key);
        if(has(key, WEAK))return key[WEAK][this._i];
      }
    }
340216
def get(*args)
      if args.size == 1
        @server.data_store.list(args)
      else
        @server.data_store.get(args)
      end
    end
563124
def get_data_store(args):
    """"""
    return tacl.DataStore(args.db, args.memory, args.ram)
711884
function hyperRepeat(store) {
  this.compile = compile;

  this.state = function(config, state) {
    var res = store.get(config.path, state);
    if (!res.completed) return false;
    return state.set(config.source, res.value);
  };

  this.children = function(config, state, children) {
    var items = state.get(config.source);
    var arr = [];
    if (!items) return arr;

    var target = config.target;
    var i, c, child;

    var path = ['state', target];

    for (i = 0; i < items.length; i++) {
      function update() {return items[i]};

      for (c = 0; c < children.length; c++) {
        child = children[c];
        if (!child) continue;
        // TODO set the key prop
        child = child.updateIn(path, update);
        arr.push(child);
      }
    }
    return arr;
  };
}
993425
function QuestionsStore(options) {
  debug('initializing from <%s>', __filename);
  Cache.call(this, options);
  this.createStores(this, this.options);
  this.listen(this);
}
638838
function getStoreData(storeId, field) {
      var arr = Ext.StoreManager.get(storeId).getRange();
      var res = arr.map(function (elem) {
        return elem[field];
      });
      return res;
    }
503203
private void storeBundle(String bundleId, JoinableResourceBundleContent store) {

		stopProcessIfNeeded();

		if (bundleMustBeProcessedInLive(store.getContent().toString())) {
			liveProcessBundles.add(bundleId);
		}
		resourceBundleHandler.storeBundle(bundleId, store);
	}
534848
def make_store(name, min_length=4, **kwargs):
   
  
   if name not in stores:
      raise ValueError('valid stores are {0}'.format(', '.join(stores)))

   if name == 'memcache':
      store = MemcacheStore
   elif name == 'memory':
      store = MemoryStore
   elif name == 'redis':
      store = RedisStore

   return store(min_length=min_length, **kwargs)
1193766
function dispatchToStores(ids = new Set()) {
	ids.forEach((storeID) => {
		if (this[IS_PENDING][storeID]) {
			return true;
		}

		invokeCallback.call(this, storeID);
	});
}
722915
function getResource(storeName, item) {
		var res,
			view = this,
			store = $views[storeName];

		res = store && store[item];
		while ((res === undefined) && view) {
			store = view.tmpl[storeName];
			res = store && store[item];
			view = view.parent;
		}
		return res;
	}
558470
def store(graph)
      begin
        statements = graph.each_statement.to_a
        @client.insert(statements)
        graph
      rescue => e
        raise TriplestoreAdapter::TriplestoreException, "store graph in triplestore cache failed with exception: #{e.message}"
      end
    end
765669
function( callback ) {
            var me = this;
            root( this, function( store ) {
                ls( store.createReader(), function( entries ) {
                    if ( callback ) me.fn( 'keys', callback ).call( me, entries );
                });
            });
            return this;
        }