Returns all <code>converter</code> elements
@return list of <code>converter</code>
178357
public List<FacesConfigConverterType<FacesConfigType<T>>> getAllConverter()
   {
      List<FacesConfigConverterType<FacesConfigType<T>>> list = new ArrayList<FacesConfigConverterType<FacesConfigType<T>>>();
      List<Node> nodeList = childNode.get("converter");
      for(Node node: nodeList)
      {
         FacesConfigConverterType<FacesConfigType<T>>  type = new FacesConfigConverterTypeImpl<FacesConfigType<T>>(this, "converter", childNode, node);
         list.add(type);
      }
      return list;
   }
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();
        }
    }
679369
public List<ConversionMethod> getConversionMethods (Class<?> clazz){
		List<ConversionMethod> conversions = new ArrayList<ConversionMethod>();
		Map<String, List<ConversionMethod>> conversionsMap = this.conversionsLoad();
		for (Class<?> classToCheck : getAllsuperClasses(clazz)){
			List<ConversionMethod> methods = conversionsMap.get(classToCheck.getName());
			if(methods != null)conversions.addAll(methods);
		}
		return conversions;
	}
837366
public java.util.List<String> getDeclaredTransforms() {
        if (declaredTransforms == null) {
            declaredTransforms = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return declaredTransforms;
    }
657889
public FacesConfigConverterType<FacesConfigType<T>> getOrCreateConverter()
   {
      List<Node> nodeList = childNode.get("converter");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigConverterTypeImpl<FacesConfigType<T>>(this, "converter", childNode, nodeList.get(0));
      }
      return createConverter();
   }
584231
public InstantConverter[] getInstantConverters() {
        ConverterSet set = iInstantConverters;
        InstantConverter[] converters = new InstantConverter[set.size()];
        set.copyInto(converters);
        return converters;
    }
827570
public static <U, V> Converter<U, V> wrapSingletonList(Converter<List<U>, V> converter) {
    Converter<U, List<U>> listConverter = new SingletonListConverter<U>().inverse();
    return listConverter.compose(converter);
  }
432583
public List<T> pollAll() {
    List<T> retList = new ArrayList<T>(size);
    for (int i = 0; i < entries.length; i++) {
      LinkedElement<T> current = entries[i];
      while (current != null) {
        retList.add(current.element);
        current = current.next;
      }
    }
    this.clear();
    return retList;
  }
74190
function getConverters(from, to) {
        if (from === to) {
            return [];
        }

        if (CONVERTERS[from][to]) {
            return [to];
        }

        var queue = [from];
        var path = {};
        path[from] = [];

        while (queue.length) {
            var v = queue.shift();
            for (var w in CONVERTERS[v]) {
                if (!path[w]) {
                    queue.push(w);
                    path[w] = path[v].concat([w]);
                    if (w === to) {
                        return path[w];
                    }
                }
            }
        }

        return null;
    }
800498
public List<ValidatorElement> getAllValidatorElements() {
        List<ValidatorElement> ret = CollectionUtil.createArrayList();
        for (ListAble<ValidatorElement> e : validatorElementLinkedList) {
            ret.addAll(e.getAsList());
        }
        return ret;
    }
987395
@Override
  public ConvertManager converter()
  {
    if (_convertManager == null) {
      _convertManager = provider(Key.of(ConvertManager.class));
    }

    return _convertManager.get();
  }
415306
public List<FacesConfigRendererType<FacesConfigRenderKitType<T>>> getAllRenderer()
   {
      List<FacesConfigRendererType<FacesConfigRenderKitType<T>>> list = new ArrayList<FacesConfigRendererType<FacesConfigRenderKitType<T>>>();
      List<Node> nodeList = childNode.get("renderer");
      for(Node node: nodeList)
      {
         FacesConfigRendererType<FacesConfigRenderKitType<T>>  type = new FacesConfigRendererTypeImpl<FacesConfigRenderKitType<T>>(this, "renderer", childNode, node);
         list.add(type);
      }
      return list;
   }
51952
public static Converter converterFor( Class type )
    {
        if (!converters.containsKey( type ))
            throw new IllegalArgumentException( "Don't know type: " + type );

        return converters.get( type );
    }
655707
public static <A, B, C, D> Converter<Example<A, B>, Example<C, D>> converter(
      Converter<A, C> inputConverter, Converter<B, D> outputConverter) {
    return new ExampleConverter<A, B, C, D>(inputConverter, outputConverter);
  }
1112902
public PeriodConverter[] getPeriodConverters() {
        ConverterSet set = iPeriodConverters;
        PeriodConverter[] converters = new PeriodConverter[set.size()];
        set.copyInto(converters);
        return converters;
    }
954928
protected function getDefaultConvertors()
	{
		$convertors   = [];
		$convertors[] = new BooleanFunctions($this);
		$convertors[] = new BooleanOperators($this);
		$convertors[] = new Comparisons($this);
		$convertors[] = new Core($this);
		$convertors[] = new Math($this);
		if (extension_loaded('mbstring'))
		{
			$convertors[] = new MultiByteStringManipulation($this);
		}
		$convertors[] = new SingleByteStringFunctions($this);
		$convertors[] = new SingleByteStringManipulation($this);

		return $convertors;
	}
218342
public java.util.List<ConversionTask> getConversionTasks() {
        if (conversionTasks == null) {
            conversionTasks = new com.amazonaws.internal.SdkInternalList<ConversionTask>();
        }
        return conversionTasks;
    }