Returns a full list of the user's tags along with the number of
 times they were used.

 @return [Array<Tag>] List of all tags
963147
def tags_get(params={})
      options = create_params(params)
      tags = self.class.get('/tags/get', options)['tags']['tag']
      tags = [] if tags.nil?
      tags = [*tags]
      tags.map { |p| Tag.new(Util.symbolize_keys(p)) }
    end
641505
def tags(self):
        
        tag_list = self.spec.get('tag', [])
        if isinstance(tag_list, (list, set, tuple)):
            return list(tag_list)
        return [tag_list]
644581
SeeTag[] seeTags() {
        ListBuffer<SeeTag> found = new ListBuffer<SeeTag>();
        for (Tag next : tagList) {
            if (next instanceof SeeTag) {
                found.append((SeeTag)next);
            }
        }
        return found.toArray(new SeeTag[found.length()]);
    }
1351990
public List<FaceletTaglibTagType<WebFacelettaglibraryDescriptor>> getAllTag()
   {
      List<FaceletTaglibTagType<WebFacelettaglibraryDescriptor>> list = new ArrayList<FaceletTaglibTagType<WebFacelettaglibraryDescriptor>>();
      List<Node> nodeList = model.get("tag");
      for(Node node: nodeList)
      {
         FaceletTaglibTagType<WebFacelettaglibraryDescriptor>  type = new FaceletTaglibTagTypeImpl<WebFacelettaglibraryDescriptor>(this, "tag", model, node);
         list.add(type);
      }
      return list;
   }
691458
public List<Tag> getAllTags()
    {
        List <Tag> ret = new Vector<Tag>(taggers.size());
        for (Tagger tagger : taggers)
            ret.add(tagger.getTag());
        return ret;
    }
537727
def get_tags(self):
        """"""

        # Uncacheable because it can be dynamically changed by the user.
        params = self._get_params()

        doc = self._request(self.ws_prefix + ".getTags", False, params)
        tag_names = _extract_all(doc, "name")
        tags = []
        for tag in tag_names:
            tags.append(Tag(tag, self.network))

        return tags
1083143
def list_tags(userdata):
        
        macros = re.findall('@(.*?)@', userdata)
        logging.info('List of available macros:')
        for macro in macros:
            logging.info('\t%r', macro)
716318
public java.util.List<Tag> getTagsList() {
        if (tagsList == null) {
            tagsList = new com.amazonaws.internal.SdkInternalList<Tag>();
        }
        return tagsList;
    }
451782
def tags(self):
        
        if 'tags' in self._values:
            return self._values['tags']
        self._values['tags'] = copy.deepcopy(self._defaults['tags'])
        return self._values['tags']
1361753
public function tags()
    {
        if ( !is_array( $this->IDArray ) || empty( $this->IDArray ) )
            return array();

        $tags = array();
        foreach ( eZTagsObject::fetchList( array( 'id' => array( $this->IDArray ) ) ) as $item )
        {
            $tags[array_search( $item->attribute( 'id' ), $this->IDArray )] = $item;
        }
        ksort( $tags );

        return $tags;
    }
621865
def tags(self, tags=None):
        
        if tags is None or not tags:
            return self
        nodes = []
        for node in self.nodes:
            if any(tag in node.extra['tags'] for tag in tags):
                nodes.append(node)
        self.nodes = nodes
        return self
518428
def get_top_tags(self, limit=None):
        """"""

        doc = self._request(self.ws_prefix + ".getTopTags", True)

        elements = doc.getElementsByTagName("tag")
        seq = []

        for element in elements:
            tag_name = _extract(element, "name")
            tagcount = _extract(element, "count")

            seq.append(TopItem(Tag(tag_name, self.network), tagcount))

        if limit:
            seq = seq[:limit]

        return seq
848650
public final ImmutableList<TaxonomyTerm> tags() {
      ImmutableList<TaxonomyTerm> tags = taxonomyTerms.get(TAG_TAXONOMY);
      return tags != null ? tags : ImmutableList.of();
   }
202697
def tag_list=(tags)
      case tags
      when String
        self.tag_names = tags.split(/,\s*/)
      when Array
        self.tag_names = tags
      end
    end
245793
def tag(*tags)
      attribute "tags" do |existing_tags|
        existing_tags ||= []
        tags.each do |tag|
          if !existing_tags.include?(tag.to_s)
            existing_tags << tag.to_s
          end
        end
        existing_tags
      end
    end
1037439
def get_tags_users(self, id_):
    
    return _get_request(_TAGS_USERS.format(c_api=_C_API_BEGINNING,
                                                                      api=_API_VERSION,
                                                                      id_=id_,
                                                                      at=self.access_token))
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