Registers macro tags that manipulate templates' structures.

@see #registerTags()
973552
protected void registerMacroTags() {
        addMacroTagProvider(new ActorLmlMacroTagProvider(), "actor");
        addMacroTagProvider(new AnyNotNullLmlMacroTagProvider(), "anyNotNull", "any");
        addMacroTagProvider(new ArgumentLmlMacroTagProvider(), "nls", "argument", "preference");
        addMacroTagProvider(new ArgumentReplacementLmlMacroTagProvider(), "replace", "replaceArguments", "noOp",
                "root");
        addMacroTagProvider(new AssignLmlMacroTagProvider(), "assign", "var", "val");
        addMacroTagProvider(new CalculationLmlMacroTagProvider(), "calculate", "calculation");
        addMacroTagProvider(new ChangeListenerLmlMacroTagProvider(), "onChange", "changeListener");
        addMacroTagProvider(new ClickListenerLmlMacroTagProvider(), "onClick", "clickListener");
        addMacroTagProvider(new CommentLmlMacroTagProvider(), "comment", "FIXME", "TODO");
        addMacroTagProvider(new ConditionalLmlMacroTagProvider(), "if", "test", "check");
        addMacroTagProvider(new EvaluateLmlMacroTagProvider(), "eval", "evaluate", "invoke");
        addMacroTagProvider(new ExceptionLmlMacroTagProvider(), "exception", "throw", "error");
        addMacroTagProvider(new ForEachLmlMacroTagProvider(), "forEach", "for", "each");
        addMacroTagProvider(new ImportAbsoluteLmlMacroTagProvider(), "absoluteImport");
        addMacroTagProvider(new ImportClasspathLmlMacroTagProvider(), "classpathImport");
        addMacroTagProvider(new ImportExternallLmlMacroTagProvider(), "externalImport");
        addMacroTagProvider(new ImportInternalLmlMacroTagProvider(), "import", "internalImport");
        addMacroTagProvider(new ImportLocalLmlMacroTagProvider(), "localImport");
        addMacroTagProvider(new InputListenerLmlMacroTagProvider(), "inputListener", "onInput");
        addMacroTagProvider(new LoggerDebugLmlMacroTagProvider(), "debug", "logDebug", "trace", "logTrace");
        addMacroTagProvider(new LoggerErrorLmlMacroTagProvider(), "logError");
        addMacroTagProvider(new LoggerInfoLmlMacroTagProvider(), "log", "logInfo", "info");
        addMacroTagProvider(new LoopLmlMacroTagProvider(), "loop", "times");
        addMacroTagProvider(new MetaLmlMacroTagProvider(), "macro");
        addMacroTagProvider(new NestedForEachLmlMacroTagProvider(), "forEachNested", "nested", "eachNested");
        addMacroTagProvider(new NewAttributeLmlMacroTagProvider(), "newAttribute", "attribute");
        addMacroTagProvider(new NewTagLmlMacroTagProvider(), "newTag", "tag");
        addMacroTagProvider(new NullCheckLmlMacroTagProvider(), "notNull", "ifNotNull", "exists");
        addMacroTagProvider(new RandomLmlMacroTagProvider(), "random");
        addMacroTagProvider(new StyleLmlMacroTagProvider(), "style");
        addMacroTagProvider(new StyleSheetImportLmlMacroTagProvider(), "importStyleSheet");
        addMacroTagProvider(new TableCellLmlMacroTagProvider(), "cell", "tableCell");
        addMacroTagProvider(new TableColumnLmlMacroTagProvider(), "column", "tableColumn");
        addMacroTagProvider(new TableRowLmlMacroTagProvider(), "row", "tableRow");
        addMacroTagProvider(new WhileLmlMacroTagProvider(), "while", "until");
    }
655303
protected function setTagsContext()
    {
        $objectManager = Bootstrap::$staticObjectManager;
        $environment = $objectManager->get(Environment::class);

        $tags = [
            'php_version' => phpversion(),
            'flow_context' => (string)$environment->getContext(),
            'flow_version' => FLOW_VERSION_BRANCH
        ];

        $this->client->tags_context($tags);
    }
156281
public void registerTag(String namespacePrefix, String tagName, Class<?> clazz) {
        if (!_namespaces.containsKey(namespacePrefix))
            throw new RuntimeException("Namespace prefix '" + namespacePrefix + "' has not been registered yet");
        _xstream.alias(namespacePrefix + ":" + tagName, clazz);
        _xstream.addPermission(new WildcardTypePermission(new String[] {clazz.getName()}));
        _tags.computeIfAbsent(namespacePrefix, k -> new HashSet<>()).add(tagName);
    }
1169837
private void initCustomTaglets() {

        moduleTags = new ArrayList<>();
        packageTags = new ArrayList<>();
        typeTags = new ArrayList<>();
        fieldTags = new ArrayList<>();
        constructorTags = new ArrayList<>();
        methodTags = new ArrayList<>();
        inlineTags = new ArrayList<>();
        overviewTags = new ArrayList<>();

        for (Taglet current : customTags.values()) {
            if (current.inModule() && !current.isInlineTag()) {
                moduleTags.add(current);
            }
            if (current.inPackage() && !current.isInlineTag()) {
                packageTags.add(current);
            }
            if (current.inType() && !current.isInlineTag()) {
                typeTags.add(current);
            }
            if (current.inField() && !current.isInlineTag()) {
                fieldTags.add(current);
            }
            if (current.inConstructor() && !current.isInlineTag()) {
                constructorTags.add(current);
            }
            if (current.inMethod() && !current.isInlineTag()) {
                methodTags.add(current);
            }
            if (current.isInlineTag()) {
                inlineTags.add(current);
            }
            if (current.inOverview() && !current.isInlineTag()) {
                overviewTags.add(current);
            }
        }

        //Init the serialized form tags
        serializedFormTags = new ArrayList<>();
        serializedFormTags.add(customTags.get(SERIAL_DATA.tagName));
        serializedFormTags.add(customTags.get(THROWS.tagName));
        if (!nosince)
            serializedFormTags.add(customTags.get(SINCE.tagName));
        serializedFormTags.add(customTags.get(SEE.tagName));
    }
413718
function registerTaggedDual(numberTag, numericTag, checkFn, toJSONSchema) {
		context.registerTaggedType({
			tag: numberTag,
			jsonType: 'number',
			minArgs: 2,
			maxArgs: 2,
			sparse: true,
			numeric: true
		}, checkFn, returnOriginal, toJSONSchema)

		context.registerTaggedType({
			tag: numericTag,
			jsonType: 'string',
			minArgs: 2,
			maxArgs: 2,
			sparse: true,
			numeric: true
		}, (value, args) => {
			let numberValue = toNumber(value)
			checkFn(numberValue, args)
			return numberValue
		}, returnOriginal, extra => ({
				type: 'string',
				format: extra.original
			}))
	}
762676
function View_setTag(name, parse, compile, ends, blockLevel) {
            this.swig.setTag(name, parse, compile, ends, blockLevel);
        }
1266244
public function tag($tagNames)
    {
        $tagNames = static::$taggingUtility->makeTagArray($tagNames);

        foreach($tagNames as $tagName) {
            $this->addTag($tagName);
        }
    }
471451
protected void registerActorTags() {
        addTagProvider(new ActorLmlTagProvider(), "actor", "group");
        addTagProvider(new ActorStorageLmlTagProvider(), "actorStorage", "isolate");
        addTagProvider(new AnimatedImageLmlTagProvider(), "animatedImage");
        addTagProvider(new ButtonGroupLmlTagProvider(), "buttonGroup", "buttonTable");
        addTagProvider(new ButtonLmlTagProvider(), "button");
        addTagProvider(new CheckBoxLmlTagProvider(), "checkBox");
        addTagProvider(new ContainerLmlTagProvider(), "container");
        addTagProvider(new DialogLmlTagProvider(), "dialog");
        addTagProvider(new HorizontalGroupLmlTagProvider(), "horizontalGroup");
        addTagProvider(new ImageButtonLmlTagProvider(), "imageButton");
        addTagProvider(new ImageLmlTagProvider(), "image");
        addTagProvider(new ImageTextButtonLmlTagProvider(), "imageTextButton");
        addTagProvider(new LabelLmlTagProvider(), "label");
        addTagProvider(new ListLmlTagProvider(), "list");
        addTagProvider(new ProgressBarLmlTagProvider(), "progressBar");
        addTagProvider(new ScrollPaneLmlTagProvider(), "scrollPane");
        addTagProvider(new SelectBoxLmlTagProvider(), "selectBox");
        addTagProvider(new SliderLmlTagProvider(), "slider");
        addTagProvider(new SplitPaneLmlTagProvider(), "splitPane");
        addTagProvider(new StackLmlTagProvider(), "stack");
        addTagProvider(new TableLmlTagProvider(), "table");
        addTagProvider(new TextAreaLmlTagProvider(), "textArea");
        addTagProvider(new TextButtonLmlTagProvider(), "textButton");
        addTagProvider(new TextFieldLmlTagProvider(), "textField");
        addTagProvider(new TooltipLmlTagProvider(), "tooltip");
        addTagProvider(new TouchpadLmlTagProvider(), "touchpad");
        addTagProvider(new TreeLmlTagProvider(), "tree");
        addTagProvider(new VerticalGroupLmlTagProvider(), "verticalGroup");
        addTagProvider(new WindowLmlTagProvider(), "window");
    }
297509
protected function setActionTags()
    {
        $form = $this->xml->getElementsByTagName('form')->item(0);
        $div = $this->xml->createElement('div');

        $input = $this->xml->createElement('input');
        $input->setAttribute('type', 'hidden');
        $input->setAttribute('name', 'ext');
        $input->setAttribute('value', $this->owner->name);
        $div->appendChild($input);

        $input = $this->xml->createElement('input');
        $input->setAttribute('type', 'hidden');
        $input->setAttribute('name', 'form');
        $input->setAttribute('value', $this->name);
        $div->appendChild($input);

        $form->appendChild($div);
    }
502909
public function setTags($tags)
    {
        foreach ($tags as $key => $value) {
            $this->setTag($key, $value);
        }
    }
498400
protected function registerMacro()
    {
        DataTableAbstract::macro(
            'setTransformer', function ($transformer) {
                $this->transformer = [$transformer];

                return $this;
            }
        );

        DataTableAbstract::macro(
            'addTransformer', function ($transformer) {
                $this->transformer[] = $transformer;

                return $this;
            }
        );

        DataTableAbstract::macro(
            'setSerializer', function ($serializer) {
                $this->serializer = $serializer;

                return $this;
            }
        );
    }
1052683
private function registerTwigExtensions()
    {
        foreach ($this->app->getSetting('twig_extensions', []) as $extension) {
            $this->twig->addExtension(new $extension($this));
        }
    }
248985
public static void register(final ProteinModification modification) {
		if (modification==null) throw new IllegalArgumentException("modification == null!");

		lazyInit();

		String id = modification.getId();
		if (byId.containsKey(id)) {
			throw new IllegalArgumentException(id+" has already been registered.");
		}

		registry.add(modification);
		byId.put(id, modification);

		ModificationCategory cat = modification.getCategory();
		byCategory.get(cat).add(modification);

		ModificationOccurrenceType occType = modification.getOccurrenceType();
		byOccurrenceType.get(occType).add(modification);


		ModificationCondition condition = modification.getCondition();
		List<Component> comps = condition.getComponents();
		for (Component comp:comps) {
			Set<ProteinModification> mods = byComponent.get(comp);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byComponent.put(comp, mods);
			}
			mods.add(modification);
		}

		String pdbccId = modification.getPdbccId();
		if (pdbccId!=null) {
			Set<ProteinModification> mods = byPdbccId.get(pdbccId);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byPdbccId.put(pdbccId, mods);
			}
			mods.add(modification);
		}

		String residId = modification.getResidId();
		if (residId!=null) {
			Set<ProteinModification> mods = byResidId.get(residId);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byResidId.put(residId, mods);
			}
			mods.add(modification);
		}

		String psimodId = modification.getPsimodId();
		if (psimodId!=null) {
			Set<ProteinModification> mods = byPsimodId.get(psimodId);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byPsimodId.put(psimodId, mods);
			}
			mods.add(modification);
		}

		for (String keyword : modification.getKeywords()) {
			Set<ProteinModification> mods = byKeyword.get(keyword);
			if (mods==null) {
				mods = new HashSet<ProteinModification>();
				byKeyword.put(keyword, mods);
			}
			mods.add(modification);
		}
	}
17286
public void setTags( Collection<String> tags ) {

		synchronized( this.tags ) {
			this.tags.clear();
			if( tags != null )
				this.tags.addAll( tags );
		}
	}
199234
public static function register_elements() {
		foreach ( self::$_elements as $element => $locations ) {
			$class = self::get_element_class_name( $element );

			if ( method_exists( $class, 'init' ) ) {
				call_user_func( [ $class, 'init' ], $locations );
			}
		}
	}
199453
def register_element_cls(tag, cls):
    
    nspfx, tagroot = tag.split(':')
    namespace = element_class_lookup.get_namespace(nsmap[nspfx])
    namespace[tagroot] = cls
1109544
public function recursivelyDeleteTag()
    {
        foreach ( $this->getChildren( 0, null, true ) as $child )
        {
            $child->recursivelyDeleteTag();
        }

        $relatedObjects = $this->getRelatedObjects();

        foreach ( $this->getSynonyms( true ) as $synonym )
        {
            $synonym->remove();
        }

        $this->remove();

        $this->registerSearchObjects($relatedObjects);
    }