Read key - value pairs into Map object

@param result
Map to put resulting pair to
325230
protected void readKeyValues(Map<String, Object> result) {
		while (hasMoreProperties()) {
			String name = readPropertyName();
			log.debug("property: {}", name);
			Object property = Deserializer.deserialize(this, Object.class);
			log.debug("val: {}", property);
			result.put(name, property);
			if (hasMoreProperties()) {
				skipPropertySeparator();
			} else {
				break;
			}
		}
	}
903289
@Override
    protected void putDumpInfoTo(Map<String, Object> result) {
        if(StringUtils.isNotBlank(this.statusCodeResult)) {
            result.put(DumpConstants.STATUS_CODE, this.statusCodeResult);
        }
    }
126455
public void map(K key, V val,
                  OutputCollector<Text, Text> output, Reporter reporter) throws IOException {
    String valStr = val.toString();
    String[] inputValFields = valStr.split(this.fieldSeparator);
    String[] inputKeyFields = null;
    String[] fields = null;
    if (this.ignoreInputKey) {
      fields = inputValFields;
    } else {
      inputKeyFields = key.toString().split(this.fieldSeparator);
      fields = new String[inputKeyFields.length + inputValFields.length];
      int i = 0;
      for (i = 0; i < inputKeyFields.length; i++) {
        fields[i] = inputKeyFields[i];
      }
      for (i = 0; i < inputValFields.length; i++) {
        fields[inputKeyFields.length + i] = inputValFields[i];
      }
    }
    String newKey = selectFields(fields, mapOutputKeyFieldList, -1,
        fieldSeparator);
    String newVal = selectFields(fields, mapOutputValueFieldList,
        allMapValueFieldsFrom, fieldSeparator);

    if (newKey == null) {
      newKey = newVal;
      newVal = null;
    }
    Text newTextKey = emptyText;
    if (newKey != null) {
      newTextKey = new Text(newKey);
    }
    Text newTextVal = emptyText;
    if (newTextVal != null) {
      newTextVal = new Text(newVal);
    }
    output.collect(newTextKey, newTextVal);
  }
1152818
public Collection<String> collect(Collection<String> result) throws IOException {
        String line;

        while (true) {
            line = next();
            if (line == null) {
                close();
                return result;
            }
            result.add(line);
        }
    }
575239
public void addTo(@Nonnull Map<String, String> attributeMap, @Nonnull Result result) {
		attributeMap.put(name, get(result));
	}
1329072
private void _processMetadata(HashMap<String, Object> result) {
		// the collections in the result can be either an object[] or a HashSet<object>, depending on the serializer that is used
		Object methods = result.get("methods");
		Object attrs = result.get("attrs");
		Object oneways = result.get("oneways");

		if(methods instanceof Object[]) {
			Object[] methods_array = (Object[]) methods;
			this.pyroMethods = new HashSet<String>();
			for(int i=0; i<methods_array.length; ++i) {
				this.pyroMethods.add((String) methods_array[i]);
			}
		} else if(methods!=null) {
			this.pyroMethods = getSetOfStrings(methods);
		}
		if(attrs instanceof Object[]) {
			Object[] attrs_array = (Object[]) attrs;
			this.pyroAttrs = new HashSet<String>();
			for(int i=0; i<attrs_array.length; ++i) {
				this.pyroAttrs.add((String) attrs_array[i]);
			}
		} else if(attrs!=null) {
			this.pyroAttrs = getSetOfStrings(attrs);
		}
		if(oneways instanceof Object[]) {
			Object[] oneways_array = (Object[]) oneways;
			this.pyroOneway = new HashSet<String>();
			for(int i=0; i<oneways_array.length; ++i) {
				this.pyroOneway.add((String) oneways_array[i]);
			}
		} else if(oneways!=null) {
			this.pyroOneway = getSetOfStrings(oneways);
		}

		if(pyroMethods.isEmpty() && pyroAttrs.isEmpty()) {
			throw new PyroException("remote object doesn't expose any methods or attributes");
		}
	}
420814
@Override
    public void dumpResponse(Map<String, Object> result) {
        byte[] responseBodyAttachment = exchange.getAttachment(StoreResponseStreamSinkConduit.RESPONSE);
        if(responseBodyAttachment != null) {
            this.bodyContent = config.isMaskEnabled() ? Mask.maskJson(new ByteArrayInputStream(responseBodyAttachment), "responseBody") : new String(responseBodyAttachment, UTF_8);
        }
        this.putDumpInfoTo(result);
    }
1248275
private Object decodeResult(IoBuffer data) {
        log.debug("decodeResult - data limit: {}", (data != null ? data.limit() : 0));
        processHeaders(data);
        int count = data.getUnsignedShort();
        if (count != 1) {
            throw new RuntimeException("Expected exactly one result but got " + count);
        }
        Input input = new Input(data);
        String target = input.getString(); // expect "/onResult"
        log.debug("Target: {}", target);
        String nullString = input.getString(); // expect "null"
        log.debug("Null string: {}", nullString);
        // Read return value
        return Deserializer.deserialize(input, Object.class);
    }
1305192
@Override
  public FutureResultImpl<T> setResult(T result) {
    this.result = result;
    succeeded = true;
    checkCallHandler();
    return this;
  }
177736
function(results) {
        var rows = [];
        var cols = results.columns;
        
        var mapFirst = function(col) { return col.shift(); };
        
        while(cols.length > 0 && cols[0].length > 0) {
            rows.push(cols.map(mapFirst));   
        }
        
        results.rows = rows;
        return results;
    }
713063
public void dumpResponse(Map<String, Object> result) {
        if(!dumpConfig.isResponseEnabled()) { return; }

        Map<String, Object> responseResult = new LinkedHashMap<>();
        for(IResponseDumpable dumper: dumperFactory.createResponseDumpers(dumpConfig, exchange)) {
            if (dumper.isApplicableForResponse()) {
                dumper.dumpResponse(responseResult);
            }
        }
        result.put(DumpConstants.RESPONSE, responseResult);
    }
1244573
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException  {
        // Read in any hidden stuff
        s.defaultReadObject();

        // Read in size (number of Mappings)
        int size = s.readInt();
        if (size < 0)
            throw new java.io.StreamCorruptedException
                ("Illegal mappings count: " + size);
        init(capacity(size));

        // Read the keys and values, and put the mappings in the table
        for (int i=0; i<size; i++) {
            @SuppressWarnings("unchecked")
                K key = (K) s.readObject();
            @SuppressWarnings("unchecked")
                V value = (V) s.readObject();
            putForCreate(key, value);
        }
    }
69472
@Override
    protected void putDumpInfoTo(Map<String, Object> result) {
        if(this.queryParametersMap.size() > 0) {
            result.put(DumpConstants.QUERY_PARAMETERS, queryParametersMap);
        }
    }
777886
public void resetResult(Object result)
  {

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
	  SibTr.entry(tc, "resetResult");  	

    if (result != null)
      ((HashSet)result).clear();

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
	  SibTr.exit(tc, "resetResult");

  }
371162
private List<String> formatResult(Result result, Server server) {
		List<String> resultStrings = new LinkedList<>();

		if (result.getValuePath().isEmpty()) {
			processOneMetric(resultStrings, server, result, result.getValue(), null, null);
		} else {
			processOneMetric(resultStrings, server, result, result.getValue(), tagName, StringUtils.join(result.getValuePath(), '.'));
		}
		return resultStrings;
	}
808552
def read_cache_results
      @cache_results ||= begin
        mutable_keys = @cache_key_to_engine.keys.map { |k| k.dup }
        if mutable_keys.empty?
          {}
        else
          Rabl.configuration.cache_engine.read_multi(*mutable_keys)
        end
      end
    end
715546
private Object deserializeOCCColumn(Result result) {
    byte[] versionBytes = result.getValue(Constants.SYS_COL_FAMILY,
        Constants.VERSION_CHECK_COL_QUALIFIER);
    if (versionBytes == null) {
      return null;
    } else {
      return Bytes.toLong(versionBytes);
    }
  }