Return all values for the given name
489874
public List<String> getAll(String name) {
        if (properties == null) {
            return null;
        }
        final List<String> all = new ArrayList<String>();
        for (Property property : properties) {
            if (property.getName().equals(name)) {
                all.add(property.getValue());
            }
        }
        return all;
    }
1066459
def getAllValuesForFieldsAsJSON( dbid, fieldNames = nil, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )
     ret = getAllValuesForFieldsAsArray(dbid,fieldNames,query,qid,qname,clist,slist,fmt,options)
     ret = JSON.generate(ret) if ret
   end
147135
def get_child_values(parent, names):
        
        vals = []
        for name in names:
            if parent.HasElement(name):
                vals.append(XmlHelper.as_value(parent.GetElement(name)))
            else:
                vals.append(np.nan)
        return vals
443040
def get_values_of_matching_keys(pattern_dict, user_name):
    '''
    
    '''
    ret = []
    for expr in pattern_dict:
        if salt.utils.stringutils.expr_match(user_name, expr):
            ret.extend(pattern_dict[expr])
    return ret
709172
private List<String> getParameterAsList(String name) {
        String[] values = getParameterValues(name);
        if (values == null) {
            return null;
        }

        List<String> valueList = new ArrayList<>(values.length);
        Collections.addAll(valueList, values);
        return valueList;
    }
917380
public List<String> getValuesList(String name) {
        final List<String> list = new ArrayList<>();
        for (HttpField f : this)
            if (f.getName().equalsIgnoreCase(name))
                list.add(f.getValue());
        return list;
    }
839317
def getlist(self, name: str, default: Any = None) -> List[Any]:
        """"""
        return super().get(name, default)
283505
def get_all_for(self, key):
        
        if not isinstance(key, _string_type):
            raise TypeError("Key needs to be a string.")
        return [self[(idx, key)] for idx in _range(self.__kcount[key])]
32514
def keys_values(data, *keys):
    """"""
    values = []
    if is_mapping(data):
        for key in keys:
            if key in data:
                values.extend(ensure_list(data[key]))
    return values
1269318
public function allValues()
    {
        $raw = $this->_parameters['_raw'];
        $values = explode(',', $raw);
        $result = ArrayMethods::trim($values);
        return $result;
    }
995778
def find_all(name, version = nil)
      matched = []
      find(name, version) {|p| matched << p }
      matched
    end
908787
def search(self, name):
        
        pattern = re.compile(name)
        result = {}
        for i in self.__allstockno:
            query = re.search(pattern, self.__allstockno[i])
            if query:
                query.group()
                result[i] = self.__allstockno[i]
        return result
772709
def values(self, name):
        
        return list(self.lookup_variables.get(unnest_path(name), Null))
938876
def fetchAll(self, rawResults = False, **queryArgs) :
        """"""
        return self.simpleQuery('all', rawResults = rawResults, **queryArgs)
1292784
def find_all(self, cls):
        """"""
        final_results = []
        table = self.get_class_table(cls)
        for db_result in table.scan():
            obj = cls.from_data(db_result['value'])
            final_results.append(obj)

        return final_results
600108
def get_all(self, fields=list(), limit=None, order_by=list(), offset=None):
        """"""
        warnings.warn("get_all() is deprecated, please use get_multiple() instead", DeprecationWarning)
        return self.get_multiple(fields, limit, order_by, offset)
80952
function all(h, parent) {
  const nodes = parent.children || []
  const { length } = nodes
  const values = []
  let index = -1

  while (++index < length) {
    const result = one(h, nodes[index], parent)
    values.push(result)
  }

  return values.filter(node => node)
}