Returns a list with all the node type categories
@method getNodeTypesCategories
@return {Array} array with all the names of the categories
971923
function() {
            var categories = { "": 1 };
            for (var i in this.registered_node_types) {
                if (
                    this.registered_node_types[i].category &&
                    !this.registered_node_types[i].skip_list
                ) {
                    categories[this.registered_node_types[i].category] = 1;
                }
            }
            var result = [];
            for (var i in categories) {
                result.push(i);
            }
            return result;
        }
33159
public List<String> getAllSelected() {

        List<String> result = new ArrayList<String>();
        for (String cat : m_selectedCategories) {
            result.add(m_categories.get(cat).getId());
        }
        return result;
    }
936235
function createCategories() {
    $cnt = count( $this->categories );
    if( 0 >= $cnt )
      return;
    $output = null;
    foreach( $this->categories as $category ) {
      $attributes = $this->_createParams( $category['params'], array( 'LANGUAGE' ));
      if( is_array( $category['value'] )) {
        foreach( $category['value'] as $cix => $categoryPart )
          $category['value'][$cix] = $this->_strrep( $categoryPart );
        $content  = implode( ',', $category['value'] );
      }
      else
        $content  = $this->_strrep( $category['value'] );
      $output    .= $this->_createElement( 'CATEGORIES', $attributes, $content );
    }
    return $output;
  }
845237
public function getElementTypes()
    {
        $types = array();

        foreach ($this->elements as $key => $element) {
            $types[$key] = get_class($element);
        }

        return $types;
    }
1354904
function mapStructures (structures) {
  var result = [];

  if (structures === undefined) return result;

  _getElementChildNodes(structures).forEach(function (c) {
    _getElementChildNodes(c).forEach(function (s) {
      if ((s.localName === undefined) || (s.localName === null)) return;

      var handler = {
        'Categorisation': mapSimpleMaintainable,
        'CategoryScheme': mapItemScheme,
        'Dataflow': mapSimpleMaintainable,
        'AgencyScheme': mapItemScheme,
        'Codelist': mapItemScheme,
        'ConceptScheme': mapItemScheme,
        'HierarchicalCodelist': mapHierarchicalCodelist,
      }[s.localName];

      if (handler === undefined) {
        console.log('No mapping for ' + s.localName);
      } else {
        result.push(handler(s));
      }
    });
  });

  return result;
}
1198124
public NodeTypes getNodeTypes() {
        String url = jsonRestClient.appendToURL(ITEMS_METHOD, NODE_TYPES_SEGMENT);
        JSONRestClient.Response response = jsonRestClient.doGet(url);
        if (!response.isOK()) {
            throw new RuntimeException(JdbcI18n.invalidServerResponse.text(url, response.asString()));
        }
        return new NodeTypes(response.json());
    }
337328
def categories(self):
    '''
    
    '''

    if not getattr(self, '_categories', False):
      self._categories = [re.sub(r'^Category:', '', x) for x in
        [link['title']
        for link in self.__continued_query({
          'prop': 'categories',
          'cllimit': 'max'
        })
      ]]

    return self._categories
1015113
public function getNodeTypeName()
    {
        return $this->nodeTypeName ?:
            (is_null($this->getNodeType()) ? null : $this->getNodeType()->getName());
    }
450747
public String[] getCategories() {

        List<String> l = m_parameters.getCategories();
        return l.toArray(new String[l.size()]);
    }
1268525
function getNodesByTypeHelper(childArray, type) {
  let nodes = [].concat(childArray.filter(element => element.type === type));
  let otherNodes = [];
  childArray.forEach(node => {
    if (hasChildren(node)) {
      otherNodes = otherNodes.concat(getNodesByTypeHelper(node.children, type));
    }
  });
  return nodes.concat(otherNodes);
}
181704
protected function getCategories()
    {
        return array(
            array(
                'id' => 'environment',
                'label' => __('Environment'),
                'categories' => array(
                    array(
                        'id' => 'comfort',
                        'label' => __('Comfort')
                    ),
                    array(
                        'id' => 'disturbance',
                        'label' => __('Disturbance')
                    ),
                    array(
                        'id' => 'noise',
                        'label' => __('Noise')
                    ),
                    array(
                        'id' => 'powerOutage',
                        'label' => __('Power Outage')
                    ),
                    array(
                        'id' => 'weather',
                        'label' => __('Weather')
                    ),
                )
            ),
            array(
                'id' => 'examinee',
                'label' => __('Examinee'),
                'categories' => array(
                    array(
                        'id' => 'behaviour',
                        'label' => __('Behaviour')
                    ),
                    array(
                        'id' => 'complaint',
                        'label' => __('Complaint')
                    ),
                    array(
                        'id' => 'idAuthorization',
                        'label' => __('ID/Authorization')
                    ),
                    array(
                        'id' => 'illness',
                        'label' => __('Illness')
                    ),
                    array(
                        'id' => 'late',
                        'label' => __('Late')
                    ),
                    array(
                        'id' => 'navigation',
                        'label' => __('Navigation')
                    ),
                    array(
                        'id' => 'noShow',
                        'label' => __('No Show')
                    ),
                )
            ),
            array(
                'id' => 'proctorStaff',
                'label' => __('Proctor/Staff'),
                'categories' => array(
                    array(
                        'id' => 'behaviour',
                        'label' => __('Behaviour')
                    ),
                    array(
                        'id' => 'compliance',
                        'label' => __('Compliance')
                    ),
                    array(
                        'id' => 'error',
                        'label' => __('Error')
                    ),
                    array(
                        'id' => 'late',
                        'label' => __('Late')
                    ),
                    array(
                        'id' => 'noShow',
                        'label' => __('No Show')
                    ),
                )
            ),
            array(
                'id' => 'technical',
                'label' => __('Technical'),
                'categories' => array(
                    array(
                        'id' => 'freezing',
                        'label' => __('Freezing')
                    ),
                    array(
                        'id' => 'launching',
                        'label' => __('Launching')
                    ),
                    array(
                        'id' => 'network',
                        'label' => __('Network')
                    ),
                    array(
                        'id' => 'printing',
                        'label' => __('Printing')
                    ),
                    array(
                        'id' => 'testingWorkstation',
                        'label' => __('Testing Workstation')
                    ),
                )
            ),
            array(
                'id' => 'other',
                'label' => __('Other')
            )
        );
    }
1116102
private function categories()
    {
        $package = Package::where('name', 'Core')->first();
        $core = ConfigCategory::create([
            'key' => 'core',
            'package_id' => $package->id
        ]);
        ConfigCategory::create([
            'key' => 'core_mail',
            'parent_id' => $core->id,
            'package_id' => $core->package_id
        ]);
        ConfigCategory::create([
            'key' => 'core_general',
            'parent_id' => $core->id,
            'package_id' => $core->package_id
        ]);
        $this->general();
        $this->mail();
    }
701386
def get_entry_categories(self, category_nodes):
        
        categories = []
        for category_node in category_nodes:
            domain = category_node.attrib.get('domain')
            if domain == 'category':
                categories.append(self.categories[category_node.text])
        return categories
805889
function getTypeArray (typeString) {
  const letters = typeString.split('')
  const elements = []
  let acc = ''

  while (letters.length) {
    const letter = letters.shift()
    // Ignore spaces
    if (letter !== ' ') {
      switch (letter) {
        case '[':
        case ']':
        case '/':
          if (acc.length) {
            elements.push(acc)
            acc = ''
          }
          elements.push(letter === '/' ? ' / ' : letter)
          break
        default:
          acc += letter
      }
    }
    continue
  }
  if (acc.length) {
    elements.push(acc)
    acc = ''
  }
  return elements
}
1002474
public function get_categories()
	{
		$categories = array();

		$type = 'category';
		foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, $type) as $category)
		{
			$term = null;
			$scheme = null;
			$label = null;
			if (isset($category['attribs']['']['term']))
			{
				$term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_HTML);
			}
			if (isset($category['attribs']['']['scheme']))
			{
				$scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_HTML);
			}
			if (isset($category['attribs']['']['label']))
			{
				$label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_HTML);
			}
			$categories[] = $this->registry->create('Category', array($term, $scheme, $label, $type));
		}
		foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, $type) as $category)
		{
			// This is really the label, but keep this as the term also for BC.
			// Label will also work on retrieving because that falls back to term.
			$term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_HTML);
			if (isset($category['attribs']['']['domain']))
			{
				$scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_HTML);
			}
			else
			{
				$scheme = null;
			}
			$categories[] = $this->registry->create('Category', array($term, $scheme, null, $type));
		}

		$type = 'subject';
		foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, $type) as $category)
		{
			$categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_HTML), null, null, $type));
		}
		foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, $type) as $category)
		{
			$categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_HTML), null, null, $type));
		}

		if (!empty($categories))
		{
			return array_unique($categories);
		}
		else
		{
			return null;
		}
	}
388709
private function getNodes(): array
    {
        return [
            new ConfigurationNode\ViewNode(),
            new ConfigurationNode\DesignNode(),
            new ConfigurationNode\DesignListNode(),
            new ConfigurationNode\DefaultViewTemplatesNode(),
            new ConfigurationNode\HttpCacheNode(),
            new ConfigurationNode\BlockDefinitionNode(),
            new ConfigurationNode\BlockTypeNode(),
            new ConfigurationNode\BlockTypeGroupNode(),
            new ConfigurationNode\LayoutTypeNode(),
            new ConfigurationNode\QueryTypeNode(),
            new ConfigurationNode\PageLayoutNode(),
            new ConfigurationNode\ApiKeysNode(),
            new ConfigurationNode\ValueTypeNode(),
            new ConfigurationNode\DebugNode(),
        ];
    }
676792
function getNodeSlots (element) {
  let nodeSlots = [...element.childNodes]
    .map(node => {
      element.removeChild(node)
      return node
    })

  return nodeSlots
}