If not already created, a new <code>convert</code> element with the given value will be created.
Otherwise, the existing <code>convert</code> element will be returned.
@return  a new or existing instance of <code>Convert<Basic<T>></code>
968313
public Convert<Basic<T>> getOrCreateConvert()
   {
      Node node = childNode.getOrCreate("convert");
      Convert<Basic<T>> convert = new ConvertImpl<Basic<T>>(this, "convert", childNode, node);
      return convert;
   }
51352
public <T> Object convert(Class collectionType, Class<T> elementType, String origin) throws ConversionException {
        Converter<T> elementConverter = find(elementType);
        CollectionConverter<T> converter = new CollectionConverter<>(elementConverter, stringSplitter);

        try {
            Collection<T> converted = converter.convert(origin);
            return castCollectionToType(collectionType, converted);
        } catch (Exception e) {
            throw new ConversionException(String.format("Could not convert string <%s> to collection <%s> " +
                    "with element type <%s>", origin, collectionType, elementType), e);
        }
    }
1316726
@SuppressWarnings("unchecked")
	public <T> T convertElement(ConversionContext context, Object source,
			TypeReference<T> destinationType) throws ConverterException {
		return (T) elementConverter.convert(context, source, destinationType);
	}
813611
@XmlElementDecl(namespace = "http://www.opengis.net/gml", name = "Conversion", substitutionHeadNamespace = "http://www.opengis.net/gml", substitutionHeadName = "_GeneralConversion")
    public JAXBElement<ConversionType> createConversion(ConversionType value) {
        return new JAXBElement<ConversionType>(_Conversion_QNAME, ConversionType.class, null, value);
    }
1232018
public T addElement(T element) {
		// make sure that elements are initialized
		getElements();
		if (!containsElement(this.elements, element)) {
			this.elements.add(element);
			element.addChangeListener(this.elementChangeListener);
			element.notifyState();
			return element;
		}
		throw new RuntimeException(element.toString() + " already exists");
	}
1289451
@SuppressWarnings("unchecked")
	public static <K, E extends Number> NumberMap<K, E> newNumberMap(Class<E> elementType) {
		if (elementType == BigDecimal.class) return (NumberMap<K, E>) newBigDecimalMap();
		if (elementType == BigInteger.class) return (NumberMap<K, E>) newBigIntegerMap();
		if (elementType == Byte.class) return (NumberMap<K, E>) newByteMap();
		if (elementType == Long.class) return (NumberMap<K, E>) newLongMap();
		if (elementType == Double.class) return (NumberMap<K, E>) newDoubleMap();
		if (elementType == Float.class) return (NumberMap<K, E>) newFloatMap();
		if (elementType == Integer.class) return (NumberMap<K, E>) newIntegerMap();
		if (elementType == Short.class) return (NumberMap<K, E>) newShortMap();
		else throw new UnsupportedOperationException();
	}
547361
public static EntryElement makeEntryElement(Object value) {
        Class<?> type = ClassUtils.primitiveToWrapper(value.getClass());
        return new EntryElement(type.getName(), value.toString());
    }
93311
public EnumGene<A> newInstance(final A value) {
		return new EnumGene<>(
			_validAlleles.indexOf(value),
			_validAlleles
		);
	}
1207845
public static <T> T convert(TypeReference<T> reference, Object value) throws ConvertException{
		return convert(reference.getType(), value, null);
	}
894767
public static RejectStatus fromValue(int value) {
        RejectStatus status = VALUES.get(value);
        if (status == null) {
            status = new RejectStatus(value);
            VALUES.put(value, status);
        }
        return status;
    }
107564
public Converter<OrmDescriptor> getOrCreateConverter()
   {
      List<Node> nodeList = model.get("converter");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ConverterImpl<OrmDescriptor>(this, "converter", model, nodeList.get(0));
      }
      return createConverter();
   }
80743
public Converter<EntityMappings<T>> getOrCreateConverter()
   {
      List<Node> nodeList = childNode.get("converter");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ConverterImpl<EntityMappings<T>>(this, "converter", childNode, nodeList.get(0));
      }
      return createConverter();
   }
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();
   }
20703
public <T> T convert(Object source, Class<T> clazz)
			throws ConverterException {
		return (T) convert(new ConversionContext(), source, clazz);
	}
1303678
@SuppressWarnings("unchecked")
    public static <T> T convert(Object fromValue, Class<T> toType) throws TypeCastException {
        return convert(fromValue, toType, (String) null);
    }
447594
@Override
    public Object convert(Object value) {
       if(value instanceof Element) {
           return parseXmlElement((Element) value);
       }
       if(value instanceof CompositeData) {
           return toMap((CompositeData)value);
       }
       return value;
    }
234112
protected final Object convert(Class targetType, String value) {
        Converter converter = Stapler.lookupConverter(targetType);
        if (converter==null)
            throw new IllegalArgumentException("Unable to convert to "+targetType);

        return converter.convert(targetType,value);
    }