Get transformer for type.

@param property
the property
@return transform
175027
public static BindTransform lookup(BindProperty property) {
		TypeName typeName = property.getPropertyType().getTypeName();

		if (property.hasTypeAdapter()) {
			typeName = typeName(property.typeAdapter.dataType);
		}

		return lookup(typeName);
	}
1297514
public static <T> T getValue(ValuedProperty<T> property) {
		return (property == null) ? null : property.getValue();
	}
822159
public Object getProperty(String property) {
        if (isValidExpandoProperty(property)) {
            if (property.equals(STATIC_QUALIFIER)) {
                return new ExpandoMetaProperty(property, true);
            } else if (property.equals(CONSTRUCTOR)) {
                return new ExpandoMetaConstructor();
            } else {
                if (myMetaClass.hasProperty(this, property) == null)
                    return new ExpandoMetaProperty(property);
                else
                    return myMetaClass.getProperty(this, property);
            }
        } else {
            return myMetaClass.getProperty(this, property);
        }
    }
558518
private String getProperty(String property) {

        String ret = sdkProperties.getProperty(property);

        if (null == ret) {
            logger.warn(String.format("No configuration value found for '%s'", property));
        }
        return ret;
    }
922029
@SuppressWarnings("unchecked")
    private ClassesTransformer<T> getTyped(ClassesTransformer<? extends T> classesTransformer) {
        return (ClassesTransformer<T>) classesTransformer;
    }
1314676
public Class<?> getClass(String property) {
    return getProperty(property, className -> {
      try {
        return Class.forName(className);
      } catch (ClassNotFoundException e) {
        throw new ConfigurationException("unknown class: " + className, e);
      }
    });
  }
547826
function (model, property) {
  // TODO the reference to model.api is not available
  if (model.api && model.api.modelPropertyMacro) {
    return model.api.modelPropertyMacro(model, property);
  } else {
    return property.default;
  }
}
1348809
public function getPropertyType($entity, $property)
    {
        $metaData = $this->_getEntityConfiguration($entity);
        return $metaData->attributes[$property]['type'];
    }
867330
public static Object getProperty(Object target, String property) {
    try {
      return InvokerHelper.getProperty(target, property);
    } catch (InvokerInvocationException e) {
      ExceptionUtil.sneakyThrow(e.getCause());
      return null; // never reached
    }
  }
139340
public static String columnTypeAsString(SQLProperty property) {
		if (property.columnAffinityType != null && ColumnAffinityType.AUTO != property.columnAffinityType) {
			return property.columnAffinityType.toString();
		}

		TypeName typeName = property.getPropertyType().getTypeName();
		if (property.hasTypeAdapter()) {
			typeName = typeName(property.typeAdapter.dataType);
		}

		SQLTransform transform = lookup(typeName);

		if (transform == null) {
			throw new IllegalArgumentException("Transform of " + property.getElement().asType() + " not supported");
		}
		return transform.getColumnType().toString();

	}
610115
private TypePair getPropertyType(Object bean, String name) throws IllegalAccessException, InvocationTargetException {
        try {
            PropertyDescriptor propDescriptor = PropertyUtils.getPropertyDescriptor(bean, name);
            if(propDescriptor!=null) {
                Method m = propDescriptor.getWriteMethod();
                if(m!=null)
                    return new TypePair(m.getGenericParameterTypes()[0], m.getParameterTypes()[0]);
            }
        } catch (NoSuchMethodException e) {
            // no such property
        }

        // try a field
        try {
            return new TypePair(bean.getClass().getField(name));
        } catch (NoSuchFieldException e) {
            // no such field
        }

        return null;
    }
1343276
public String getRawProperty(T property)
    {
        String propertyName = getTranslator().getPropertyName(property);
        String value = properties.getProperty(propertyName);

        if (value != null && isAutoTrim())
        {
            value = value.trim();
        }

        return value;
    }
70624
public static PrefsTransform lookup(PrefsProperty property) {
		TypeMirror typeMirror = property.getElement().asType();

		TypeName typeName = typeName(typeMirror);
		return lookup(typeName);
	}
1134381
protected void configureTransformerInstance(final IClassTransformer transformerInstance,
                                              final Properties properties) throws Exception {
    if (null == transformerInstance || !(transformerInstance instanceof ClassTransformer)) {
      return;
    }
    ((ClassTransformer)transformerInstance).configure(properties);
  }
840154
private static PrefsTransform getTransform(TypeName typeName) {
		if (typeName.isPrimitive()) {
			return getPrimitiveTransform(typeName);
		}

		if (typeName instanceof ArrayTypeName) {
			ArrayTypeName typeNameArray = (ArrayTypeName) typeName;
			TypeName componentTypeName = typeNameArray.componentType;

			if (TypeUtility.isEquals(componentTypeName, Byte.TYPE.toString())) {
				return new ByteArrayPrefsTransform();
			} else {
				return new ArrayPrefsTransform();
			}
		} else if (typeName instanceof ParameterizedTypeName) {
			ParameterizedTypeName parameterizedTypeName = (ParameterizedTypeName) typeName;
			if (TypeUtility.isList(parameterizedTypeName)) {
				return new ListPrefsTransformation();
			} else if (TypeUtility.isSet(parameterizedTypeName)) {
				return new SetPrefsTransformation();
			} else if (TypeUtility.isMap(parameterizedTypeName)) {
				return new MapPrefsTransformation();
			}
		}

		PrefsTransform transform;

		transform = getLanguageTransform(typeName);
		if (transform != null) {
			return transform;
		}

		transform = getUtilTransform(typeName);
		if (transform != null) {
			return transform;
		}

		transform = getMathTransform(typeName);
		if (transform != null) {
			return transform;
		}

		transform = getNetTransform(typeName);
		if (transform != null) {
			return transform;
		}

		transform = getSqlTransform(typeName);
		if (transform != null) {
			return transform;
		}

		if (TypeUtility.isEnum(typeName)) {
			return new EnumPrefsTransform(typeName);
		}

		return new ObjectPrefsTransform();
	}
367218
public function getConvertedValue(\ReflectionProperty $property, $original, Property $annot = null)
    {
        return $this->handleTypeConversion($this->propertyTypeOverride($annot, $property), $property->getValue($original));
    }
689516
public Object getProperty(String property) {
        if(ExpandoMetaClass.isValidExpandoProperty(property)) {
            if(property.equals(ExpandoMetaClass.STATIC_QUALIFIER) ||
               property.equals(ExpandoMetaClass.CONSTRUCTOR) ||
               myMetaClass.hasProperty(this, property) == null) {
                  return replaceDelegate().getProperty(property);
            }
        }
        return myMetaClass.getProperty(this, property);
    }