Builds the list of VersionedValue objects for provided list of values.
496626
private function buildVersionedValues(iterable $values, int $version): Generator
    {
        foreach ($values as $key => $value) {
            yield $key => new VersionedValue($value, $version);
        }
    }
189208
def marshal(self, values):
        
        if values is not None:
            return [super(EntityCollection, self).marshal(v) for v in values]
988946
@Override
    public ImmutableCollection<V> values() {
        Builder<V> builder = ImmutableList.builder();
        for (Cell<V> cell : cells()) {
            builder.add(cell.getValue());
        }
        return builder.build();
    }
360374
protected Versioned<byte[]> toVersioned(MapEntryValue value) {
    return value != null && value.type() != MapEntryValue.Type.TOMBSTONE
        ? new Versioned<>(value.value(), value.version()) : null;
  }
804783
def itervalues(obj):
    ""
    return iter(obj.values()) if sys.version_info.major == 3 else obj.itervalues()
363159
private <T extends Enum<T>> Object[] getValidEnumConstants(Class<T> valueClass) {
        T[] constants = valueClass.getEnumConstants();
        if (!VersionedEnum.class.isAssignableFrom(valueClass)) {
            return constants;
        }

        List<T> valid = new ArrayList<T>(constants.length);
        for (T value : constants) {
            VersionedEnum versionedValue = (VersionedEnum) value;
            if (version >= versionedValue.getMinVersion()) {
                valid.add(value);
            }
        }

        return valid.toArray();
    }
910704
def values_list(self, *fields, **kwargs):
        
        flat = kwargs.pop('flat', False)
        if kwargs:
            raise TypeError('Unexpected keyword arguments to values_list: %s'
                            % (kwargs.keys(),))
        if flat and len(fields) > 1:
            raise TypeError("'flat' is not valid when values_list is called with more than one field.")
        clone = self.only(fields)
        clone._values_list = True
        clone._flat_values_list = flat
        return clone
263573
public String[] buildColumnsAs(List<TColumn> columns, String[] values) {

		String[] columnsArray = buildColumnsArray(columns);

		return buildColumnsAs(columnsArray, values);
	}
538387
private Map<String, Object> ensureValidValueTypes(Map<String, Object> parameterValues) {
    Map<String, Object> transformedParameterValues = new HashMap<>();
    for (Map.Entry<String, Object> entry : parameterValues.entrySet()) {
      if (entry.getKey() == null || entry.getValue() == null) {
        continue;
      }
      else {
        Parameter<?> parameter = allParametersMap.get(entry.getKey());
        if (parameter == null) {
          continue;
        }
        else {
          Object transformedValue = PersistenceTypeConversion.fromPersistenceType(entry.getValue(), parameter.getType());
          if (!parameter.getType().isAssignableFrom(transformedValue.getClass())) {
            continue;
          }
          transformedParameterValues.put(entry.getKey(), transformedValue);
        }
      }
    }
    return transformedParameterValues;
  }
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;
	}
186851
public Attributes<T> version(String ... values)
   {
      if (values != null)
      {
         for(String name: values)
         {
            childNode.createChild("version").text(name);
         }
      }
      return this;
   }
857446
private List<Serializable> getSelectedValues(List<IdName> values, List<Serializable> defaultValues) {
        List<Serializable> selectedValues = new ArrayList<Serializable>();
        if (defaultValues == null) {
            return selectedValues;
        }
        for (Serializable s : defaultValues) {
            for  (IdName in : values) {
                if (s instanceof IdName) {
                    if ((in.getId() != null) && in.getId().equals( ((IdName)s).getId())) {
                        selectedValues.add(in);
                        break;
                    }
                } else if ((in.getId() != null) && in.getId().equals(s)) {
                    selectedValues.add(in);
                    break;
                }
            }
        }
        
        return selectedValues;
    }
17276
public java.util.List<? extends com.google.appengine.v1.VersionOrBuilder> 
      getVersionsOrBuilderList() {
    return versions_;
  }
1170481
function toCassandraValues(metadata, values) {
  if (values === null || values === undefined) {
    return null;
  }
  var specs = metadata.columnSpecs;
  var list = [];
  for (var i = 0; i < specs.length; i++) {
    var value = values[i];
    if (value === null || value === undefined) {
      list.push(null);
    } else {
      var spec = specs[i];
      var type = types.fromType(spec.type);
      list.push(type.serialize(value));
    }
  }
  return list;
}
877473
def map_specifiers_to_versions
      specifiers = {}
      processed = {}

      l = lambda do |t|
        return if processed[t.object_id]
        processed[t.object_id] = true
        t.dependencies.each do |package, spec|
          specifiers[package] ||= {}
          specifiers[package][spec.clause] ||= []
          specifiers[package][spec.clause] << spec
          spec.versions.each_value {|v| l[v]}
        end
      end

      l[@tree]
      specifiers
    end
125526
function buildRefValues (indexes, data) {
  let v
  const ret = {}
  for (v in indexes) {
    if (indexes.hasOwnProperty(v)) {
      const path = indexes[v].path
      const name = indexes[v].name
      const indexType = indexes[v].indexType

      let value = null
      if (indexes[v].compound) {
        value = _.map(path, p => processValue(mpath.get(p, data)))
        value = expandValues(value)
        value = _.compact(value)

        const containsNested = _.some(value, _.isArray)
        if (containsNested) {
          value = _.map(value, v => v.join('_'))
        } else {
          value = value.join('_')
        }
      } else {
        value = processValue(mpath.get(path, data))
      }

      if (indexes[v].refKeyCase === REF_KEY_CASE.UPPER) {
        value = value.toUpperCase()
      } else if (indexes[v].refKeyCase === REF_KEY_CASE.LOWER) {
        value = value.toLowerCase()
      }

      ret[name] = {
        path,
        value,
        name,
        indexType
      }
    }
  }

  return ret
}
325852
function processVersionLists (entity, version, versions) {
  quantum.select(entity)
    .selectAll('versionList', {recursive: true})
    .forEach(versionList => {
      versionList.content(versions.map(v => {
        return { type: 'version', params: [v], content: [] }
      }))
      versionList.add({ type: 'current', params: [version], content: [] })
    })
}