Include properties in the result map.
10999
public ClassSelector add(String... propertyNames) {
    if (ArrayUtils.isNotEmpty(propertyNames)) {
      for (String propertyNameToAdd : propertyNames) {
        addPropertySelector(propertyNameToAdd);
      }
    }
    return this;
  }
232210
private void setSpecificFieldsInResult(List<Map<String, Object>> columnsToOutput, EntityMetadata m, List results,
            JsonArray array)
    {
        Map<String, Class> colNameToJavaType = new HashMap<String, Class>();
        for (Map<String, Object> map : columnsToOutput)
        {
            colNameToJavaType.put((String) map.get(Constants.COL_NAME), (Class) map.get(Constants.FIELD_CLAZZ));
        }
        Map<String, List<Object>> outputResults = new HashMap<String, List<Object>>();
        for (JsonElement element : array)
        {
            String column = element.getAsJsonObject().get("key").getAsString();
            String value = element.getAsJsonObject().get("value").getAsString();
            String id = element.getAsJsonObject().get("id").getAsString();
            Object obj = PropertyAccessorHelper.fromSourceToTargetClass(colNameToJavaType.get(column), String.class,
                    value);
            if (colNameToJavaType.size() > 1)
            {
                if (!outputResults.containsKey(id))
                {
                    outputResults.put(id, new ArrayList<Object>());
                }
                outputResults.get(id).add(obj);
            }
            else
            {
                results.add(obj);
            }
        }
        if (colNameToJavaType.size() > 1)
        {
            results.addAll(outputResults.values());
        }
    }
279142
private Map<String, Object> buildFieldValues(String property, String value) {
		Map<String, Object> fieldValues = new HashMap<String, Object>();
		fieldValues.put(COLUMN_PROPERTY, property);
		fieldValues.put(COLUMN_VALUE, value);
		return fieldValues;
	}
142527
public static List<List<Object>> buildResults(Result result,
			GeoPackageDataType[] dataTypes, Integer limit) {

		List<List<Object>> results = new ArrayList<>();
		try {
			int columns = result.getColumnCount();
			while (result.moveToNext()) {
				List<Object> row = new ArrayList<>();
				for (int i = 0; i < columns; i++) {
					row.add(result.getValue(i, dataTypes != null ? dataTypes[i]
							: null));
				}
				results.add(row);
				if (limit != null && results.size() >= limit) {
					break;
				}
			}
		} finally {
			result.close();
		}

		return results;
	}
1243624
function(result){

      var data = {},
        geometry = result.geometry,
        viewport = geometry.viewport,
        bounds = geometry.bounds;

      // Create a simplified version of the address components.
      $.each(result.address_components, function(index, object){
        var name = object.types[0];

        $.each(object.types, function(index, name){
          data[name] = object.long_name;
          data[name + "_short"] = object.short_name;
        });
      });

      // Add properties of the places details.
      $.each(placesDetails, function(index, key){
        data[key] = result[key];
      });

      // Add infos about the address and geometry.
      $.extend(data, {
        formatted_address: result.formatted_address,
        location_type: geometry.location_type || "PLACES",
        viewport: viewport,
        bounds: bounds,
        location: geometry.location,
        lat: geometry.location.lat(),
        lng: geometry.location.lng()
      });

      // Set the values for all details.
      $.each(this.details, $.proxy(function(key, $detail){
        var value = data[key];
        this.setDetail($detail, value);
      }, this));

      this.data = data;
    }
69472
@Override
    protected void putDumpInfoTo(Map<String, Object> result) {
        if(this.queryParametersMap.size() > 0) {
            result.put(DumpConstants.QUERY_PARAMETERS, queryParametersMap);
        }
    }
649554
function mapSpritesProperties(images, options, sprites) {
	return new Promise(function (resolve) {
		sprites = _.map(sprites, function (sprite) {
			return _.map(sprite.coordinates, function (coordinates, imagePath) {
				return _.merge(_.find(images, {path: imagePath}), {
					coordinates: coordinates,
					spritePath: sprite.path,
					properties: sprite.properties
				});
			});
		});
		resolve([images, options, sprites]);
	});
}
150533
function map( result ) {
  const invalid = !result || result.length < 2;
  return invalid ? null : ( result.slice( 1 ).map( normalizeRegexResult ));
}
426130
private Properties mapToProperties(Map<String, String> map) {
		   Properties p = new Properties();
		   for (Map.Entry<String,String> entry : map.entrySet()) {
		     p.put(entry.getKey(), entry.getValue());
		   }
		   return p;
		 }
1292144
def include(prop):
    ''''''
    if isinstance(prop, QueryableAttribute):
        prop = prop.property
    assert isinstance(prop, (Column, ColumnProperty, RelationshipProperty))
    #assert isinstance(prop, RelationshipProperty)
    _included.add(prop)
1033368
private Map<String, Object> getProperties(GDLParser.PropertiesContext propertiesContext) {
    if (propertiesContext != null) {
      Map<String, Object> properties = new HashMap<>();
      for (GDLParser.PropertyContext property : propertiesContext.property()) {
        properties.put(property.Identifier().getText(), getPropertyValue(property.literal()));
      }
      return properties;
    }
    return Collections.emptyMap();
  }
574949
def addProperty(self, property):
		"""
			'"""
		if self.has_key(property.id):
			raise DuplicatePropertyError
		else:
			self.data[property.id] = property
			self.order.append(property)
436286
function addExtra(properties, extra) {
    for(var key in extra){
      if(extra.hasOwnProperty(key)) {
        properties[key] = extra[key];
      }
    }

    return properties;
  }
955167
def __AddAdditionalProperties(self, message, schema, properties):
        """"""
        additional_properties_info = schema['additionalProperties']
        entries_type_name = self.__AddAdditionalPropertyType(
            message.name, additional_properties_info)
        description = util.CleanDescription(
            additional_properties_info.get('description'))
        if description is None:
            description = 'Additional properties of type %s' % message.name
        attrs = {
            'items': {
                '$ref': entries_type_name,
            },
            'description': description,
            'type': 'array',
        }
        field_name = 'additionalProperties'
        message.fields.append(self.__FieldDescriptorFromProperties(
            field_name, len(properties) + 1, attrs))
        self.__AddImport('from %s import encoding' % self.__base_files_package)
        message.decorators.append(
            'encoding.MapUnrecognizedFields(%r)' % field_name)
152248
def _set_result(self, result):
        
        if self._result_set.isSet():
            return
        self._value = result
        self._result_set.set()
1108773
public Map<String,Object> addPropertiesFile(Map<String,Object> properties)
    {
        String propertiesPath = (String)properties.get("webStartPropertiesFile");
        if (propertiesPath == null)
            return properties;
        if (propertiesPath.startsWith("/"))
            propertiesPath = propertiesPath.substring(1);
        URL url = null;
        try {
            url = ClassServiceUtility.getClassService().getResourceURL(propertiesPath, null, null, this.getClass().getClassLoader());
        } catch (RuntimeException e) {
            e.printStackTrace();    // ???
        }           
        Reader inStream = null;
        if (url != null)
        {
            try {
                inStream = new InputStreamReader(url.openStream());
            } catch (Exception e) {
                // Not found
            }
        }
        if (inStream != null)
        {
            try {
                // Todo may want to add cache info (using bundle lastModified).
                Properties cachedProperties = new Properties();
                cachedProperties.load(inStream);
                inStream.close();
                for (Object key : cachedProperties.keySet())
                {
                    properties.put(key.toString(), cachedProperties.get(key));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return properties;
    }
277837
def build_results(self, results):
        """"""
        self.add_result_subsection(
            'Exploit mitigation techniques',
            {
                'level': results.get('Plugins', {}).get('mitigation', {}).get('level', None),
                'summary': results.get('Plugins', {}).get('mitigation', {}).get('summary', None),
                'content': results.get('Plugins', {}).get('mitigation', {}).get('plugin_output', None)
            }
        )
        self.add_result_subsection(
            'Suspicious strings',
            {
                'level': results.get('Plugins', {}).get('strings', {}).get('level', None),
                'summary': results.get('Plugins', {}).get('strings', {}).get('summary', None),
                'content': results.get('Plugins', {}).get('strings', {}).get('plugin_output', None)
            }
        )
        self.add_result_subsection(
            'Suspicious imports',
            {
                'level': results.get('Plugins', {}).get('imports', {}).get('level', None),
                'summary': results.get('Plugins', {}).get('imports', {}).get('summary', None),
                'content': results.get('Plugins', {}).get('imports', {}).get('plugin_output', None)
            }
        )
        self.add_result_subsection(
            'Packer',
            {
                'level': results.get('Plugins', {}).get('packer', {}).get('level', None),
                'summary': results.get('Plugins', {}).get('packer', {}).get('summary', None),
                'content': results.get('Plugins', {}).get('packer', {}).get('plugin_output', None)
            }
        )
        self.add_result_subsection(
            'Clamav',
            {
                'level': results.get('Plugins', {}).get('clamav', {}).get('level', None),
                'summary': results.get('Plugins', {}).get('clamav', {}).get('summary', None),
                'content': results.get('Plugins', {}).get('clamav', {}).get('plugin_output', None)
            }
        )
        self.add_result_subsection('Manalyze raw output', json.dumps(results, indent=4))