Customize configuration for individual member

@param string $name Destination member name
@param MemberOptionInterface|MemberOptionInterface[] $memberOptions Member option
@throws PapperConfigurationException
@return MappingFluentSyntax
162250
public function forMember($name, $memberOptions)
	{
		$propertyMap = $this->typeMap->getPropertyMap($name);
		if ($propertyMap === null) {
			throw new PapperConfigurationException(sprintf('Unable to find destination member %s on type %s', $name, $this->typeMap->getDestinationType()));
		}
		$memberOptions = is_array($memberOptions) ? $memberOptions : array($memberOptions);
		foreach ($memberOptions as $memberOption) {
			if (!$memberOption instanceof MemberOptionInterface) {
				throw new PapperConfigurationException('Member options must be array or instance of Papper\MemberOptionInterface');
			}
			$memberOption->apply($this->typeMap, $propertyMap);
		}
		return $this;
	}
973871
public function getOption($name){
        return (isset($this->configOptions->{$name})) ? $this->configOptions->{$name} : false;    
    }
655463
public function addOptionalQueryParameter($name, $value)
    {
        Validate::isString($name, 'name');
        Validate::isString($value, 'value');

        if (!empty($value)) {
            $this->_queryParams[$name] = $value;
        }
    }
1047665
protected function createUserConfig(ContainerBuilder $container, $name, array $config)
    {
        $tagParams = array(
            'alias' => $name,
            'class' => $config['user_class'],
            'path' => $config['path'],
            'host' => $config['host'],
            'db_driver' => $config['db_driver'],
        );

        if (null !== $config['request_matcher']) {
            $tagParams['request_matcher'] = $config['request_matcher'];
        }

        $def = $container->register('rollerworks_multi_user.user_system.'.$name, 'Rollerworks\Bundle\MultiUserBundle\Model\UserConfig');
        $def
            ->addArgument($this->servicePrefix)
            ->addArgument($this->routesPrefix)
            ->addArgument(new Reference(sprintf('%s.user_manager', $this->servicePrefix)))
            ->addArgument(new Reference(sprintf('%s.group_manager', $this->servicePrefix)))
            ->addMethodCall('setConfig', array('use_listener', $config['use_listener']))
            ->setPublic(false)
            ->addTag('rollerworks_multi_user.user_system', $tagParams)
        ;

        $def->addMethodCall('setTemplate', array('layout', $config['template']['layout']));
        $def->setLazy(true);

        return $def;
    }
469681
public function setOption($name, $value)
    {
        $methodName = 'set' . ucfirst($name);
        if (!method_exists($this, $methodName)) {
            throw new RuntimeException('Method not exists: ' . $methodName);
        }
        return $this->$methodName($value);
    }
1246628
public function argument($name) {
        $this->validated = false;
        if (!preg_match('#^[a-zA-Z0-9\-\_]+$#', $name)) {
            throw new OptionConfigException('illegal characters in name: ' . $name);
        }
        $this->config[self::ARGUMENT] = $name;
        return $this;
    }
1292554
public static function setOptions(array $userOptions = array())
    {
        // set default options on first run only (before applying user settings)
        if (!self::$_defaultOptionsSet) {
            foreach (self::$_defaultOptions as $defaultOptionName => $defaultOptionValue) {
                if (isset(self::$_defaultOptions[$defaultOptionName])) {
                    @ini_set("session.$defaultOptionName", $defaultOptionValue);
                }
            }

            self::$_defaultOptionsSet = true;
        }

        // set the options the user has requested to set
        foreach ($userOptions as $userOptionName => $userOptionValue) {

            $userOptionName = strtolower($userOptionName);

            // set the ini based values
            if (array_key_exists($userOptionName, self::$_defaultOptions)) {
                @ini_set("session.$userOptionName", $userOptionValue);
            }
            elseif (isset(self::$_localOptions[$userOptionName])) {
                self::${self::$_localOptions[$userOptionName]} = $userOptionValue;
            }
            else {
                /** @see Zend_Session_Exception */
                // require_once 'Zend/Session/Exception.php';
                throw new Zend_Session_Exception("Unknown option: $userOptionName = $userOptionValue");
            }
        }
    }
536417
public function setOption($name, $value)
    {
        if ($name == 'cached_entity') {
            $this->setCachedEntity($value);
        } else {
            parent::setOption($name, $value);
        }
    }
1064667
public function toOptions($name)
    {
        $html = '';
        foreach ($this->wei->getConfig($name) as $value => $text) {
            if (is_array($text)) {
                $html .= '<optgroup label="' . $value . '">';
                foreach ($text as $v => $t) {
                    $html .= '<option value="' . $v . '">' . $t . '</option>';
                }
                $html .= '</optgroup>';
            } else {
                $html .= '<option value="' . $value . '">' . $text . '</option>';
            }
        }
        return $html;
    }
185392
public function property(string $memberExpression) : ColumnMappingDefiner
    {
        $this->memberParser->parse($this->class, $memberExpression);

        return new ColumnMappingDefiner(
            function (IColumn $column) use ($memberExpression) {
                $this->column($column);
                $this->propertyComponentIdMap[$memberExpression] = $column->getComponentId();
            },
            function ($componentId) use ($memberExpression) {
                $this->propertyComponentIdMap[$memberExpression] = $componentId;
            }
        );
    }
1040197
public function choice(string $name, array $options = []): FieldTypeInterface
    {
        return (new ChoiceType($name))
            ->setLocale($this->app->getLocale())
            ->setViewFactory($this->viewFactory)
            ->setOptions($options);
    }
7804
private function getMappingField(ContainerConfigurationInterface $containerConfiguration, $fieldName)
    {
        if (isset($this->fieldMapper[$fieldName])) {
            $fieldName = $this->fieldMapper[$fieldName];
        }

        try {
            $optionTextFieldName = $this->mappingHelper->getOptionTextFieldName($fieldName);
            $containerConfiguration->getMapping()->getField($optionTextFieldName);
            $fieldName = $optionTextFieldName;
        } catch (\Exception $e) {
            ;
        }

        return $fieldName;
    }
577650
protected function createOptionResolver($name)
    {
        $resolverName = ucfirst($name) . 'OptionResolver';

        if(!isset($this->optionResolvers[$resolverName])) {
            $className = "\\Wangjian\\PinganPay\\OptionResolver\\$resolverName";
            $this->optionResolvers[$resolverName] = new $className();
        }

        return $this->optionResolvers[$resolverName];
    }
332147
public function setName($name) {
        if ($name !== null && ! $this->argumentsParser->isOptionName($name)) {
            throw new InvalidOptionNameException(s(
                'A option name must have this format: "--option", got: "%s"', $name
            ));
        }

        $this->name = $name;

        return $this;
    }
8233
public function addOption($name, Option $opt = null) {
        if (isset($this->configOpts[$name]) || isset($this->configArgs[$name])) {
            throw new ConfigException('option/argument already set: ' . $name);
        }

        if (is_null($opt)) {
            $opt = new Option();
        }

        $this->configOpts[$name] = $opt;
        return $opt;
    }
225184
public function getOption($name)
    {
        if (!\array_key_exists($name, $this->options)) {
            throw new \OutOfBoundsException(\sprintf('Unknown option "%s"', $name));
        }

        return $this->options[$name];
    }
908854
public function getOption($locale, $name, $default = null)
    {
        return isset($this->localesConfig[$locale][$name]) ? $this->localesConfig[$locale][$name] : $default;
    }