Get all terms that exist in a taxonomy type. To determine what taxonomy types are available, call 'getTermTypes' and use
one of the names provided.

@return array
424775
public function getTerms($taxonomy) {
		static $table = 'terms';
		$this->_init();
		$taxonomy = $this->_db->real_escape_string($taxonomy);
		$termIds = $this->_query('SELECT term_taxonomy_id FROM '.$this->getTable('term_taxonomy').' WHERE taxonomy = \''.$taxonomy.'\'', 'term_taxonomy_id', true);
		$result = $this->_query('SELECT * FROM '.$this->getTable($table).' WHERE term_id IN ('.implode(',', $termIds).')', 'term_id');
		foreach ($result as &$item) {
			$item[self::HINT]['table'] = $table;
			unset($item);
		}
		return $result;
	}
1290864
public function getTypes() {
    $typesExport = array();
    foreach ($this->types->toArray() as $key => $type) {
      $typesExport[str_replace(':','.',$key)] = $type;
    }
    return $typesExport;
  }
720874
public function getTermRelationships($terms) {
		static $table = 'term_relationships';
		if (!$terms) {
			return array();
		}
		$termIds = array_keys($terms);
		$termRelationships = $this->_query('SELECT * FROM '.$this->getTable($table).' WHERE term_taxonomy_id IN ('.implode(',', $termIds).')');
		$result = array();
		foreach ($termRelationships as $item) {
			$key = $item['object_id'];
			$value = $item['term_taxonomy_id'];
			if (!isset($result[$key])) {
				$result[$key] = array();
			}
			$result[$key][] = $value;
		}
		return $result;
	}
444704
public function getList()
    {
        if ($this->modelClass === TaxonomyTerm::class) {
            $list = parent::getList();
            return $list->filter('ParentID', '0');
        }
        return parent::getList();
    }
276546
public function getItemTypes()
	{
		$usedTypes = array_reduce( $this->elements, function( $carry, $element ) {
			foreach ( $element as $key => $entry )
			{
				$type = $entry['taxonomy_element']['type'];
				if ( empty( $type ) ) continue;

				if ( ! isset( $carry[ $type ] ) )
				{
					$carry[ $type ] = 1;
				}
			}

			return $carry;
		}, array() );

		return array_keys( $usedTypes );
	}
280325
public function getTaxonomiesInfo()
    {
        $taxonomies = $this->getTaxonomies();
        if (!Arr::iterable($taxonomies)) {
            return array();
        }

        $out = array();
        foreach ($taxonomies as $k => $taxonomy) {
            $taxonomy = $this->getTaxonomy($k);
            $key = $this->getTaxonomyKey($k, $taxonomy);
            $out[] = array(
                'key'       => $key,
                'post_type' => $this->getPostType(),
                'config'    => $taxonomy
            );
        }
        return $out;
    }
1227107
protected function get_taxonomies() {
        $taxonomies = explode(',', $this->raw_get('taxonomies'));

        // Indexing first level at 1.
        array_unshift($taxonomies, null);
        unset($taxonomies[0]);

        // Ensure that we do not return empty levels.
        foreach ($taxonomies as $i => $taxonomy) {
            if (empty($taxonomy)) {
                $taxonomies[$i] = self::TAXONOMY_COMPETENCY;
            }
        }

        return $taxonomies;
    }
290245
public function getTaxonomyValues()
    {
        if (!isset($_POST['tax']) || empty($_POST['tax'])) {
            echo '0';
            die();
        }

        $taxonomy = $_POST['tax'];
        $post = $_POST['post'];

        $result = array(
            'tax' => get_terms($taxonomy, array(
                'hide_empty' => false,
            )),
            'curr' => get_field('posts_taxonomy_value', $post)
        );

        echo json_encode($result);
        die();
    }
1224604
public function getKeywordsAttribute()
    {
        return collect($this->terms)->map(function ($taxonomy) {
            return collect($taxonomy)->values();
        })->collapse()->toArray();
    }
704126
public List<Term> getAllTerms() {
        List<Term> ret = new ArrayList<Term>();

        if (terms != null) {
            ret.addAll(terms);
            for (final Term term : terms) {
                ret.addAll(term.getAllTerms());
            }
        }

        return ret;
    }
879355
public function getReturnTypes() {
    $types = ['void'];
    $doc_comment = $this->getDocComment();
    if (!$doc_comment) {
      return $types;
    }
    $return_tag = $doc_comment->getReturn();
    if (!$return_tag) {
      return $types;
    }
    $types = Types::normalize($return_tag->getTypes());
    if (empty($types)) {
      $types[] = 'void';
    }
    return $types;
  }
937661
public function getTypes()
    {
        if (!array_key_exists('value', $this->types)) {
            return;
        }

        //return an array, no matter one or many types defined
        if (is_array($this->types['value']) && count($this->types['value']) > 1) {
            return $this->types['value'];
        } else {
            return [$this->types['value']];
        }
    }
342055
public function terms()
    {
        $result = array();

        /**
 * Zend_Search_Lucene_Index_TermsPriorityQueue 
*/
        include_once 'Zend/Search/Lucene/Index/TermsPriorityQueue.php';

        $segmentInfoQueue = new Zend_Search_Lucene_Index_TermsPriorityQueue();

        foreach ($this->_segmentInfos as $segmentInfo) {
            $segmentInfo->resetTermsStream();

            // Skip "empty" segments
            if ($segmentInfo->currentTerm() !== null) {
                $segmentInfoQueue->put($segmentInfo);
            }
        }

        while (($segmentInfo = $segmentInfoQueue->pop()) !== null) {
            if ($segmentInfoQueue->top() === null 
                || $segmentInfoQueue->top()->currentTerm()->key() !=                $segmentInfo->currentTerm()->key()
            ) {
                // We got new term
                $result[] = $segmentInfo->currentTerm();
            }

            if ($segmentInfo->nextTerm() !== null) {
                // Put segment back into the priority queue
                $segmentInfoQueue->put($segmentInfo);
            }
        }

        return $result;
    }
358497
public function getTypes()
    {
        $types = array(
            'brand' => $this->translation->text('Brand'),
            'common' => $this->translation->text('Common'),
            'catalog' => $this->translation->text('Catalog')
        );

        $this->hook->attach('category.group.types', $types, $this);
        return $types;
    }
347253
public function getQueryTerms()
    {
        if ($this->_signs === null) {
            return $this->_terms;
        }

        $terms = array();

        foreach ($this->_signs as $id => $sign) {
            if ($sign !== false) {
                $terms[] = $this->_terms[$id];
            }
        }

        return $terms;
    }
322278
protected function getMatchTypes()
    {
        return array(self::EXACT_MATCH_TYPE, self::EXISTS_MATCH_TYPE, self::GREATER_THAN_MATCH_TYPE,
         self::LESS_THAN_MATCH_TYPE, self::SUBSTRING_MATCH_TYPE);
    }
38520
public function getTermsFor($taxonomy)
    {
        if (!($taxonomy instanceof Taxonomy)) {
            $taxonomy = $this->taxonomyFactory->create($taxonomy);
        }

        return $taxonomy->getTermsForPost($this);
    }