Store the given value at the specified path.
191331
public void addPath(T value, byte[]... parts)
    {
        int depth = 0;
        ByteTrieNode<T> node = _root;
        for (byte[] part : parts) {
            for (byte b : part) {
                ByteTrieNode<T> child = node._children.get(b);
                if (child == null) {
                    child = new ByteTrieNode<T>();
                    node._children.put(b, child);
                }
                node = child;
                depth++;
            }
        }
        if (depth == 0)
            throw new IllegalArgumentException("Parts must contain at least one byte.");
        node.setValue(value);
        _maxDepth = Math.max(_maxDepth, depth);
    }
152215
public void add(String path, V value) {

        m_tree.setValue(splitPath(path), value);
    }
1281074
def store(self, key, value):
        """"""
        # Prepend tweepy to our key,
        # this makes it easier to identify tweepy keys in our redis server
        key = self.pre_identifier + key
        # Get a pipe (to execute several redis commands in one step)
        pipe = self.client.pipeline()
        # Set our values in a redis hash (similar to python dict)
        pipe.set(key, pickle.dumps((time.time(), value)))
        # Set the expiration
        pipe.expire(key, self.timeout)
        # Add the key to a set containing all the keys
        pipe.sadd(self.keys_container, key)
        # Execute the instructions in the redis server
        pipe.execute()
771579
public void store(Path path, String keyStorePassword) throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException {
		OutputStream os = this.fs.create(path, true);
		this.keystore.store(os,keyStorePassword.toCharArray());
		if (os!=null) {
			os.close();
		}
	}
1089971
def save(self, path: Union[str, bytes, int]) -> None:
        """"""
        with open(path, 'w') as f:
            def write(s: str) -> None:
                f.write(s)
            self._write_qasm(write)
1368099
public function setValueByPath($path, $value)
    {
        if (is_string($path)) {
            $path = $this->parsePath($path);
        }

        $endPart = array_pop($path);
        $child = & $this->data;

        foreach ($path as $part) {
            if (isset($child[$part])) {
                $child = & $child[$part];
            } else {
                $child[$part] = [];
                $child = & $child[$part];
            }
        }

        $child[$endPart] = $value;
    }
998297
public function set($path, $value)
    {
        parent::set($path, $value);

        $this->save();

        return $this;
    }
433134
function put(path, val) {
  var pos = splitPath(path).reduce(function (t, segment) {
    if (!t[segment]) { t[segment] = {} }
    return t[segment]
  }, this)
  pos['@'] = val;
  return this;
}
418626
public static void put(String key, String path, Forest forest) {
        DIC.put(key, KV.with(path, forest));
        MyStaticValue.ENV.put(key, path);
    }
885370
def put(self, path, value):
        
        return lib.zconfig_put(self._as_parameter_, path, value)
406225
def _write_object(self, path, value):
    ''''''
    ensure_directory_exists(os.path.dirname(path))

    with open(path, 'w') as f:
      f.write(value)
1298626
public static void saveTo(String path, InputStream in) {
        if (in == null) {
            throw new IllegalArgumentException("input stream cannot be null");
        }
        if (path == null) {
            throw new IllegalArgumentException("path cannot be null");
        }

        FileOutputStream out = null;
        try {
            out = new FileOutputStream(path);
            byte[] bytes = new byte[1024];
            int len;
            while ((len = in.read(bytes)) != -1) {
                out.write(bytes, 0, len);
            }
            out.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            closeQuietly(out);
        }
    }
571914
def read_value_from_path(value):
    
    if value.startswith('file://'):
        path = value.split('file://', 1)[1]
        config_directory = get_config_directory()
        relative_path = os.path.join(config_directory, path)
        with open(relative_path) as read_file:
            value = read_file.read()
    return value
1226968
def put(self, path, data, **options):
        """"""
        parameter_options = self._parse_parameter_options(options)
        body = {
            # values in the data body takes precendence
            'data': _merge(parameter_options, data),
            'options': self._parse_api_options(options)
        }
        headers = _merge(
            {'content-type': 'application/json'},
            options.pop('headers', {})
        )
        return self.request('put', path, data=body, headers=headers, **options)
474690
@Override public void store(Value v) throws IOException {
    assert !v.isPersisted();
    File dirs = new File(_dir, getIceDirectory(v._key));
    if( !dirs.mkdirs() && !dirs.exists() )
      throw new java.io.IOException("mkdirs failed making "+dirs);
    try(FileOutputStream s = new FileOutputStream(getFile(v))) {
        byte[] m = v.memOrLoad(); // we are not single threaded anymore
        if( m != null && m.length != v._max ) {
          Log.warn("Value size mismatch? " + v._key + " byte[].len=" + m.length+" v._max="+v._max);
          v._max = m.length; // Implies update of underlying POJO, then re-serializing it without K/V storing it
        }
        new AutoBuffer(s.getChannel(), false, Value.ICE).putA1(m, m.length).close();
      } catch( AutoBuffer.AutoBufferException abe ) {
      throw abe._ioe;
    }
  }
388306
def setStoragePath(self, location, path):
        
        if not path:
            self._storagePaths.pop(location, None)
        else:
            self._storagePaths[location] = path
767594
def save(self, path, **extra):
        
        with File(path, 'w') as f:
            for key, val in vars(self).items():
                assert val is not None, key  # sanity check
                try:
                    f[key] = maybe_encode(val)
                except ValueError as err:
                    if 'Object header message is too large' in str(err):
                        logging.error(str(err))
            for k, v in extra.items():
                f.attrs[k] = maybe_encode(v)