Stores hash configuration
197265
def store_hash_configuration(self, lshash):
        
        self.redis_object.set(lshash.hash_name+'_conf', pickle.dumps(lshash.get_config()))
1154219
def options
      map = Config.class_variables.map do |key|
        [key.to_s.tr('@', '').to_sym, class_variable_get(:"#{key}")]
      end
      Hash[map]
    end
451492
def save_hashes(hashes, filename):
    """"""
    with open(filename, 'w') as cython_hash_file:
        for key, value in hashes.items():
            cython_hash_file.write("%s %s %s %s\n"
                                   % (key, value[0], value[1], value[2]))
978241
def store(self, config_file):
        

        selfcopy = copy.deepcopy(self)
        selfcopy.filter_exports()

        with open(config_file, 'w') as outf:
            yaml.dump(
                selfcopy.node,
                outf,
                width=80,
                indent=4,
                default_flow_style=False,
                Dumper=ConfigDumper)
125047
def to_hash
      Hash[options.reject(&:null?).map { |o| [o.key, o.value] }]
    end
221191
def put_hash(name, hash)
      file_name = File.join(@db_dir, name + '.json')
      begin
        RobustFile.write(file_name, hash.to_json)
      rescue IOError => e
        PEROBS.log.fatal "Cannot write hash file '#{file_name}': #{e.message}"
      end
    end
1257072
def ensureHashIndex(self, fields, unique = False, sparse = True, deduplicate = False) :
        """"""
        data = {
            "type" : "hash",
            "fields" : fields,
            "unique" : unique,
            "sparse" : sparse,
            "deduplicate": deduplicate
        }
        ind = Index(self, creationData = data)
        self.indexes["hash"][ind.infos["id"]] = ind
        return ind
3301
def options
      Hash[
        DeskApi::Configuration.keys.map do |key|
          [key, instance_variable_get(:"@#{key}")]
        end
      ]
    end
1338981
protected function store()
	{
		$options = defined('JSON_PRETTY_PRINT') ? JSON_PRETTY_PRINT : 0;
		file_put_contents($this->filename, json_encode($this->settings, $options));
	}
959114
def config_generation(options)
      config_contents = {}

      config_options = options.keys.map(&:to_sym).sort.uniq
      config_options.delete(:password)
      config_options.each do |config_option|
        config_contents.store(config_option.to_sym, options[config_option])
      end

      config_contents.store(:default_organization, options[:username])

      config_contents.to_yaml
    end
674281
def hash(self):
        '''
        
        '''
        if self._hash is None:
            self._initialize()
            self._hash = khash(type(self).__name__, self._default_value, self._fuzzable)
        return self._hash
1166627
def create_hash(response)
      begin
        JSON.parse response
      rescue JSON::ParserError
        response
      rescue StandardError
        response
      end
    end
16153
def []=(key, value)
      @lock.synchronize do
        @indexes = {}
        if value.id_changed?
          hash.delete value.to_id(true)
        end
        saved = hash[key] = value.to_hash.freeze
        adapter.save_database if @options[:sync]
        saved
      end
    end
465179
def __store(key,value=nil)
      pair = (JsonPair === key ? key : JsonPair.new(key, value))
      (@stack[@level] ||= JsonObject.new).add(pair)
    end
648337
def merge_conf(to_hash, other_hash, path=[]):
    ""
    for key in other_hash:
        if (key in to_hash and isinstance(to_hash[key], dict)
                and isinstance(other_hash[key], dict)):
            merge_conf(to_hash[key], other_hash[key], path + [str(key)])
        else:
            to_hash[key] = other_hash[key]
    return to_hash
219914
private void storeFileHashCache(Properties props) {
        File cacheFile = new File(this.targetDirectory, CACHE_PROPERTIES_FILENAME);
        try (OutputStream out = new BufferedOutputStream(new FileOutputStream(cacheFile))) {
            props.store(out, null);
        } catch (IOException e) {
            getLog().warn("Cannot store file hash cache properties file", e);
        }
    }
731484
def store(key, value, mode = nil, &dup_handler)
      if mode == :add and dup_handler.nil?
        super
      elsif dup_handler
        warn "block supersedes mode argument" unless mode.nil?
        k        = cast_key_in(key)
        callback = lambda { |old_value_pointer, old_size, returned_size, _|
          old_value         = cast_from_null_terminated_colums(
                                *old_value_pointer.get_bytes(0, old_size)
                              )
          replacement, size = cast_to_null_terminated_colums( yield( key,
                                                                     old_value,
                                                                     value ) )
          returned_size.put_int(0, size)
          pointer = Utilities.malloc(size)
          pointer.put_bytes(0, replacement) unless pointer.address.zero?
          pointer
        }
        try(:putproc, k, cast_to_null_terminated_colums(value), callback, nil)
        value
      else
        Utilities.temp_map do |map|
          map.update(value) { |string|
            cast_to_bytes_and_length(string)
          }
          result = super(key, map, mode, &dup_handler)
          result == map ? value : result
        end
      end
    end