Store a value for the module.
189821
def storage_set(self, key, value):
        
        if not self._module:
            return
        self._storage_init()
        module_name = self._module.module_full_name
        return self._storage.storage_set(module_name, key, value)
392757
def register_id(self, id, module):
        """"""
        assert isinstance(id, basestring)
        assert isinstance(module, basestring)
        self.id2module[id] = module
332204
def store(self, value, context=None):
        
        if isinstance(value, (str, unicode)) and self.testFlag(self.Flags.Encrypted):
            value = orb.system.security().encrypt(value)

        return super(AbstractStringColumn, self).store(value, context=context)
252786
def store(self, value, l, dir_only):
        """"""

        if l and value in (b'', ''):
            return

        globstar = value in (b'**', '**') and self.globstar
        magic = self.is_magic(value)
        if magic:
            value = compile(value, self.flags)
        l.append(WcGlob(value, magic, globstar, dir_only, False))
1237795
def save_module(self, obj):
        
        mod_name = obj.__name__
        # If module is successfully found then it is not a dynamically created module
        if hasattr(obj, '__file__'):
            is_dynamic = False
        else:
            try:
                _find_module(mod_name)
                is_dynamic = False
            except ImportError:
                is_dynamic = True

        self.modules.add(obj)
        if is_dynamic:
            self.save_reduce(dynamic_subimport, (obj.__name__, vars(obj)), obj=obj)
        else:
            self.save_reduce(subimport, (obj.__name__,), obj=obj)
138160
def put(self, key, value):
    ''''''
    for store in self._stores:
      store.put(key, value)
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
1147160
def storeValue(self, xelem, value):
        
        typ = type(value)
        
        if typ == QtGui.QColor:
            xelem.set('type', 'color')
            xelem.text = nativestring(value.name())
        
        elif typ == QtCore.QPoint:
            xelem.set('type', 'point')
            xelem.text = '{0},{1}'.format(value.x(), value.y())
        
        elif typ == QtCore.QPointF:
            xelem.set('type', 'pointf')
            xelem.text = '{0},{1}'.format(value.x(), value.y())
        
        elif typ == QtCore.QRect:
            xelem.set('type', 'rect')
            xelem.text = '{0},{1},{2},{3}'.format(value.x(),
                                                  value.y(),
                                                  value.width(),
                                                  value.height())
        
        elif typ == QtCore.QRectF:
            xelem.set('type', 'rectf')
            xelem.text = '{0},{1},{2},{3}'.format(value.x(),
                                                  value.y(),
                                                  value.width(),
                                                  value.height())
        
        elif typ == QtCore.QByteArray:
            xelem.set('type', 'bytea')
            xelem.text = cPickle.dumps(nativestring(value))
        
        elif typ == ElementTree.Element:
            xelem.set('type', 'xml')
            xelem.append(value)
        
        elif typ in (list, tuple, dict):
            xelem.set('type', 'pickle')
            xelem.text = cPickle.dumps(value)
        
        else:
            if not typ in (str, unicode):
                value_text = nativestring(value)
            else:
                value_text = value
            
            xelem.set('type', typ.__name__)
            xelem.text = value_text
1095931
def set(self, key, value):
        """"""
        self.store[key]=value
        return self.store
964886
def store(self, key, pk, value):
        

        self.connection.zadd(key, value, pk)
568954
def save(self):
        """"""
        if self.path is None:  # Delete requested, so remove the current path from sys.path, if present
            if self.config_manager.userCodeDir is not None:
                sys.path.remove(self.config_manager.userCodeDir)
                self.config_manager.userCodeDir = None
                logger.info("Removed custom module search path from configuration and sys.path.")

        else:
            if self.path != self.config_manager.userCodeDir:
                if self.config_manager.userCodeDir is not None:
                    sys.path.remove(self.config_manager.userCodeDir)
                sys.path.append(self.path)
                self.config_manager.userCodeDir = self.path
                logger.info("Saved custom module search path and added it to sys.path: {}".format(self.path))
109493
def setValue(self, key, value):
        
        curr = self._stack[-1]
        curr[key] = value
206776
def set_value(self, value):
        """"""
        cache, cache_key = self._get_cache_plus_key()
        cache.set(cache_key, value)
1162214
def put(self, key, value):
    '''
    '''

    value = self.serializedValue(value)
    self.child_datastore.put(key, value)
11141
@Bind(optional = true, aggregate = true)
    public synchronized void bindModule(Module module) {
        register(module);
    }
149614
def set_value(self, value):
        
        parsed_value = self._parse_value(value)
        self.value = parsed_value
618425
def save(self, value, redis, *, commit=True):
        '''  '''
        value = self.prepare(value)

        if value is not None:
            redis.hset(self.obj.key(), self.name, value)
        else:
            redis.hdel(self.obj.key(), self.name)

        if self.index:
            key = self.key()

            if self.name in self.obj._old:
                redis.hdel(key, self.obj._old[self.name])

            if value is not None:
                redis.hset(key, value, self.obj.id)