If not already created, a new <code>taglib</code> element will be created and returned.
Otherwise, the first existing <code>taglib</code> element will be returned.
@return the instance defined for the element <code>taglib</code>
769969
public TaglibType<JspConfigType<T>> getOrCreateTaglib()
   {
      List<Node> nodeList = childNode.get("taglib");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new TaglibTypeImpl<JspConfigType<T>>(this, "taglib", childNode, nodeList.get(0));
      }
      return createTaglib();
   }
378738
public Transient<EmbeddableAttributes<T>> getOrCreateTransient()
   {
      List<Node> nodeList = childNode.get("transient");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new TransientImpl<EmbeddableAttributes<T>>(this, "transient", childNode, nodeList.get(0));
      }
      return createTransient();
   }
1296152
public Embeddable<OrmDescriptor> getOrCreateEmbeddable()
   {
      List<Node> nodeList = model.get("embeddable");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new EmbeddableImpl<OrmDescriptor>(this, "embeddable", model, nodeList.get(0));
      }
      return createEmbeddable();
   }
1168023
public static Vertex newE()
    {
        return new Vertex(Predefine.TAG_END, " ", new CoreDictionary.Attribute(Nature.end, Predefine.MAX_FREQUENCY / 10), CoreDictionary.getWordID(Predefine.TAG_END));
    }
151186
public OneToOne<EmbeddableAttributes<T>> getOrCreateOneToOne()
   {
      List<Node> nodeList = childNode.get("one-to-one");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new OneToOneImpl<EmbeddableAttributes<T>>(this, "one-to-one", childNode, nodeList.get(0));
      }
      return createOneToOne();
   }
1084209
public Flow<Flow<T>> getOrCreateFlow()
   {
      List<Node> nodeList = childNode.get("flow");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FlowImpl<Flow<T>>(this, "flow", childNode, nodeList.get(0));
      }
      return createFlow();
   }
163231
public Id<Attributes<T>> getOrCreateId()
   {
      List<Node> nodeList = childNode.get("id");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new IdImpl<Attributes<T>>(this, "id", childNode, nodeList.get(0));
      }
      return createId();
   }
371528
public Next<Flow<T>> getOrCreateNext()
   {
      List<Node> nodeList = childNode.get("next");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new NextImpl<Flow<T>>(this, "next", childNode, nodeList.get(0));
      }
      return createNext();
   }
819013
public TagFileType<TldTaglibType<T>> getOrCreateTagFile()
   {
      List<Node> nodeList = childNode.get("tag-file");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new TagFileTypeImpl<TldTaglibType<T>>(this, "tag-file", childNode, nodeList.get(0));
      }
      return createTagFile();
   }
936394
public Element createDOMNode(Element parent) {
        Element domNode = parent.getOwnerDocument().createElement(tagName);
        LayoutUtil.copyAttributes(attributes, domNode);
        parent.appendChild(domNode);
        return domNode;
    }
536891
public ElementType<AnnotationType<T>> getOrCreateElement()
   {
      List<Node> nodeList = childNode.get("element");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ElementTypeImpl<AnnotationType<T>>(this, "element", childNode, nodeList.get(0));
      }
      return createElement();
   }
144470
public static Builder newParserConfigBuilder() {
        return new Builder() {
            boolean used = false;
            CollectionBuilder.Factory listFactory = DEFAULT_LIST_FACTORY;
            CollectionBuilder.Factory vectorFactory = DEFAULT_VECTOR_FACTORY;
            CollectionBuilder.Factory setFactory = DEFAULT_SET_FACTORY;
            CollectionBuilder.Factory mapFactory = DEFAULT_MAP_FACTORY;
            Map<Tag, TagHandler> tagHandlers = defaultTagHandlers();

            public Builder setListFactory(CollectionBuilder.Factory listFactory) {
                checkState();
                this.listFactory = listFactory;
                return this;
            }

            public Builder setVectorFactory(CollectionBuilder.Factory vectorFactory) {
                checkState();
                this.vectorFactory = vectorFactory;
                return this;
            }

            public Builder setSetFactory(CollectionBuilder.Factory setFactory) {
                checkState();
                this.setFactory = setFactory;
                return this;
            }

            public Builder setMapFactory(CollectionBuilder.Factory mapFactory) {
                checkState();
                this.mapFactory = mapFactory;
                return this;
            }

            public Builder putTagHandler(Tag tag, TagHandler handler) {
                checkState();
                this.tagHandlers.put(tag, handler);
                return this;
            }

            public Config build() {
                checkState();
                used = true;
                return new Config() {
                    public Factory getListFactory() {
                        return listFactory;
                    }

                    public Factory getVectorFactory() {
                        return vectorFactory;
                    }

                    public Factory getSetFactory() {
                        return setFactory;
                    }

                    public Factory getMapFactory() {
                        return mapFactory;
                    }

                    public TagHandler getTagHandler(Tag tag) {
                        return tagHandlers.get(tag);
                    }
                };
            }

            private void checkState() {
                if (used) {
                    throw new IllegalStateException(
                            "Builder is single-use. Not usable after build()");
                }
            }
        };
    }
695395
protected T createInstance() {
        try {
            Constructor<T> ctor = clazz.getDeclaredConstructor();
            ctor.setAccessible(true);
            return ctor.newInstance();
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (SecurityException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (IllegalArgumentException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }
918848
public TagFileType<WebJsptaglibraryDescriptor> getOrCreateTagFile()
   {
      List<Node> nodeList = model.get("tag-file");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new TagFileTypeImpl<WebJsptaglibraryDescriptor>(this, "tag-file", model, nodeList.get(0));
      }
      return createTagFile();
   }
1064755
public ExprTransformer getExprTransfomer() throws TagLibException {
	// Class cls;
	if (exprTransformer != null) return exprTransformer;

	try {
	    exprTransformer = (ExprTransformer) ClassUtil.loadInstance(ELClass.getClazz());
	    // exprTransformer = (ExprTransformer) cls.newInstance();
	}
	catch (Exception e) {
	    throw new TagLibException(e);
	}
	return exprTransformer;
    }
691322
public TagLib duplicate(boolean deepCopy) {
	TagLib tl = new TagLib(isCore);
	tl.appendixTags = duplicate(this.appendixTags, deepCopy);
	tl.displayName = this.displayName;
	tl.ELClass = this.ELClass;
	tl.exprTransformer = this.exprTransformer;
	tl.isCore = this.isCore;
	tl.nameSpace = this.nameSpace;
	tl.nameSpaceAndNameSpaceSeperator = this.nameSpaceAndNameSpaceSeperator;
	tl.nameSpaceSeperator = this.nameSpaceSeperator;
	tl.shortName = this.shortName;
	tl.tags = duplicate(this.tags, deepCopy);
	tl.type = this.type;
	tl.source = this.source;
	tl.ignoreUnknowTags = this.ignoreUnknowTags;

	return tl;
    }
1060676
public WebType<ModuleType<T>> getOrCreateWeb()
   {
      Node node = childNode.getOrCreate("web");
      WebType<ModuleType<T>> web = new WebTypeImpl<ModuleType<T>>(this, "web", childNode, node);
      return web;
   }