Undocumented method.

@param string $Term
@param string $Definition
@todo Method AddDefinition(), $Term and $Definition need descriptions.
508982
public function AddDefinition($Term, $Definition = NULL) {
      if(!is_null($Definition)) {
         // Make sure the term is a valid id.
         if (!preg_match('/[a-z][0-9a-z_\-]*/i', $Term))
            throw new Exception('Definition term must start with a letter or an underscore and consist of alphanumeric characters.');
         $this->_Definitions[$Term] = $Definition;
      }
      return ArrayValue($Term, $this->_Definitions);
   }
1274726
public function splitDefinition(InputDefinition $definition)
    {
        /** @var InputDefinition[] $ret */
        $ret = array(
            new InputDefinition(),
            new InputDefinition()
        );

        foreach ($definition->getArguments() as $arg) {
            $ret[0]->addArgument($arg);
            $ret[1]->addArgument($arg);
        }
        foreach ($definition->getOptions() as $opt) {
            $ret[$this->isHiddenOption($opt) ? 1 : 0]->addOption($opt);
        }
        return $ret;
    }
949429
public function extend($id, $definition)
    {
        if (!isset($this->extensions[$id])) {
            $this->extensions = [];
        }
        $this->extensions[$id][] = $definition;
    }
28266
public function term($field, $term, array $attributes = [])
    {
        $query = new TermQuery($field, $term, $attributes);

        $this->append($query);

        return $this;
    }
41124
private function setDefinitionArguments(Definition $definition, array $array)
    {
        if (true === array_key_exists('arguments', $array)) {
            foreach ($array['arguments'] as $arg) {
                $definition->addArgument($this->convertArgument($arg));
            }
        }
    }
1346081
public void removeTerm(final String term) {
		for (WComponent child : getComponentsForTerm(term)) {
			content.remove(child);
		}
	}
365719
public function setDefinition($definition)
	{
		if ($definition instanceof InputDefinition)
		{
			$this->definition = $definition;
		}
		else
		{
			$this->definition->setDefinition($definition);
		}

		$this->applicationDefinitionMerged = false;
	}
1093803
public function createDictionary(DictionaryDefinition $definition): DictionaryInterface
    {
        $builder = $this->getDictionaryBuilder($definition);

        /** @var DictionaryBuilderInterface $builder */
        return $builder->build($this, $definition);
    }
1199256
private function appendProperData(Collection $data, Definition $definition)
    {
        $identifier = $definition->getIdentifier();
        if ($data->offsetExists($identifier)) {
            return;
        }
        $characteristic = $this->manager->createCharacteristicFromDefinition($definition);
        $data->set($identifier, $characteristic);
    }
268208
public function add($schema, $definition)
    {
        if(is_array($definition)) $definition = (object)$definition;
        $this->__schemas__[$schema] = $definition;
        $this->compile();
        return $this;
    }
1333773
protected function addForeign(String $definition)
	{
		$this->runQueryWithExpression(Expressions::addForeign($this->tableName, $definition));
	}
1003134
public void addTerm(OntologyTerm term) {
        terms.put(term.getId(), term);
        indexTerm(term);
        isTypeOfIsBuilt = false;
    }
288659
private function shouldDefinitionHaveAClass(Definition $definition)
    {
        if ($definition->isSynthetic()) {
            return false;
        }

        if ($definition->isAbstract()) {
            return false;
        }

        return true;
    }
158263
public static function addOptions(InputDefinition $definition, array $fields, $description)
    {
        foreach ($fields as $field => $type) {
            $mode = 'array' === $type
                ? InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY
                : InputOption::VALUE_REQUIRED;

            if (!$definition->hasOption($field) && !$definition->hasArgument($field)) {
                $definition->addOption(new InputOption($field, null, $mode, sprintf($description, $field, $type)));
            }
        }
    }
709654
protected function normalizeDefinition($definition) {
		if ($definition instanceof DefinitionInterface) {
			return $definition;
		}
		
		if ($definition instanceof Closure) {
			return new Definition\CallbackDefinition($definition);
		}
		
		if (is_string($definition)) {
			return new Definition\ClassDefinition($definition);
		}
		
		return new Definition\InstanceDefinition($definition);
	}
721138
public function addDefinitions(array $definitions)
    {
        foreach ($definitions as $name => $definition) {
            if (!($definition instanceof DefinitionInterface)) {
                throw new DcGeneralInvalidArgumentException(
                    'Definition ' . $name . ' does not implement DefinitionInterface.'
                );
            }

            $this->setDefinition($name, $definition);
        }

        return $this;
    }
1089529
public void add(Element term, Element def)
    {
        terms.addElement(term);
        defs.addElement(def);
    }