Store an object.
339743
public Object storeObject(Object object)
    {
        PersistenceBroker broker = getBroker();
        try
        {
            broker.store(object);
        }
        finally
        {
            if (broker != null) broker.close();
        }
        return object;
    }
598381
async def put(self, key, value, *args):
        """"""
        self._db[key] = value
        await self.save()
873061
def add_object(self, object):
        """"""
        if object.id is None:
            object.get_id()
        self.db.engine.save(object)
236213
def save_json(object, handle, indent=2):
    """"""
    obj_json = json.dumps(object, indent=indent, cls=NumpyJSONEncoder)
    handle.write(obj_json)
1282506
def save_object(self, obj, expected_value=None):
        
        doc = self.marshal_object(obj)
        if obj.id:
            url = "/%s/%s" % (self.db_name, obj.id)
        else:
            url = "/%s" % (self.db_name)
        resp = self._make_request("PUT", url, body=doc.toxml())
        new_obj = self.get_object_from_doc(obj.__class__, None, parse(resp))
        obj.id = new_obj.id
        for prop in obj.properties():
            try:
                propname = prop.name
            except AttributeError:
                propname = None
            if propname:
                value = getattr(new_obj, prop.name)
                if value:
                    setattr(obj, prop.name, value)
        return obj
695430
public String save(Object obj) {
    if (((IdEntity) obj).isNew())
      return insert(obj);
    else
      return update(obj);
  }
308922
def put(self, key, value):
    '''
    '''
    path = self.object_path(key)
    self._write_object(path, value)
330114
def _store_variable(self, j, key, m, value):
        
        if hasattr(value, 'copy'):
            v = value.copy()
        else:
            v = value

        self.history[j][key][m].append(v)
478947
def store(self, thing):
        
        to_store = {'field1': thing.field1,
                    'date_field': thing.date_field,
                    }
        to_store['stuff'] = Binary(cPickle.dumps(thing.stuff))
        # Respect any soft-quota on write - raises if stats().totals.size > quota 
        self._arctic_lib.check_quota()
        self._collection.insert_one(to_store)
927380
def store(key, value, mode = nil)
      if mode == :dup
        if value.is_a? Array
          Utilities.temp_list(value.size) do |list|
            list.push(*value) { |string| cast_value_in(string) }
            try(:putdup3, cast_key_in(key), list.pointer)
          end
        else
          try(:putdup, cast_key_in(key), cast_value_in(value))
        end
        value
      else
        super
      end
    end
1125949
def put_object(obj, id)
      find_blob(id, true).write_object(id, serialize(obj))
    end
277248
def store_json(self, filename, dict_to_store):
        """"""
        filename = os.path.join(
            self.data_dir,
            filename + '.data'
        )
        fileops.dump_dict_to_file(
            dict_to_store,
            filename
        )
187938
def persist(self):
        """"""
        if self.object_hash:
            data = dill.dumps(self.object_property)
            f = ContentFile(data)
            self.object_file.save(self.object_hash, f, save=False)
            f.close()
            self._persisted = True
        return self._persisted
469904
def _store(self, con):
        """"""
        self._con = con
        self._transaction = False
        self._closed = False
        self._usage = 0
288814
def set_object(self, start, obj, object_size):
        

        self._store(start, obj, object_size, overwrite=True)
206895
function store(err, resp, data) {
  if (err && (err.code == 'EADDRINFO' || err.code == 'ENOTFOUND'))
    failed.push(data);
}
1047189
function storeModel(model, permissionSchemaKey) {
    if (model && model.rolePermissions) {
        var obj = {
            permissionSchemaKey: permissionSchemaKey,
            rolePermissions: model.rolePermissions
        };
        exports.store(obj);
    }
}