For a grouped AVP, returns all AVPs it contains with this name.

 @param [String] name The AVP name
 @return [Array<AVP>]
8914
def inner_avps(name)
      code, _type, _vendor = AVPNames.get(name)

      grouped_value.select { |a| a.code == code }
    end
1042615
def grouped_value=(avps)
      new_content = ''
      avps.each { |a| new_content += a.to_wire }
      @content = new_content
    end
909616
def text(name)
      accum = []
      each do |f|
        if f.name? name
          accum << f.to_text
        end
      end
      accum
    end
76037
def getElementsByName(self, name):
        
        try:
            return filter(lambda x: x.name == name, self._lattice_eleobjlist)
        except:
            return []
1289543
def segments(name)
      result = call("segments", "segments", {:name => name})

      result["segments"].collect {|item| Segment.new(self, item)}
    end
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;
    }
620721
def [](key)
      if @my_vars.include?(key)
        @my_vars[key]
      else
        @coa_vars.each do |coa_vars|
          if coa_vars.include?(key)
            @my_vars[key] = deep_dup(coa_vars[key])
            return @my_vars[key]
          end
        end
        nil
      end
    end
839577
def relative_const_get(name)
      module_names = self.name.split("::")
      if module_names.length > 1
        receiver = Object
        namespaces = module_names[0, module_names.size-1].map do |module_name|
          receiver = receiver.const_get(module_name)
        end
        const_args = RUBY_VERSION < "1.9" ? [name] : [name, false]
        if namespace = namespaces.reverse.detect { |ns| ns.const_defined?(*const_args) }
          return namespace.const_get(*const_args)
        else
          raise NameError, "Couldn't find a class named #{name}"
        end
      else
        const_get(name)
      end
    end
600973
def [](name)
      enum_by_name(name).each { |f| return f.value if f.value != ""}
      enum_by_name(name).each { |f| return f.value }
      nil
    end
664275
function (name) {
        var children = this._children;
        for (var i = 0; i < children.length; i++) {
            if (children[i].name === name) {
                return children[i];
            }
        }
    }
111507
def find_all(name, opts={})
      # opts ||= {}
      all = [@packages.select {|x| x.name.to_s == name.to_s },
      find_all_by_provides(name, opts)].flatten.compact
      filter(all, opts)
    end
150974
public String [] get(final String name) {
		if(has(name)) {
			List<String> values = parameters.get(name).getValues();
			Collections.sort(values);
			return values.toArray(new String [values.size()]);
		}
		else
			return null;
	}
634461
def get_list(self, name: str) -> List[str]:
        """"""
        norm_name = _normalized_headers[name]
        return self._as_list.get(norm_name, [])
1160478
def [](name)
      key = name.to_s
      if attributes.key?(key)
        attributes[key]
      elsif index = underscored_column_names.index(key)
        attributes[@columns[index].name]
      end
    end
1038278
def find(name)
      cache(name) { @children.find { |x| safe_find(x, name) } || failure }
    end
728965
def get_list(self, name):
        ''''''
        normalized_name = normalize_name(name, self._normalize_overrides)
        return self._map[normalized_name]
594963
def by_name(&block)
      @grouped ||= @gems.group_by(&:name).map{|name, collection|
        [name, Geminabox::GemVersionCollection.new(collection)]
      }.sort_by{|name, collection|
        name.downcase
      }

      if block_given?
        @grouped.each(&block)
      else
        @grouped
      end
    end