Returned information is a JSON representation of a map with
volume name as the key and value is a map of volume attribute
keys to its values
542909
@Override // DataNodeMXBean
  public String getVolumeInfo() {
    final Map<String, Object> info = new HashMap<String, Object>();
    try {
      FSVolume[] volumes = ((FSDataset)this.data).volumes.getVolumes();
      for (FSVolume v : volumes) {
        final Map<String, Object> innerInfo = new HashMap<String, Object>();
        innerInfo.put("usedSpace", v.getDfsUsed());
        innerInfo.put("freeSpace", v.getAvailable());
        innerInfo.put("reservedSpace", v.getReserved());
        info.put(v.getDir().toString(), innerInfo);
      }
      return JSON.toString(info);
    } catch (IOException e) {
      LOG.info("Cannot get volume info.", e);
      return "ERROR";
    }
  }
988147
function info (cb) {
  var data = {
    name: pjson.name,
    message: 'pong',
    version: pjson.version,
    node_env: process.env.NODE_ENV,
    node_ver: process.versions.node,
    timestamp: Date.now(),
    hostname: os.hostname(),
    uptime: process.uptime(),
    loadavg: os.loadavg()[0]
  };

  cb(null, data);
}
1119611
private static Map<String, Map<String, String>> getStatsMap(String json)
      throws IOException {
    if (json == null || json.isEmpty()) {
      return new HashMap<String, Map<String, String>>();
    }
    TypeReference<Map<String, Map<String, String>>> type = new TypeReference<Map<String, Map<String, String>>>() {
    };
    return mapper.readValue(json, type);
  }
563317
function getData(storage) {
    var core = storage.core;
    var data = core.getItem(storage.id) || '{}';
    return JSON.parse(data);
}
1003787
function (mapping) {
    const result = {};
    for (const [key, value] of _.toPairs(mapping)) {
      result[key] = _.isString(value) ? value : JSON.stringify(value);
    }
    return result;
  }
552144
function mapToObject ( map, opts ) {
	const length = map.getLength();
	const data = {};
	for ( let i = 0; i < length; i++ ) {
		const key = map.getKey(i).getValue();
		const value = getJsonValueFromSassValue(map.getValue(i), opts);
		data[key] = value;
	}
	return data;
}
640888
@NonNull
    @Override
    public Map<String, Object> toMap() {
        final List<Object> values = toList();
        final Map<String, Object> dict = new HashMap<>();
        for (String name : rs.getColumnNames().keySet()) {
            final int index = indexForColumnName(name);
            if (index >= 0) { dict.put(name, values.get(index)); }
        }
        return dict;
    }
861746
static String mapEntryToString(Object key, Object val) {
        final String k, v;
        final int klen, vlen;
        final char[] chars =
            new char[(klen = (k = objectToString(key)).length()) +
                     (vlen = (v = objectToString(val)).length()) + 1];
        k.getChars(0, klen, chars, 0);
        chars[klen] = '=';
        v.getChars(0, vlen, chars, klen + 1);
        return new String(chars);
    }
359951
function dataMap()
    {
        // Retrieve the indexed information collection attributes
        $informationCollectionAttributes = $this->informationCollectionAttributes();

        $retArray = array();

        // Loop through each attribute hashing the array with the
        // class attribute identifier associated with the information
        // collection attribute
        foreach ( $informationCollectionAttributes as $informationAttribute )
        {
            $contentClassAttribute = $informationAttribute->attribute( 'contentclass_attribute' );
            $id = $contentClassAttribute->attribute( 'identifier' );
            $retArray[$id] = $informationAttribute;
        }

        return $retArray;
    }
422808
def get_file_volume_details(self, volume_id, **kwargs):
        

        if 'mask' not in kwargs:
            items = [
                'id',
                'username',
                'password',
                'capacityGb',
                'bytesUsed',
                'snapshotCapacityGb',
                'parentVolume.snapshotSizeBytes',
                'storageType.keyName',
                'serviceResource.datacenter[name]',
                'serviceResourceBackendIpAddress',
                'fileNetworkMountAddress',
                'storageTierLevel',
                'provisionedIops',
                'lunId',
                'originalVolumeName',
                'originalSnapshotName',
                'originalVolumeSize',
                'activeTransactionCount',
                'activeTransactions.transactionStatus[friendlyName]',
                'replicationPartnerCount',
                'replicationStatus',
                'replicationPartners[id,username,'
                'serviceResourceBackendIpAddress,'
                'serviceResource[datacenter[name]],'
                'replicationSchedule[type[keyname]]]',
            ]
            kwargs['mask'] = ','.join(items)
        return self.client.call('Network_Storage', 'getObject',
                                id=volume_id, **kwargs)
1123195
def json_data(self, instance, default=[]):
        
        value = self.get(instance)
        out = map(api.get_url_info, value)
        return out or default
1115988
def get_data_by_key(self, name):
        
        data = graceful_chain_get(self.json, "data")

        if data is None or name not in data:
            return {}

        if self.is_yaml(name):
            return yaml.load(data[name]) or {}
        return json.loads(data[name])
567208
def data(self):
        
        d = {}
        for name in self.key_names:
            d[name] = self.__dict__.get(name, None)
        return d
1286948
function(doc_key, map_field, item_key){

			var retlbl = null;

			var map_str = anchor.get_doc_field(doc_key, map_field);

			if( map_str && bbop.what_is(map_str) === 'string' ){

			    // First, check the cache. If it's not there
			    // add it.
			    if( typeof(anchor._doc_label_maps[doc_key]) ===  'undefined'){
				anchor._doc_label_maps[doc_key] = {};
			    }
			    if( typeof(anchor._doc_label_maps[doc_key][map_field]) === 'undefined'){
				// It looks like a map wasn't defined, so let's
				// convert it into JSON now.
				anchor._doc_label_maps[doc_key][map_field] =
				    JSON.parse(map_str);
			    }

			    // Pull our map out of the cache.
			    var map = anchor._doc_label_maps[doc_key][map_field];

			    // Probe to see if we have anything in the map.
			    if( map && map[item_key] ){
				retlbl = map[item_key];
			    }
			}

			return retlbl;
		    }
161511
function(_data,_key,_map){
            if (_u._$isArray(_data)){
                _map[_key] = JSON.stringify(_data);
            }
        }
1034635
def to_json(self):
    
    mapper_spec = self.mapper.to_json()
    return {
        "name": self.name,
        "mapreduce_id": self.mapreduce_id,
        "mapper_spec": mapper_spec,
        "params": self.params,
        "hooks_class_name": self.hooks_class_name,
    }
879926
function getMapData$1(map, key) {
  var data = map.__data__;
  return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
}