Lookup an entry in the SubjectSet based on a given name

 @param [#to_s] name
   the name of the entry

 @return [Object, nil]
   the entry having the given name, or nil if not found

 @api private
175425
def [](name)
      name = name.to_s
      entries.detect { |entry| entry.name.to_s == name }
    end
1038278
def find(name)
      cache(name) { @children.find { |x| safe_find(x, name) } || failure }
    end
490748
def lookup(self, name: str):
        ''''''
        # <module>
        if name in self._moduleMap:
            return self._moduleMap[name]
        # <module>.<Symbol>
        (module_name, type_name, fragment_name) = self.split_typename(name)
        if not module_name and type_name:
            click.secho('not able to lookup symbol: {0}'.format(name), fg='red')
            return None
        module = self._moduleMap[module_name]
        return module.lookup(type_name, fragment_name)
985897
def lookupQueryByName( name, dbid=nil  )
      getSchema(dbid) if dbid
      if @queries
         @queries.each_element_with_attribute( "id" ){|q|
            if q.name == "query" and q.elements["qyname"].text.downcase == name.downcase
               return q
            end
         }
      end
      nil
   end
117240
def has_name?( other, ns=nil )
      if ns
        return (namespace() == ns and name() == other)
      elsif other.include? ":"
        return fully_expanded_name == other
      else
        return name == other
      end
    end
1341543
def provide(name)
      return nil unless name.respond_to?(:to_sym)
      name = name.to_sym
      fields[name] || fields[aliases[name]]
    end
284415
def get(name)
      name = normalize_header name.to_s
      @pile.select { |k, _| k == name }.map { |_, v| v }
    end
851948
def get_by_name(self, name):
        
        scopes = self._client.get_all()
        result = [x for x in scopes if x['name'] == name]
        return result[0] if result else None
237495
def []=(name, value)
      @column_keys << name
      @attrs[to_key(name)] = value
      define_accessor(name) unless respond_to?(name)
    end
1251930
def find_by_name(gemname)
      gem = by_name.select do |name, _collection|
        name == gemname
      end

      gem.first.last if gem.any?
    end
1312475
def find_by_name(name)
      Twinfield::Finder.new(@session).
        search(Twinfield::FinderSearch.new('DIM', name, 0, 1, 0, { office: @company, dimtype: 'DEB'} )).
        body[:search_response][:data]
    end
952996
def find(self, name, required):
        
        if name == None:
            raise Exception("Name cannot be null")
        
        locator = self._locate(name)
        if locator == None:
            if required:
                raise ReferenceException(None, name)
            return None
        
        return self._references.find(locator, required)
138333
def []=(name, entry)
      warn "#{self.class}#[]= is deprecated. Use #{self.class}#<< instead: #{caller.first}"
      raise "#{entry.class} is not added with the correct name" unless name && name.to_s == entry.name.to_s
      self << entry
      entry
    end
386425
def lookup!(nameserver=nil)
      resolver = Resolv.resolver(nameserver)
      hosts = begin
                resolver.getnames(self.address.to_s)
              rescue
                []
              end

      hosts.map! do |name|
        HostName.first_or_create(
          :address => name,
          :ip_addresses => [self]
        )
      end

      return hosts
    end
449979
def findUserByVanityName(name)
      method = 'findUser'
      type = User
      args = {:vanityName=>name}
      return_object type,method,args
    end
15875
def tags(name = nil)
      list = stable_sort_by(@tags + convert_ref_tags, &:tag_name)
      return list unless name
      list.select {|tag| tag.tag_name.to_s == name.to_s }
    end
97639
def find_by_name(self, item_name, items_list, name_list=None):
        
        if not name_list:
            names = [item.name for item in items_list if item]
        else:
            names = name_list
        if item_name in names:
            ind = names.index(item_name)
            return items_list[ind]
        return False