If not already created, a new <code>converter</code> element will be created and returned.
Otherwise, the first existing <code>converter</code> element will be returned.
@return the instance defined for the element <code>converter</code>
495761
public FacesConfigConverterType<WebFacesConfigDescriptor> getOrCreateConverter()
   {
      List<Node> nodeList = model.get("converter");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigConverterTypeImpl<WebFacesConfigDescriptor>(this, "converter", model, nodeList.get(0));
      }
      return createConverter();
   }
59050
public TableGenerator<EntityMappings<T>> getOrCreateTableGenerator()
   {
      List<Node> nodeList = childNode.get("table-generator");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new TableGeneratorImpl<EntityMappings<T>>(this, "table-generator", childNode, nodeList.get(0));
      }
      return createTableGenerator();
   }
67951
public TableGenerator<OrmDescriptor> getOrCreateTableGenerator()
   {
      List<Node> nodeList = model.get("table-generator");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new TableGeneratorImpl<OrmDescriptor>(this, "table-generator", model, nodeList.get(0));
      }
      return createTableGenerator();
   }
675553
public static final DeclarationTransformer getDeclarationTransformer() {
        if (dt == null) {
            try {
                @SuppressWarnings("unchecked")
                Class<? extends DeclarationTransformerImpl> clazz = (Class<? extends DeclarationTransformerImpl>) Class
                        .forName(DEFAULT_DECLARATION_TRANSFORMER);
                Method m = clazz.getMethod("getInstance");
                registerDeclarationTransformer((DeclarationTransformerImpl) m.invoke(null));
                log.debug("Retrived {} as default DeclarationTransformer implementation.",
                        DEFAULT_DECLARATION_TRANSFORMER);
            } catch (Exception e) {
                log.error("Unable to get DeclarationTransformer from default", e);
                throw new RuntimeException(
                        "No DeclarationTransformer implementation registered!");
            }
        }

        return dt;
    }
278137
public FacesConfigAttributeType<FacesConfigConverterType<T>> getOrCreateAttribute()
   {
      List<Node> nodeList = childNode.get("attribute");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigAttributeTypeImpl<FacesConfigConverterType<T>>(this, "attribute", childNode, nodeList.get(0));
      }
      return createAttribute();
   }
1110137
public static <S> PAreaSizeBIGenerator<S> create()
  {
    final LongGenerator gen = new LongGenerator(0L, Long.MAX_VALUE);
    return new PAreaSizeBIGenerator<>(() -> new BigInteger(gen.next().toString()));
  }
1335647
public Object getNextElement() {
        Object element = null;
        while (currentIndex+1 < endIndex && element == null) {
            currentIndex++;
            element = getElement();
        }
        return element;      
    }
1000105
public Converter getFieldConverter()
    {
        for (int i = 0; ; i++)
        {
            Object ojbComponent = this.getField().getComponent(i);
            if (ojbComponent == null)
                break;
            if (ojbComponent instanceof ScreenComponent)
            {
                Converter conv = (Converter)((ScreenComponent)ojbComponent).getConverter();
                if ((conv != null) && (conv.getField() == this.getField()))
                    return conv;   // Since there is a converter in front of this field, return the converter
            }
        }
        return this;
    }
485337
public Convert<Embedded<T>> getOrCreateConvert()
   {
      List<Node> nodeList = childNode.get("convert");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ConvertImpl<Embedded<T>>(this, "convert", childNode, nodeList.get(0));
      }
      return createConvert();
   }
255540
public Converter getDefaultConverter() {
        if (getPm().getDefaultConverter() == null) {
            Converter c = new GenericConverter();
            Properties properties = new Properties();
            properties.put("filename", "converters/show.tostring.converter");
            c.setProperties(properties);
            return c;
        } else {
            return getPm().getDefaultConverter();
        }
    }
495168
@Override
    public FilterMutableType getOrCreateFilter() {
        final List<Node> nodeList = this.getRootNode().get("filter");
        if (nodeList.size() > 0) {
            return createNewFilterViewForModel(nodeList.get(0));
        }
        return createFilter();
    }
1086763
public Iterator<ElementType> iterator() {
        return new Iterator<ElementType>() {
            int idx = getIdx;
            int N = size;

            public boolean hasNext() {
                return N > 0;
            }

            public ElementType next() {
                ElementType x = (ElementType) elements[idx];
                idx = (idx + 1) % elements.length;
                N--;
                return x;
            }

            public void remove() {
                throw new UnsupportedOperationException("remove");
            }
        };
    }
993243
public static ISonarConverter getConverterInstance() {

        if (converterInstance == null) {

            synchronized (DefaultSonarConverter.class) {

                if (converterInstance == null)
                    converterInstance = new DefaultSonarConverter();
            }
        }

        return converterInstance;
    }
258099
public EjbLocalRefType<WebFragmentDescriptor> getOrCreateEjbLocalRef()
   {
      List<Node> nodeList = model.get("ejb-local-ref");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new EjbLocalRefTypeImpl<WebFragmentDescriptor>(this, "ejb-local-ref", model, nodeList.get(0));
      }
      return createEjbLocalRef();
   }
532692
public GroupConversionType<GetterType<T>> getOrCreateConvertGroup()
   {
      List<Node> nodeList = childNode.get("convert-group");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new GroupConversionTypeImpl<GetterType<T>>(this, "convert-group", childNode, nodeList.get(0));
      }
      return createConvertGroup();
   }
1273225
protected Converter createConverter(FaceletContext ctx)
    {
        if (_delegate.getConverterId(ctx) == null)
        {
            throw new TagException(_delegate.getTag(),
                                    "Default behavior invoked of requiring a converter-id passed in the "
                                    + "constructor, must override ConvertHandler(ConverterConfig)");
        }
        return ctx.getFacesContext().getApplication().createConverter(_delegate.getConverterId(ctx));
    }
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();
   }