Gets the adapter for param.

@param paramName
the param name
@return the adapter for param
330967
public TypeName getAdapterForParam(String paramName) {
		if (this.hasAdapterForParam(paramName)) {
			return TypeUtility.typeName(this.parameterName2Adapter.get(paramName));
		} else {
			return null;
		}
	}
438151
def get_parameter(self, name):
        
        for parameter in self._parameters:
            if parameter.name == name:
                return parameter
196650
function getAdapter(serviceInfo, resource, moduleStack) {
        var adapterName = serviceInfo.adapterName;

        // if adapter name is 'service' and there is a default, switch to the default
        if (adapterName === 'service' && resource.adapters[this.injector.container]) {
            adapterName = serviceInfo.adapterName = resource.adapters[this.injector.container];
            serviceInfo.adapterImpl = this.injector.adapterMap[adapterName];
            serviceInfo.serviceName = utils.getCamelCase(serviceInfo.resourceName + '.' +
                serviceInfo.adapterName + '.service');
        }

        // if that doesn't work, we will assume the adapter is in the current codebase, so go get it
        var overridePath = '/resources/' + serviceInfo.resourceName + '/' + serviceInfo.resourceName + '.' +
            (adapterName === 'service' ? adapterName : adapterName + '.service');
        var adapterPath = '/adapters/' + adapterName + '/' +
            serviceInfo.adapterImpl + '.' + adapterName + '.adapter';

        // if override exists, use that one, else use the lower level adapter
        var Adapter =
            this.loadIfExists(overridePath, moduleStack, null) ||
            this.injector.adapters[serviceInfo.adapterImpl] ||
            this.loadIfExists(adapterPath, moduleStack, null);

        // if still no adapter found, then there is an issue
        if (!Adapter) {
            throw new Error('ServiceFactory could not find adapter ' + adapterName +
            ' paths ' + overridePath + ' and ' + adapterPath);
        }

        return new Adapter(resource);
    }
32695
public String findParameterAliasByName(String name) {
		if (parameterName2Alias.containsKey(name)) {
			return parameterName2Alias.get(name);
		}

		return name;
	}
897002
def getParam(self, paramName):
        
        param = getattr(self, paramName)
        if isinstance(param, Param):
            return param
        else:
            raise ValueError("Cannot find param with name %s." % paramName)
1016065
public Integer getPosition(String parameterName) {
        Integer position = null;

        for (int i = 0; i < this.sqlParameterNames.size(); i++) {
            if (this.sqlParameterNames.get(i).equals(parameterName) == true) {
                position = i;
                break;
            }
        }

        return position;
    }
941357
@SuppressWarnings("rawtypes")
    protected String parseStringParameter(Map params, String paramName) {
        Object paramModel = params.get(paramName);
        if (paramModel == null) {
            return null;
        }
        if (!(paramModel instanceof SimpleScalar)) {
            throw new IllegalArgumentException(paramName + " must be string");
        }
        return ((SimpleScalar)paramModel).getAsString();
    }
723192
public static function adapter($name = null) {
		if (!$name) {
			if (!$names = array_keys(static::$_configurations)) {
				return;
			}
			$name = end($names);
		}
		return parent::adapter($name);
	}
506549
@Override
    public IUpdater getUpdaterByParam(String paramName) {
        if (biasUpdater != null && initializer().isBiasParam(this, paramName)) {
            return biasUpdater;
        }
        return iUpdater;
    }
811997
public static Parameter getActionParameter(Action action, String paramName) {
        for (Parameter param : action.getParameters()) {
            if (paramName.equals(param.getName())) {
                return param;
            }
        }
        return NOT_FOUND_PARAMETER;
    }
487156
protected Param getParam (ParamReader reader, String name) {
        return getParam(new Param(reader, name));
    }
1159486
public String getListenScopeParameter( String paramName )
    {
        String retVal = null;

        if ( _listenScopes != null )
        {
            for ( int i = 0, len = _listenScopes.size(); retVal == null && i < len; ++i )
            {
                String key = ScopedServletUtils.getScopedName( paramName, _listenScopes.get( i ) );
                retVal = getRequest().getParameter( key );
            }
        }

        return retVal;
    }
935660
public function getParam($paramName)
    {
        return !empty($this->_params[$paramName]) ? $this->_params[$paramName] : NULL;
    }
700896
public String getParam(String paramName) {
		if (requestParameters == null) {
			return null;
		}
		String[] values = requestParameters.get(paramName);
		if (ArrayUtil.isNotEmpty(values)) {
			return values[0];
		}
		return null;
	}
9318
public static <T> T get(String className, Object... params) {
		final Class<T> clazz = ClassUtil.loadClass(className);
		return get(clazz, params);
	}
302675
public ParameterValue getParameter(String name) {
        if (!getParameters().containsKey(name)) {
            return buildParameterValue();
        }

        return getParameters().get(name);
    }
960999
protected function getRawParameter($paramName)
    {
        $raw = $this->getRequest()->getRawParameters();
        if (!isset($raw[$paramName])) {
            throw new \common_exception_MissingParameter($paramName);
        }
        return $raw[$paramName];
    }