Return the type of parameter (index 0) from the method or the type from the field.
@return The type (class)
772474
public Class<?> getParameterType() {
		Class<?> lvParamType = null;
		if (propertyType == PROPERTY_TYPE_METHOD) {
			Method lvMethod = (Method) accessibleObject;
			Class<?>[] lvParameterTypes = lvMethod.getParameterTypes();
			if (lvParameterTypes != null && lvParameterTypes.length > 0) {
				lvParamType = lvMethod.getParameterTypes()[0];
			}
		} else {
			lvParamType = ((Field) accessibleObject).getType();
		}
		return lvParamType;
	}
986263
public Type type() {
    if (type == null) {
      synchronized (this) {
        if (type == null) {
          type = address() instanceof Inet6Address ? Type.IPV6 : Type.IPV4;
        }
      }
    }
    return type;
  }
1274006
public JType getGenericType()
  {
    try {
      Type type = _field.getGenericType();

      if (type instanceof Class)
  return getType();
      else
  return new JTypeWrapper(_loader, (ParameterizedType) type);
    } catch (NoSuchMethodError e) {
      return getType();
    }
  }
348016
public Type getParameterizedType() {
        Type tmp = parameterTypeCache;
        if (null == tmp) {
            tmp = executable.getAllGenericParameterTypes()[index];
            parameterTypeCache = tmp;
        }

        return tmp;
    }
1358674
public TypeDescription getType() {
        if (mType == null) {
            mType = getTeaToolsUtils().createTypeDescription(
                       getPropertyDescriptor().getPropertyType());
        }

        return mType;
    }
749702
public Type getType()
    {
        Type ret = null;
        try {
            if (this.uuid != null) {
                ret = Type.get(this.uuid);
            }
        } catch (final CacheReloadException e) {
            Instance.LOG.error("Could not load Type for UUID: {}", this.uuid);
        }
        return ret;
    }
874766
public Class<?> getArrayOrCollectionComponentType() {
        if (!isCollection() && !isArray()) {
            throw new IllegalStateException();
        }

        if (isCollection()) {
            Type type = field.getGenericType();
            if (type instanceof ParameterizedType) {
                return toClass(((ParameterizedType) type).getActualTypeArguments()[0]);
            } else {
                String message = String.format("Cannot determine the type parameter of the collection-typed field %s. Raw types are not supported", field);
                throw new IllegalArgumentException(message);
            }
        } else {
            return field.getType().getComponentType();
        }
    }
84088
private Class<?> ptype(@NonNull final Field field) {
        Class<?> ptype = ptypes.get(field);
        if (ptype == null) {
            final ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
            ptype = (Class<?>) parameterizedType.getActualTypeArguments()[0];
            ptypes.put(field, ptype);
        }
        return ptype;
    }
73088
@Pure
	public DBaseFieldType getDBFFieldType(int index) {
		if (this.fieldCount != -1) {
			try {
				final DBaseFileField field = this.fields.get(index);
				if (field != null) {
					return field.getType();
				}
			} catch (Exception exception) {
				//
			}
		}
		return null;
	}
251577
public Class<?> type() {
        Type type = Types.getBaseClass(getClass(), ConsoleAnnotatorFactory.class);
        if (type instanceof ParameterizedType)
            return Types.erasure(Types.getTypeArgument(type,0));
        else
            return Object.class;
    }
968185
@Override
    public String getType(String uri, String local) {
        int index = getIndex(uri, local);

        if (index < 0) {
            return null;
        }
        return getType(index);
    }
609384
public Class<?> getGenericType(Field field) {
        Type generic = field.getGenericType();
        if (generic instanceof ParameterizedType) {
            Type actual = ((ParameterizedType) generic).getActualTypeArguments()[0];
            if (actual instanceof Class) {
                return (Class<?>) actual;
            } else if (actual instanceof ParameterizedType) {
                //in case of nested generics we don't go deep
                return (Class<?>) ((ParameterizedType) actual).getRawType();
            }
        }

        return Object.class;
    }
67237
public String getArgTypes()
    {
        StringBuffer sb = new StringBuffer();
        int i = 0;

        if ( _methodDecl == null || _methodDecl.getParameters() == null )
            return "";
        
        for (ParameterDeclaration paramDecl : _methodDecl.getParameters())
        {
            if (i++ != 0)
                sb.append(", ");

            TypeMirror paramType = paramDecl.getType();
            if (paramType == null)
                return "";

            //
            // Use the erasure here, because we only want the raw type, not the reference
            // type
            //
            sb.append(_ap.getAnnotationProcessorEnvironment().getTypeUtils().getErasure(paramType));
            sb.append(".class");
        }
        return sb.toString();
    }
1094290
private Parameter<?> getParameter(int index)
	{
		if (index < 0 || index >= listParams.size())
			return null;
		return listParams.get(index);
	}
886805
public String getType()
    {
        if ( _fieldDecl == null || _fieldDecl.getType() == null )
            return "";
        
        return _fieldDecl.getType().toString();
    }
1161714
protected int getSortFieldIndex() {
        SortParam sp = getSort();
        Integer index = fieldNameToIndex.get(sp.getProperty());
        if (index == null) {
            index = 1;
        }
        return index;
    }
763915
public static Type parameterizedRequestType(Method method) {
    if (method != null && method.getGenericParameterTypes().length > 0) {
      Type type = method.getGenericParameterTypes()[0];
      if (type instanceof ParameterizedType) {
        return ((ParameterizedType) type).getActualTypeArguments()[0];
      }
    }

    return Object.class;
  }