Returns a variable element mirroring a {@code Parameter} object.
@return a variable element mirroring a {@code Parameter} object
@param p the {Parameter} to mirror
187275
public static VariableElement createMirror(java.lang.reflect.Parameter p) {
        return new CoreReflParameterVariableElement(Objects.requireNonNull(p));
    }
369115
@Override
	public Void visitAnnotation(AnnotationMirror a, String p) {
		if (AnnotationAttributeType.INDEXES.getValue().equals(p)) {
			inTasks = true;
		}

		if (inTasks) {
			currentValue = new Pair<List<String>, Boolean>(new ArrayList<String>(), false);
			for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : a.getElementValues().entrySet()) {
				String key = entry.getKey().getSimpleName().toString();
				entry.getValue().accept(this, key);
			}
			indexes.add(currentValue);
		}

		if (AnnotationAttributeType.INDEXES.getValue().equals(p)) {
			inTasks = false;
		}

		return null;
	}
789118
@Override
    public R visitParam(ParamTree node, P p) {
        R r = scan(node.getName(), p);
        r = scanAndReduce(node.getDescription(), p, r);
        return r;
    }
1308108
public static Object getVariableEL(PageContext pc, String var, Object defaultValue) {
	StringList list = parse(pc, new ParserString(var), false);
	if (list == null) return defaultValue;

	int scope = scopeString2Int(pc.ignoreScopes(), list.next());
	Object coll = null;
	if (scope == Scope.SCOPE_UNDEFINED) {
	    coll = pc.undefinedScope().get(KeyImpl.init(list.current()), NullSupportHelper.NULL());
	    if (coll == NullSupportHelper.NULL()) return defaultValue;
	}
	else {
	    try {
		coll = VariableInterpreter.scope(pc, scope, list.hasNext());
		// coll=pc.scope(scope);
	    }
	    catch (PageException e) {
		return defaultValue;
	    }
	}

	while (list.hasNext()) {
	    coll = pc.getVariableUtil().get(pc, coll, KeyImpl.init(list.next()), NullSupportHelper.NULL());
	    if (coll == NullSupportHelper.NULL()) return defaultValue;
	}
	return coll;
    }
41862
private Integer getFromParameter(Map<String, String> parameters) throws TransformationOperationException {
        return getSubStringParameter(parameters, fromParam, 0);
    }
1179543
public final <T extends Parameter> T getParameter(final String aName) {
        for (final Parameter p : parameters) {
            if (aName.equalsIgnoreCase(p.getName())) {
                return (T) p;
            }
        }
        return null;
    }
830903
public SDVariable getVariable(String name) {
        Variable v = variables.get(name);
        return v == null ? null : v.getVariable();
    }
1231902
public static <T> Predicate<Iterable<T>> all(
      final Predicate<? super T> p) {
    return new Predicate<Iterable<T>>() {
      @Override
      public boolean apply(Iterable<T> obj) {
        return Iterables.all(obj, p);
      }
    };
  }
526613
public String getParameterByReflection(Object obj, String param)
    {
        Object value = null;
        try {
            java.lang.reflect.Method method = obj.getClass().getMethod("getParameter", String.class);
            
            if (method != null)
                value = method.invoke(obj, param);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (value == null)
            return null;
        else
            return value.toString();
    }
1220617
public EquivalentParameter convert(Parameter p) {
        if (p == null) return null;
        return paramCvtr.convert(p);
    }
838114
public ParameterBinding getBindingFor(int position) {

        for (ParameterBinding binding : bindings) {
            if (binding.hasPosition(position)) {
                return binding;
            }
        }

        throw new IllegalArgumentException(String.format("No parameter binding found for position %s!", position));
    }
763457
public T findItem (Predicate<T> p)
    {
        if (_items == null) {
            return null;
        }
        for (T item : _items) {
            if (p.apply(item)) {
                return item;
            }
        }
        return null;
    }
1315365
public String getParameter( String name )
    {
        if (_parameters == null || !_parameters.hasParameters())
            return null;

        List parameters = _parameters.getParameterValues(name);
        if(parameters != null && parameters.size() > 0)
            return (String)parameters.get(0);
        else return null;
    }
1105685
@SuppressWarnings("unchecked")
	public void merge(Parameter<?> parameter)
	{
		if (parameter.getValue() != null)
			value = (T) parameter.getValue();
	}
661262
@SuppressWarnings("unchecked")
    public <T> T getValue(final String variableName) {
        final Variable variable = getVariable(variableName);
        return (variable == null) ? null : (T) variable.getValue();
    }
614612
@Override
  public final Method getFor(final Class<?> pClass, final String pFieldName) {
    Map<String, Method> methMap = this.rapiMethodsMap.get(pClass);
    if (methMap == null) {
      // There is no way to get from Map partially initialized bean
      // in this double-checked locking implementation
      // cause putting to the Map fully initialized bean
      synchronized (this.rapiMethodsMap) {
        methMap = this.rapiMethodsMap.get(pClass);
        if (methMap == null) {
          methMap = new HashMap<String, Method>();
          Method[] methods = getUtlReflection().retrieveMethods(pClass);
          for (Method method : methods) {
            if (method.getName().startsWith("get")) {
              String fldNm = method.getName().substring(3, 4).toLowerCase()
                + method.getName().substring(4);
              methMap.put(fldNm, method);
            }
          }
          //assigning fully initialized object:
          this.rapiMethodsMap.put(pClass, methMap);
        }
      }
    }
    return methMap.get(pFieldName);
  }
83070
def p_variable(self, p):
        """"""
        p[0] = [_Segment(_BINDING, p[2])]
        if len(p) > 4:
            p[0].extend(p[4])
        else:
            p[0].append(_Segment(_TERMINAL, '*'))
            self.segment_count += 1
        p[0].append(_Segment(_END_BINDING, ''))