Returns the {@link IGeneratorParameter} for the active {@link IRenderer}.
@param <T>

@param paramType {@link IGeneratorParameter} to get the value of.
@return the {@link IGeneratorParameter} value.

@see #getParameter(Class)
766406
public <T extends IGeneratorParameter<S>, S> S get(Class<T> paramType) {
        return getParameter(paramType).getValue();
    }
1212610
@SuppressWarnings("unchecked")
    public <T extends Annotation> T getParameterAnnotation(Class<T> annotationType) {
        Annotation[] anns = getParameterAnnotations();
        for (Annotation ann : anns) {
            if (annotationType.isInstance(ann)) {
                return (T) ann;
            }
        }
        return null;
    }
1248882
public static Type[] getParameterTypes(Type generic) {
		Type[] types = null;
		if(isGeneric(generic)) {
			types = ((ParameterizedType)generic).getActualTypeArguments();
		}
		return types;
	}
118549
@SuppressWarnings("serial")
    public static Type[] forTypeParameters(final Class<?> type) {
        Type[] result = new Type[type.getTypeParameters().length];
        for (int i = 0; i < result.length; i++) {
            final int index = i;
            result[i] = forTypeProvider(new DefaultTypeProvider() {
                @Override
                public Type getType() {
                    return type.getTypeParameters()[index];
                }
            });
        }
        return result;
    }
1118373
public static String getDesc(Class<?> returnType, Class<?>... paramTypes) {
        StringBuilder sb = new StringBuilder();
        sb.append("(");
        for (Class<?> type : paramTypes) {
            sb.append(ByteCodeUtils.getByteCodeType(type));
        }
        sb.append(")");
        //        sb.append(StringUtils.trim(ByteCodeUtils.getByteCodeType(returnType), ";"));
        sb.append(ByteCodeUtils.getByteCodeType(returnType));
        return sb.toString();
    }
330967
public TypeName getAdapterForParam(String paramName) {
		if (this.hasAdapterForParam(paramName)) {
			return TypeUtility.typeName(this.parameterName2Adapter.get(paramName));
		} else {
			return null;
		}
	}
94486
public String getGenre(int type)
	{
		if (allow(type&ID3V1))
		{
			return id3v1.getGenreString();
		}
		if (allow(type&ID3V2))
		{
			return id3v2.getFrameDataString(ID3v2Frames.CONTENT_TYPE);
		}
		return null;
	}
115187
@SuppressWarnings("static-method")
	protected List<JvmTypeParameter> getTypeParametersFor(XtendTypeDeclaration type) {
		if (type instanceof XtendClass) {
			return ((XtendClass) type).getTypeParameters();
		}
		if (type instanceof XtendInterface) {
			return ((XtendInterface) type).getTypeParameters();
		}
		return Collections.emptyList();
	}
174380
JCTypeParameter typeParameter() {
        int pos = token.pos;
        List<JCAnnotation> annos = typeAnnotationsOpt();
        Name name = ident();
        ListBuffer<JCExpression> bounds = new ListBuffer<>();
        if (token.kind == EXTENDS) {
            nextToken();
            bounds.append(parseType());
            while (token.kind == AMP) {
                nextToken();
                bounds.append(parseType());
            }
        }
        return toP(F.at(pos).TypeParameter(name, bounds.toList(), annos));
    }
1225738
public IGeneratorSet getGenerators() {
    if( generatorSet_ == null && generatorSetRef_ != null)
      {
      try( GeneratorSetResource resource = GeneratorSetResource.at( urlFor( generatorSetRef_)))
        {
        generatorSet_ = resource.getGeneratorSet();
        }
      catch( Exception e)
        {
        throw new GeneratorSetException( String.format( "Can't read resource at %s", generatorSetRef_), e);
        }
      }
    return generatorSet_;
    }
565441
private String getTypeGenericName(Type type)
    {
        StringBuilder sb = new StringBuilder(getTypeName(type));

        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;

            Type[] generics = parameterizedType.getActualTypeArguments();
            if (generics.length > 0) {
                sb.append('<');
                for (int i = 0; i < generics.length; ++i) {
                    if (i > 0) {
                        sb.append(',');
                    }
                    sb.append(getTypeGenericName(generics[i]));
                }
                sb.append('>');
            }
        }

        return sb.toString();
    }
1136089
@Trivial
    private static Type getType(Converter<?> converter) {
        Type type = null;

        Type[] itypes = converter.getClass().getGenericInterfaces();
        for (Type itype : itypes) {
            ParameterizedType ptype = (ParameterizedType) itype;
            if (ptype.getRawType() == Converter.class) {
                Type[] atypes = ptype.getActualTypeArguments();
                if (atypes.length == 1) {
                    type = atypes[0];
                    break;
                } else {
                    throw new ConfigException(Tr.formatMessage(tc, "unable.to.determine.conversion.type.CWMCG0009E", converter.getClass().getName()));
                }
            }
        }
        if (type == null) {
            throw new ConfigException(Tr.formatMessage(tc, "unable.to.determine.conversion.type.CWMCG0009E", converter.getClass().getName()));
        }

        return type;
    }
1126867
public Class<?> getElementType() {
		if (Iterable.class.isAssignableFrom(type)) {
			return (Class<?>) ((ParameterizedType) getGenericType()).getActualTypeArguments()[0];
		} else {
			return type;
		}
	}
609092
public Class<?> getType() {
        Class<?> tmp = parameterClassCache;
        if (null == tmp) {
            tmp = executable.getParameterTypes()[index];
            parameterClassCache = tmp;
        }
        return tmp;
    }
1239039
public static IdGenerator getIdGenerator(GenerationType generationType, String name,
			List<IdGenerator> idGeneratorList) {
		// fixed idGenerators
		IdGenerator idGen = getIdGeneratorByType(generationType);
		if (idGen != null)
			return idGen;
		if (StrUtils.isEmpty(name))
			return null;
		for (IdGenerator idGenerator : idGeneratorList) {
			if (generationType != null && name.equalsIgnoreCase(idGenerator.getIdGenName()))
				return idGenerator;
			if ((generationType == null || GenerationType.OTHER.equals(generationType))
					&& name.equalsIgnoreCase(idGenerator.getIdGenName()))
				return idGenerator;
		}
		return null;
	}
145757
private static String getTypeString(IType t) {
        if(t==null)
            return "null";

        IPtrType pt = t.queryInterface(IPtrType.class);
        if(pt!=null)
            return getTypeString(pt.getPointedAtType())+"*";

        IPrimitiveType prim = t.queryInterface(IPrimitiveType.class);
        if(prim!=null)
            return prim.getName();

        ITypeDecl decl = t.queryInterface(ITypeDecl.class);
        if(decl!=null)
            return decl.getName();

        ISafeArrayType sa = t.queryInterface(ISafeArrayType.class);
        if (sa != null) {
          return "SAFEARRAY(" + getTypeString(sa.getComponentType()) + ")";
        }

        return "N/A";
    }
1198133
final <t> ConvertibleType<t> param(final int index) {
        return this.params.length > index ? (ConvertibleType<t>)this.params[index] : null;
    }