The types of objects the data store provides.
496712
def provides(self):  # type: Union[Iterable[Type[T]], Type[Any]]
        """"""
        types = set()
        any_dispatch = False
        try:
            types.update(getattr(self.__class__, "get")._provides)
            any_dispatch = True
        except AttributeError:
            pass
        try:
            types.update(getattr(self.__class__, "get_many")._provides)
            any_dispatch = True
        except AttributeError:
            pass
        return types if any_dispatch else TYPE_WILDCARD
563655
function (data) {
    var material = this.material;
    data = getMaterialData(data);
    Object.keys(data).forEach(function (key) {
      material[key] = data[key];
    });
  }
1262506
function combineObjects(types, opts) {
  var allTypes = []; // Field and value types.
  var fieldTypes = {}; // Record field types grouped by field name.
  var fieldDefaults = {};
  var isValidRecord = true;

  // Check whether the final type will be a map or a record.
  var i, l, type, fields;
  for (i = 0, l = types.length; i < l; i++) {
    type = types[i];
    if (type.typeName === 'map') {
      isValidRecord = false;
      allTypes.push(type.valuesType);
    } else {
      fields = type.fields;
      var j, m, field, fieldDefault, fieldName, fieldType;
      for (j = 0, m = fields.length; j < m; j++) {
        field = fields[j];
        fieldName = field.name;
        fieldType = field.type;
        allTypes.push(fieldType);
        if (isValidRecord) {
          if (!fieldTypes[fieldName]) {
            fieldTypes[fieldName] = [];
          }
          fieldTypes[fieldName].push(fieldType);
          fieldDefault = field.defaultValue();
          if (fieldDefault !== undefined) {
            // Later defaults will override any previous ones.
            fieldDefaults[fieldName] = fieldDefault;
          }
        }
      }
    }
  }

  if (isValidRecord) {
    // Check that no fields are missing and that we have the approriate
    // defaults for those which are.
    var fieldNames = Object.keys(fieldTypes);
    for (i = 0, l = fieldNames.length; i < l; i++) {
      fieldName = fieldNames[i];
      if (
        fieldTypes[fieldName].length < types.length &&
        fieldDefaults[fieldName] === undefined
      ) {
        // At least one of the records is missing a field with no default.
        if (opts && opts.strictDefaults) {
          isValidRecord = false;
        } else {
          fieldTypes[fieldName].unshift(Type.forSchema('null', opts));
          fieldDefaults[fieldName] = null;
        }
      }
    }
  }

  var schema;
  if (isValidRecord) {
    schema = {
      type: 'record',
      fields: fieldNames.map(function (s) {
        var fieldType = Type.forTypes(fieldTypes[s], opts);
        var fieldDefault = fieldDefaults[s];
        if (
          fieldDefault !== undefined &&
          ~fieldType.typeName.indexOf('union')
        ) {
          // Ensure that the default's corresponding type is first.
          var unionTypes = fieldType.types.slice();
          var i, l;
          for (i = 0, l = unionTypes.length; i < l; i++) {
            if (unionTypes[i].isValid(fieldDefault)) {
              break;
            }
          }
          if (i > 0) {
            var unionType = unionTypes[0];
            unionTypes[0] = unionTypes[i];
            unionTypes[i] = unionType;
            fieldType = Type.forSchema(unionTypes, opts);
          }
        }
        return {
          name: s,
          type: fieldType,
          'default': fieldDefaults[s]
        };
      })
    };
  } else {
    schema = {
      type: 'map',
      values: Type.forTypes(allTypes, opts)
    };
  }
  return Type.forSchema(schema, opts);
}
1294981
protected function initStorageObjects()
    {
        /**
         * Do not modify this method!
         * It will be rewritten on each save in the extension builder
         * You may modify the constructor of this class instead
         */
        $this->infoWindowImages = new ObjectStorage();
        $this->categories = new ObjectStorage();
        $this->map = new ObjectStorage();
    }
750886
function processData(store, attrs) {
      // List data
      if (attrs && attrs[0]) {
        StoreMemory.listByAttr(store, attrs[0]);
      }
      // Filter data if specified
      if (store.keys) {
        // Check keys format
        // Parse key object string to object
        store.keys =
          typeof store.keys === "string" ? eval("(" + store.keys + ")") : store.keys;
        // Call store filter
        StoreMemory.filter(store, store.keys);
      }
    }
768132
public Collection storeObjects(Collection objects)
    {
        PersistenceBroker broker = null;
        Collection stored;
        try
        {
            broker = getBroker();
            stored = this.storeObjects(broker, objects);
        }
        finally
        {
            if (broker != null) broker.close();
        }
        return stored;
    }
729568
def store_db_obj(cls, in_obj, out_obj):
        
        cls.ip_db_obj['in'] = in_obj
        cls.ip_db_obj['out'] = out_obj
1351195
@Override
	public int store(Object obj, int previousHandle) throws DataStoreException
    {
    	if (data.length == size)
            if (!reallocate())
            	return -1; // Store is full
    	
        int nextHandle;
        if (previousHandle != -1)
        {
            if (SAFE_MODE) checkHandle(previousHandle);
            nextHandle = nextEntry[previousHandle];
        }
        else
            nextHandle = firstEntry;
        
        int newHandle = findEmpty();
        if (newHandle == -1)
        	return -1;
        
        // Store data
        previousEntry[newHandle] = previousHandle;
        nextEntry[newHandle] = nextHandle;
        data[newHandle] = obj;
        
        // Connect to list
        if (previousHandle != -1)
            nextEntry[previousHandle] = newHandle;
        if (nextHandle != -1)
            previousEntry[nextHandle] = newHandle;
        
        // Update first entry if necessary
        if (previousHandle == -1)
            firstEntry = newHandle;
        
        size++;
        
        return newHandle;
    }
953602
public void addDatatypes(ParaObject... objects) {
		// register a new data type
		if (objects != null && objects.length > 0) {
			for (ParaObject obj : objects) {
				if (obj != null && obj.getType() != null) {
					addDatatype(obj.getPlural(), obj.getType());
				}
			}
		}
	}
813221
public static WritableRecordStore makeRecordStorage(DBIDs ids, int hints, Class<?>... dataclasses) {
    return DataStoreFactory.FACTORY.makeRecordStorage(ids, hints, dataclasses);
  }
1362709
def datasetItems(self):
        
        out = {}
        for item in self.items():
            if isinstance(item, XChartDatasetItem):
                out[item.dataset()] = item
        return out
667888
public List<DataStore> getDataStores() {
        return invoke(DATA_STORES,
                new RequestClosure<JsonArray>() {
                    @Override
                    public JsonArray call(Invocation.Builder request) {
                        return request.get(JsonArray.class);
                    }
                },
                new ResponseClosure<JsonArray, List<DataStore>>() {
                    @Override
                    public List<DataStore> call(JsonArray json) {
                        List<DataStore> ds = new ArrayList<DataStore>(json.size());
                        for (int k = 0; k < json.size(); ++k) {
                            ds.add(new DataStore(json.getJsonObject(k)));
                        }
                        return ds;
                    }
                }
        );
    }
400548
protected final List<?> list(Object... datas) {
    List<Object> items = CollectUtils.newArrayList(datas.length);
    for (Object obj : datas) {
      if (obj instanceof Class<?>) {
        items.add(buildInnerReference((Class<?>) obj));
      } else {
        items.add(obj);
      }
    }
    return items;
  }
416143
def children_types( record, index, key='refs', stop_types=STOP_TYPES ):
    """"""
    types = {}
    for child in children( record, index, key, stop_types=stop_types ):
        types.setdefault(child['type'],[]).append( child )
    return types
348380
function WebTreeStore(storageObject, storageId, dataChanged) {
            this.storage = storageObject;
            this.id = storageId;
            this._setItem(this.id + "-tree", true);
            this.dataChanged = dataChanged;
        }
287707
function getSupportedDataTypes () {
  var types = [];

  // NOTE: More frequently-used types come first, to improve lookup speed
  if (typeof Uint8Array === 'function') {
    types.push(Uint8Array);
  }
  if (typeof Uint16Array === 'function') {
    types.push(Uint16Array);
  }
  if (typeof ArrayBuffer === 'function') {
    types.push(ArrayBuffer);
  }
  if (typeof Uint32Array === 'function') {
    types.push(Uint32Array);
  }
  if (typeof Int8Array === 'function') {
    types.push(Int8Array);
  }
  if (typeof Int16Array === 'function') {
    types.push(Int16Array);
  }
  if (typeof Int32Array === 'function') {
    types.push(Int32Array);
  }
  if (typeof Uint8ClampedArray === 'function') {
    types.push(Uint8ClampedArray);
  }
  if (typeof Float32Array === 'function') {
    types.push(Float32Array);
  }
  if (typeof Float64Array === 'function') {
    types.push(Float64Array);
  }
  if (typeof DataView === 'function') {
    types.push(DataView);
  }

  return types;
}
834978
protected void store(Object obj, Identity oid, ClassDescriptor cld,  boolean insert)
    {
        store(obj, oid, cld, insert, false);
    }