Generate the params that will be used during the registration phase
@return Map with all the parameters
358133
private HashMap<String, String> createRegistrationParams() {
        registrationKeyPair = KeyPairUtility.generateRandomKeyPair();

        JSONObject csrJSON = new JSONObject();
        HashMap<String, String> params;

        try {
            DeviceIdentity deviceData = new BaseDeviceIdentity(preferences.deviceIdentity.getAsMap());
            AppIdentity applicationData = new BaseAppIdentity(preferences.appIdentity.getAsMap());

            csrJSON.put("deviceId", deviceData.getId());
            csrJSON.put("deviceOs", "" + deviceData.getOS());
            csrJSON.put("deviceModel", deviceData.getModel());
            csrJSON.put("applicationId", applicationData.getId());
            csrJSON.put("applicationVersion", applicationData.getVersion());
            csrJSON.put("environment", "android");

            String csrValue = jsonSigner.sign(registrationKeyPair, csrJSON);

            params = new HashMap<>(1);
            params.put("CSR", csrValue);

            return params;
        } catch (Exception e) {
            throw new RuntimeException("Failed to create registration params", e);
        }
    }
905972
public Map<String, String[]> getParameterMap() {
		// JSR 289 Section 5.6.1 Parameters :
		// For initial requests where a preloaded Route header specified the application to be invoked, the parameters are those of the SIP or SIPS URI in that Route header.
		// For initial requests where the application is invoked the parameters are those present on the request URI, 
		// if this is a SIP or a SIPS URI. For other URI schemes, the parameter set is undefined.
		// For subsequent requests in a dialog, the parameters presented to the application  are those that the application itself 
		// set on the Record-Route header for the initial request or response (see 10.4 Record-Route Parameters). 
		// These will typically be the URI parameters of the top Route header field but if the upstream SIP element is a 
		// "strict router" they may be returned in the request URI (see RFC 3261). 
		// It is the containers responsibility to recognize whether the upstream element is a strict router and determine the right parameter set accordingly.
		HashMap<String, String[]> retval = new HashMap<String, String[]>();
		if(this.getPoppedRoute() != null) {
			Iterator<String> parameterNamesIt =  this.getPoppedRoute().getURI().getParameterNames();
			while (parameterNamesIt.hasNext()) {
				String parameterName = parameterNamesIt.next();
				String [] paramsArray = {this.getPoppedRoute().getURI().getParameter(parameterName)}; //Get the parameter map value to String[]
				retval.put(parameterName, paramsArray); 
			}
		} else {
			Iterator<String> parameterNamesIt =  this.getRequestURI().getParameterNames();
			while (parameterNamesIt.hasNext()) {
				String parameterName = parameterNamesIt.next();
				String [] paramsArray = {this.getPoppedRoute().getURI().getParameter(parameterName)}; //Get the parameter map value to String[]
				retval.put(parameterName, paramsArray);
			}
		}		
		
		return retval;
	}
133260
private function createMap()
    {
        $map = [];
        //browse directories recursively
        $directoryIterator = new \RecursiveDirectoryIterator($this->inputDirectory);
        $iterator = new \RecursiveIteratorIterator($directoryIterator);
        foreach ($iterator as $file) {
            if ($file->getFileName() == '.' || $file->getFileName() == '..') {
                continue;
            }
            if (!preg_match($this->modelClassPattern, $file->getPathname())) {
                continue;
            }
            //resolves name of class
            $className = $this->resolveFileClassName($file);
            try {
                $classInstance = $this->instantiateClass($className);
                if ($classInstance instanceof \Phalcon\Mvc\Collection) {
                    $map[$classInstance->getSource()] = $className;
                }
            } catch (\Exception $e) {
                continue;
            }
        }

        return $map;
    }
925299
@SuppressWarnings("unchecked")
    public Map<String, String[]> getParameters()
    {
        return (Map<String, String[]>) this.map.get(Parameter.ParameterValues.PARAMETERS);
    }
329819
public function getParametersArray()
    {
        $result = parent::getParametersArray();

        if (!empty($this->getOffset())) {
            $result['offset'] = $this->getOffset();
        }

        if (!empty($this->getLimit())) {
            $result['limit'] = $this->getLimit();
        }

        if ($this->getTypes()->count() > 0) {
            $result['type'] = implode('|', $this->getTypes()->toArray());
        }

        if (!empty($this->getName())) {
            $result['f_name'] = $this->getName();
        }

        if (!empty($this->getCategoryID())) {
            $result['f_category'] = $this->getCategoryID();
        }

        if (!empty($this->getRepertoireID())) {
            $result['f_repertoire'] = $this->getRepertoireID();
        }

        if (!empty($this->getLocation())) {
            $result['f_location'] = $this->getLocation();
        }

        return $result;
    }
748266
public function getParameters()
    {
        $params = explode("\n", trim($this->_response));

        foreach ($params as $param) {
            list($key, $val) = explode('=', $param, 2);
            $param_array[$key] = $val;
        }

        $param_array['identity'] = substr($param_array['otp'], 0, 12);

        return $param_array;
    }
209069
public function getParameters()
    {
        // If the parameters property is null, it still hasn't been set. Parse
        // the path components first.
        if (is_null($this->parameters)) {
            $this->parameters = $this->parsePath();
        }

        return $this->parameters;
    }
907321
@Override
    public Map<String, Object> getBodyParameters() {

        ArrayList<Map<String, Object>> requestMaps = new ArrayList<Map<String, Object>>();
        for(Request r: this.requests)
            requestMaps.add(requestToBatchMap(r));

        HashMap<String, Object> result = new HashMap<String, Object>();
        result.put("requests", requestMaps);
        result.put("distinctRecomms", this.distinctRecomms);
        return result;
    }
648583
public function all()
    {
        $params = [];

        foreach ($this->methodRequirements as $key => $config) {
            $params[$key] = $this->get($key);
        }

        return $params;
    }
1014636
protected function getUserRegistrationMapper()
    {
        if (!$this->userRegistrationMapper instanceof UserRegistrationMapperInterface) {
            $this->userRegistrationMapper = $this->getServiceLocator()->get('HtUserRegistration\UserRegistrationMapper');
        }

        return $this->userRegistrationMapper;
    }
284034
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.String> getParams() {
    return getParamsMap();
  }
162517
@Override
    public Map<String, String[]> getParameterMap() {
        try {
            collaborator.preInvoke(componentMetaData);
            return request.getParameterMap();
        } finally {
            collaborator.postInvoke();
        }
    }
264106
@Override
    public Map<String, String[]> getParameterMap() {
        if (sanitized == null) {
            sanitized = sanitizeParamMap(orig);
        }

        return sanitized;
    }
800935
public java.util.Map<String, java.util.List<String>> getParameters() {
        return parameters;
    }
504429
@Override
    public Map<String, String> defaultParameters() {
        Map<String, String> dp = new HashMap<>();
        dp.put("0", "jdi");
        for (int i = 1; i <= 9; ++i) {
            dp.put("" + i, "");
        }
        return dp;
    }
288053
public Map<String, Object> getParams() {
    return (null == params) ? Conditions.getParamMap(conditions) : CollectUtils.newHashMap(params);
  }
742175
private function compileAllParameters()
    {
        foreach (array_keys($this->raw_parameters) as $section) {
            $this->parameters[$section] = $this->compileParameters($section);
        }

        return $this->parameters;
    }