/*
create the storer
773169
public IStorer createStorer(SessionManagerConfig smc, IStore store) {
        IStorer storer = null;
        if (smc.getEnableTimeBasedWrite()) {
            storer = new TBWSessionStorer(store, 10); // 10 seconds is fixed - not configurable
        } else if (smc.getEnableManualWrite()) {
            storer = new ManualSessionStorer();
        } else {
            storer = new EOSSessionStorer();
        }
        return storer;
    }
836293
@Override
    public ObjectStore createObjectStore(ObjectStore objectStore)
            throws NameConflictException {
        try {
            return objectStoreDao.createObjectStore(objectStore);
        } catch (DuplicateKeyException e) {
            throw new NameConflictException("Object store name is already in use", e);
        }
    }
584421
function makeApp(rootContainer, combinedStore) {
    return React.createElement(react_redux_1.Provider, { store: combineStores(combinedStore) }, rootContainer);
}
1317513
function _initStorage(options) {
        var self = this;
        var dbInfo = {
            db: null
        };

        if (options) {
            for (var i in options) {
                dbInfo[i] = options[i];
            }
        }

        return new Promise(function(resolve, reject) {
            var openreq = indexedDB.open(dbInfo.name, dbInfo.version);
            openreq.onerror = function() {
                reject(openreq.error);
            };
            openreq.onupgradeneeded = function() {
                // First time setup: create an empty object store
                openreq.result.createObjectStore(dbInfo.storeName);
            };
            openreq.onsuccess = function() {
                dbInfo.db = openreq.result;
                self._dbInfo = dbInfo;
                resolve();
            };
        });
    }
346557
public static <K,V> Storage<K,V> createHashtableStorage(){
		return new Storage<K,V>(new MapStorageWrapper<K, V>(new HashMap<K, V>()));
	}
1293084
function create(requestObj, callback) {
           
            var storage = this;

            callback = callback || function defaultPostCallback() {
                //setup Error Notification here
            };
            
            if ((typeof requestObj) === 'undefined' || requestObj === null) {
               callback();
               return this;
            }
            
            requestObj.data.id = this._generateUid();

			for (i = 0; i < storage.preprocessors.length; i++) {
                requestObj.data = storage.preprocessors[i](requestObj.data, requestObj);
            }
            this.storage[requestObj.data.id] = requestObj.data;
            
            var data = this.storage[requestObj.data.id];            

            for (i = 0; i < storage.processors.length; i++) {
                data = storage.processors[i](data);
            }
            callback(data);
            
            return this;
        }
797184
@Override
	protected LinkedDataStore createDataStore()
    {
        int maxSize = queueDef.getMaxNonPersistentMessages();
        return new InMemoryLinkedDataStore(queueDef.getName()+" Volatile Store",
                                           Math.min(maxSize, 16),
                                           maxSize);
    }
950866
function createCacheEntry(reactorState, getter) {
  // evaluate dependencies
  const args = getDeps(getter).map(dep => evaluate(reactorState, dep).result)
  const value = getComputeFn(getter).apply(null, args)

  const storeDeps = getStoreDeps(getter)
  const storeStates = toImmutable({}).withMutations(map => {
    storeDeps.forEach(storeId => {
      const stateId = reactorState.getIn(['storeStates', storeId])
      map.set(storeId, stateId)
    })
  })

  return CacheEntry({
    value: value,
    storeStates: storeStates,
    dispatchId: reactorState.get('dispatchId'),
  })
}
150382
function ContextStore() {
    const store = {};

    this.put = function PutContextFn(id, context, callback) {
        callback = callback || function(){};

        if(id === undefined) return callback(new TypeError('Parameter id must be defined'));

        store[id] = {value: context};
        return callback(undefined, {id: id, context: context});
    };

    this.get = function GetContextFn(id, callback) {
        if(id === undefined) return callback(new TypeError('Parameter id must be defined'));
        if(callback === undefined) throw new TypeError('Parameter callback must be defined');

        var retrievedContext = store[id];
        if(retrievedContext === undefined) return callback(undefined, undefined);

        var contextRecord = {id: id, context: retrievedContext.value};
        return callback(undefined, contextRecord);
    };

    this.remove = function RemoveContextFn(id, callback) {
        callback = callback || function() {};
        if(id === undefined) return callback(new TypeError('Parameter id must be defined'));
        delete store[id];
        return callback(undefined, undefined);
    };
}
672021
@Override
    public StaticDataStore create(StoreConfig config) throws IOException {
        try {
            return StoreFactory.createStaticDataStore(config);
        } catch (Exception e) {
            if(e instanceof IOException) {
                throw (IOException)e;
            } else {
                throw new IOException(e);
            }
        }
    }
305479
public void saveStoreFile() {
    JSONArray array = new JSONArray(this.keys.values());

    try {
      if (this.storeFile.exists()) {
        this.storeFile.delete();
        this.storeFile.createNewFile();
      }

      BufferedOutputStream bos = new BufferedOutputStream(
          new FileOutputStream(this.storeFile)
      );
      OutputStreamWriter osw = new OutputStreamWriter(bos);
      osw.write(array.toString());
      osw.close();
    } catch (FileNotFoundException e) {
      log.error("Could not find JSONKeystore file!");
      log.debug(e.toString());
    } catch (IOException e) {
      log.error("Could not create new JSONKeystore file!");
      log.debug(e.toString());
    }
  }
1321921
function store(options) {
  options = options || {};
  var DataStore = lazy.DataStore();
  var opts = extend(options.store || {});
  return new DataStore('snippets', opts);
}
752204
function Reducer () {
  /**
   * Is this reducer enabled?
   *
   * @name _enabled
   * @memberof Reducer
   * @private
   */
  this._enabled = true

  /**
   * Unique ID of this reducer
   *
   * @name _id
   * @memberof Reducer
   * @private
   */
  this._id = null

  /**
   * Array of registered reducers
   *
   * @name _reducers
   * @memberof Reducer
   * @private
   */
  this._reducerRelations = null

  /**
   * Object of registered stores
   *
   * @name _stores
   * @memberof Reducer
   * @private
   */
  this._storeRelations = null

  customizer.constructParent(this)
  storeRelation.constructParent(this)
  reducerRelation.constructParent(this)
  parentReducerRelation.constructParent(this)

  reducer.apply(this, arguments)
}
821397
protected function createStore()
    {
        $this->setCliMessage('Creating store...');

        $default = $this->getStoreModel()->getDefaultData();

        $default['title'] = $this->data['store']['title'];
        $default['email'] = array($this->data['user']['email']);

        $store = array(
            'status' => 0,
            'data' => $default,
            'name' => $this->data['store']['title'],
            'domain' => $this->data['store']['host'],
            'basepath' => $this->data['store']['basepath']
        );

        $store_id = $this->getStoreModel()->add($store);

        $this->config->set('store', $store_id);
        $this->setContext('store_id', $store_id);
    }
1360195
public IStore createStore(SessionManagerConfig smc, String smid, ServletContext sc) {
        return this.createStore(smc, smid, sc, false, false);
    }
770951
function createFakeStorage() {
      const store = {};
      const api = {
         getItem( key ) {
            return store[ key ];
         },
         setItem( key, val ) {
            store[ key ] = `${val}`;
         },
         removeItem( key ) {
            delete store[ key ];
         }
      };
      Object.keys( api ).forEach( method => spyOn( api, method ).and.callThrough() );
      return api;
   }
468178
def create_blobstore(self, **kwargs):
        
        blobstore = predix.admin.blobstore.BlobStore(**kwargs)
        blobstore.create()

        blobstore.add_to_manifest(self)
        return blobstore