Assign the provided options for the georadius* redis functions
to the request object, as expected by Kuzzle API

Mutates the provided options object

@param $options
164815
private function assignGeoRadiusOptions(&$options)
    {
        $parsed = '';

        foreach ($options as $key => $opt) {
            if ($key === 'withcoord' || $key === 'withdist') {
                if (!empty($parsed)) {
                    $parsed .= ',';
                }

                $parsed .= $key;
                unset($options[$opt]);
            } else if ($key === 'count' || $key === 'sort') {
                if (!empty($parsed)) {
                    $parsed .= ',';
                }

                if ($key === 'count') {
                    $parsed .= 'count,';
                }

                $parsed .= $opt;
                unset($options[$opt]);
            }
        }

        if (!empty($parsed)) {
            $options['query_parameters']['options'] = $parsed;
        }
    }
212924
public function setOptions(array $options) : void
    {
        self::$options = array_unique(array_merge(self::$options, $options));
    }
121699
public function setOptions(array $options = array())
    {
        foreach (static::$supportedOptions as $key) {
            if (isset($options[$key])) {
                $this->$key = $options[$key];
            }
        }
    }
902116
public function setOptions($options)
	{
		if (!is_array($options) && !$options instanceof Traversable) {
			throw new \InvalidArgumentException(sprintf(
				'Expected an array or Traversable; received "%s"',
				(is_object($options) ? get_class($options) : gettype($options))
			));
		}
		
		foreach ($options as $key => $value){
			
			$key = strtolower($key);
			
			switch ($key) {
			    case 'services':
			        $this->registerServices($value);
			        break;
			    case 'locator':
			    case 'service_locator':
			        $this->setServiceLocator($value);
			        break;
		        case 'service_manager':
		            $this->configureServiceManager($value);
		            break;
			}
		}
		
		return $this;
	}
1195659
public function setOptions($options = [])
    {
        $this->options = $options;
        $this->debug->info(__FUNCTION__, 'setOptions: ', $this->options);

        return $this;
    }
1210137
public function setOptions(OptionsInterface $options = null)
    {
        if (null !== $options && !$options instanceof Options) {
            $options = new Options($options->toArray());
        }

        $this->options = $options;
        return $this;
    }
1228338
protected function initializeOptions(array $options)
    {
        foreach ($options as $key => $value) {
            $method = 'set' . ucfirst($key);
            if (method_exists($this, $method)) {
                call_user_func(array($this, $method), $value);
            }
        }
    }
97296
public function addOptions($options)
    {
        if (is_string($options)) {
            $this->mergeOptions($this->optionParser->parseString($options));
        } elseif (is_array($options)) {
            $this->mergeOptions($this->optionParser->parseArray($options));
        } else {
            throw new \InvalidArgumentException("Getopt(): argument must be string or array");
        }
    }
453644
public function setOptions(array $options)
    {
        if (! array_key_exists(self::CONFIG_SOURCE, $options)
            || ! is_array($options[self::CONFIG_SOURCE])
            || empty($options[self::CONFIG_SOURCE])
        ) {
            throw new InconsistencyConfigException(__('Injector has to contains a valid "source" field.'));
        }

        if (! array_key_exists(self::CONFIG_DESTINATION, $options)
            || ! is_array($options[self::CONFIG_DESTINATION])
            || empty($options[self::CONFIG_DESTINATION])
        ) {
            throw new InconsistencyConfigException(__('Injector has to contains a valid "destination" field.'));
        }

        parent::setOptions($options);
    }
722229
public function setOptions($options) {
		$this->renderer->getElement()->setOptions($options);
		$this->renderer->getHtmlElement()->setOptions($options);
	}
22758
protected function addGlobalOptions($options)
    {
        if (!empty($options)) {
            foreach ($options as $name => $value) {
                $this->globalOptions[$name] = $value;
            }
        }
    }
118408
static public function setOptions($options = [])
    {
        if (isset($options['gzip'])) {
            self::$optGzip = !empty($options['gzip']);
        }
        if (isset($options['minimal'])) {
            self::$optMinimal = !empty($options['minimal']);
        }
    }
826548
public function setOptions($options){
		$options = array_intersect_key($options,$this->defaultOptions);
		$this->options = array_merge($this->defaultOptions, $this->options, $options);
	}
1191818
public function setOptions(array $options)
    {
        foreach ($options as $key => $value) {
            if (in_array(strtolower($key), $this->_skipOptions)) {
                continue;
            }

            $method = 'set' . ucfirst($key);
            if (method_exists($this, $method)) {
                $this->$method($value);
            }
        }

        return $this;
    }
413042
public function set($options)
    {
        $this->__opts__ = $this->assign($this->__opts__, $options);
        return $this;
    }
446404
public function withOptions($options)
    {
        if (is_array($options)) {
            $options = new RequestOptions($options);
        }

        $this->options = $options;

        return $this;
    }
472708
public function setOptions(array $options)
    {
        foreach ($options as $k => $v) {
            $this->setOption($k, $v);
        }
    }