Backup the given parameters

@param  array  $parameters the names of the parameters
@return Environment $this
198253
public function backup(array $parameters)
	{
		foreach ($parameters as $name)
		{
			$this->_backup[$name] = $this->group_for_name($name)->get($name);
		}
		return $this;
	}
746910
protected function prepareParameters(array $parameters = [])
    {
        foreach ($parameters as &$parameterValue) {
            if (is_bool($parameterValue)) {
                $parameterValue = (int) $parameterValue;
            } elseif ($parameterValue instanceof \DateTimeInterface) {
                $parameterValue = $parameterValue->format('Y-m-d H:i:s');
            } elseif (!is_scalar($parameterValue) && $parameterValue !== null) {
                throw new \InvalidArgumentException(
                    sprintf('Invalid db parameter type "%s"', gettype($parameterValue))
                );
            }
        }
        unset($parameterValue);

        return $parameters;
    }
536227
private function parametersToData(array $parameters)
    {
        $data = array();

        foreach ($parameters as $parameter) {
            $data[$parameter->getName()] = $this->parameterToData($parameter);
        }

        return (object) $data;
    }
307562
protected function copyShippingAddress(ParameterBag $parameters)
    {
        $billingAddress = $parameters->get('billingAddress');
        
        $shippingAddress = [
            'shippingAddress.copyBillingAddress' => true,
        ];
        
        foreach ($billingAddress as $key => $value) {
            list(, $fieldName) = explode('.', $key);
            $shippingAddress['shippingAddress.' . $fieldName] = $value;
        }
        
        $parameters->set('shippingAddress', $shippingAddress);
    }
1102634
public static function createInstanceToSave(array $parameters): ImportPropertyModel
    {
        try {
            $model = new ImportPropertyModel();

            $model
                ->setUserId($parameters[ImportPropertyRepository::FIELD_USER_ID])
                ->setAction($parameters[ImportPropertyRepository::FIELD_ACTION])
                ->setType($parameters[ImportPropertyRepository::FIELD_TYPE])
            ;

            if ('all' !== $model->getType()) {
                $model
                    ->setInStockDaysAgo($parameters[ImportPropertyRepository::FIELD_IN_STOCK_DAYS_AGO])
                    ->setFilters($parameters[ImportPropertyRepository::FIELD_FILTERS])
                ;
            }

            return $model;

        } catch (\Exception $e) {
            throw $e;
        }
    }
1304657
public function parameters(array $parameters)
    {
        foreach ($parameters as $parameter => $value) {
            if (property_exists($this->parameters, $parameter)) {
                $this->parameters->{$parameter} = $value;
            }
        }

        return $this;
    }
1370147
public static function create($parameters)
    {
        if (is_string($parameters)) {
            return self::fromString($parameters);
        }

        if (is_array($parameters)) {
            return self::fromArray($parameters);
        }

        throw new InvalidArgumentException('Invalid parameters type');
    }
707280
public function setParameters($parameters)
    {
        $this->parameters = [];
        
        foreach ($parameters as $parameter) {
            $this->append($parameter);
        }
        
        return $this;
    }
304845
public function run(array $parameters)
    {
        $info = new SystemInfo();

        printf("%s:\n", Color::head('Environment:'));
        foreach ($info->getEnvironment() as $k => $v) {
            printf("  %s: %s\n", $k, $v);
        }

        printf("%s:\n", Color::head('Versions:'));
        foreach ($info->getVersions() as $k => $v) {
            printf("  %s: %s\n", $k, $v);
        }

        print PHP_EOL;

        return 0;
    }
305988
protected function setParameters(array $parameters = array())
    {
        foreach ($parameters as $parameterKey => $parameterValue) {
            $this->container->setParameter($parameterKey, $parameterValue);
        }
    }
88799
public function setParameters(array $parameters) {
		$this->parameters = [];
		foreach ($parameters as $parameter) {
			$this->addParameter($parameter);
		}

		return $this;
	}
1353400
protected function summary(array $parameters = [])
    {
        ksort($parameters);
        $summary = '';
        foreach ($parameters as $value) {
            $summary .= $value;
        }
        $summary .= $this->config('private_key');

        return md5($summary);
    }
979744
public function withParameters(array $parameters): self
    {
        $query = $this;

        foreach ($parameters as $key => $parameter) {
            $query = $query->withParameter($key, $parameter);
        }

        return $query;
    }
596446
public function details($details, $parameters = array())
    {
        $this->message['details'] = $this->container->translate($details, $parameters);
        return $this;
    }
460261
public function generate($parameters = [])
    {

        $content = $this->getContent();
        if (count($parameters)) {
            foreach ($parameters as $param => $value) {
                $content = str_replace("{{ $param }}", $value, $content);
            }
        }

        return $content;
    }
47200
protected function replaceDefaults(array $parameters)
    {
        foreach ($parameters as $key => &$value) {
            if (! isset($value)) {
                $value = Arr::get($this->defaults, $key);
            }
        }

        return $parameters;
    }
181775
public function initialize(array $parameters = [])
        {
            if (null !== $this->response) {
                throw new RuntimeException('Request cannot be modified after it has been sent!');
            }

            $this->helper->initialize($this, $parameters);

            return $this;
        }