Creates the configuration mapping for Oracle databases

@param array $configuration
@return array
320974
public function map(array $configuration)
	{

        $defaults = ['pooled' => false];
        $optional = ['servicename', 'instancename'];

        foreach ($optional as $opt) {
            if(isset($configuration[$opt]))
                $defaults[$opt] = $configuration[$opt];
        }

		return array_merge($defaults, [
			'driver' => $this->driver($configuration['driver']),
            'port' => @$configuration['port'] ? $configuration['port'] : 1521,
			'host' => $configuration['host'],
			'dbname' => $configuration['database'],
			'user' => $configuration['username'],
			'password' => $configuration['password'],
            'charset' => $configuration['charset'],
            'prefix' => @$configuration['prefix'] ? $configuration['prefix'] : null
		]);
	}
1258160
private function getAdapters(array $configuration, ContainerBuilder $container)
    {
        if (!isset($configuration['adapter'])) {
            $configuration['adapter'] = $container->getParameter(self::PARAMETER);
        }

        return (array) $configuration['adapter'];
    }
777558
private function getCollectionBy($configuration)
    {
        if (!$configuration) {
            return null;
        }

        $db = $this->connection->selectDB($configuration['db']);
        return $db->{$configuration['collection']};
    }
956158
public function resolveParams(array $configuration)
    {
        if ($this->resolved) {
            return;
        }

        $this->config = $configuration;
        $parameters = [];
        foreach ($configuration as $key => $value) {
            $key = $this->resolveValue($key);
            $value = $this->resolveValue($value);
            $parameters[$key] = $this->unescapeValue($value);
        }

        $this->resolved = true;

        return $parameters;
    }
13032
protected function instantiateBackends(array $configuration)
    {
        $backends = [];
        foreach ($configuration as $backendConfiguration) {
            $class = $backendConfiguration['class'] ?? '';
            $options = $backendConfiguration['options'] ?? [];
            $backends[] = $this->instantiateBackend($class, $options);
        }

        return $backends;
    }
916294
private function disableCache(array $configuration): array
    {
        if (isset($this->options['force']) && $this->options['force']) {
            $configuration['phpdocumentor']['use-cache'] = false;
        }

        return $configuration;
    }
755029
protected function redisFactory(array $configuration): Redis
	{
		return (new Redis($this->container->get(RedisConnectionManager::class)->connection($configuration['configuration']), $this->classWhitelist))->setPrefix($configuration['prefix'] ?? '');
	}
1327160
protected function buildTasks(array $configuration)
    {
        $this->io->text('- Building tasks...');
        $builder = new TaskBuilder($this->debug);

        $tasks = $builder->build($configuration);

        $this->io->text('- Tasks build !');
        $this->io->newLine();

        return $tasks;
    }
59718
public function processAcls(array &$configuration)
    {
        if (!isset($configuration['acls'])) {
            return;
        }
        $newRolesConfiguration = isset($configuration['roles']) ? $configuration['roles'] : array();
        foreach ($configuration['acls'] as $roleIdentifier => $aclConfiguration) {
            $roleIdentifier = $this->expandRoleIdentifier($roleIdentifier);
            if (!isset($newRolesConfiguration[$roleIdentifier])) {
                $newRolesConfiguration[$roleIdentifier] = array();
            }
            if (!isset($newRolesConfiguration[$roleIdentifier]['privileges'])) {
                $newRolesConfiguration[$roleIdentifier]['privileges'] = array();
            }
            foreach ($aclConfiguration as $resourceType => $permissions) {
                if ($resourceType !== 'methods' && $resourceType !== 'entities') {
                    $this->showWarning('Resource type "' . $resourceType . '" is not supported...');
                    continue;
                }
                foreach ($permissions as $resourceName => $permission) {
                    $newRolesConfiguration[$roleIdentifier]['privileges'][] = array('privilegeTarget' => $resourceName, 'permission' => $permission);
                }
            }
        }
        unset($configuration['acls']);
        $configuration['roles'] = $newRolesConfiguration;
    }
901365
private function getOperatorConfiguration(array $operators): array
    {
        $conf = [];
        foreach ($operators as $operator => $leafType) {
            $instance = $this->types->getOperator($operator, $leafType);
            $field = [
                'name' => $this->getOperatorFieldName($operator),
                'type' => $instance,
            ];

            $conf[] = $field;
        }

        return $conf;
    }
1213863
public function init($configurations = array())
    {
        $this->parseAndFillConfiguration($configurations);

        $this->included_directories = $this->default_include['directories'];
        $this->included_extensions = $this->default_include['extensions'];
        $this->included_patterns = $this->default_include['patterns'];

        $this->excluded_directories = $this->default_exclude['directories'];
        $this->excluded_files = $this->default_exclude['files'];
        $this->excluded_extensions = $this->default_exclude['extensions'];
        $this->excluded_patterns = $this->default_exclude['patterns'];
        $this->exclude_hidden = $this->default_exclude['hidden'];

        return $this;
    }
1362883
public static function config_get_configuration_array($data) {
        $return = array(
            'server' => $data->server,
            'database' => $data->database,
            'extendedmode' => (!empty($data->extendedmode))
        );
        if (!empty($data->username)) {
            $return['username'] = $data->username;
        }
        if (!empty($data->password)) {
            $return['password'] = $data->password;
        }
        if (!empty($data->replicaset)) {
            $return['replicaset'] = $data->replicaset;
        }
        if (!empty($data->usesafe)) {
            $return['usesafe'] = true;
            if (!empty($data->usesafevalue)) {
                $return['usesafe'] = (int)$data->usesafevalue;
                $return['usesafevalue'] = $return['usesafe'];
            }
        }
        return $return;
    }
991183
protected function generate_configuration_array() {
        $configuration = array();
        $configuration['stores'] = $this->configstores;
        $configuration['modemappings'] = $this->configmodemappings;
        $configuration['definitions'] = $this->configdefinitions;
        $configuration['definitionmappings'] = $this->configdefinitionmappings;
        $configuration['locks'] = $this->configlocks;
        return $configuration;
    }
1237023
protected function insert(array $configuration, &$context)
    {
        $tuples = [];
        $parameters = [];

        $rows = $this->confHelper->resolve($configuration[self::CONF_PARAMETERS], $context);
        foreach ($rows as $key => $params) {
            $params = $this->prepareParameters($params, $key);
            $tuples[] = '('.implode(',', $params['names']).')';
            $parameters = array_merge_recursive($parameters, $params);
        }

        $sql = $this->confHelper->resolve($configuration[self::CONF_SQL], $context);
        $sql = str_replace(':values', implode(',', $tuples), $sql);

        return $this->performQuery($configuration, $context, $parameters, $sql);
    }
120974
public static function get_supported_features(array $configuration = array()) {
        $supports = self::SUPPORTS_DATA_GUARANTEE + self::DEREFERENCES_OBJECTS;
        if (array_key_exists('extendedmode', $configuration) && $configuration['extendedmode']) {
            $supports += self::SUPPORTS_MULTIPLE_IDENTIFIERS;
        }
        return $supports;
    }
1057035
private function mapLaravelToDoctrineConfig($config)
    {
        $default = $config['database.default'];
        $connection = $config["database.connections.{$default}"];
        return App::make(DriverMapper::class)->map($connection);
    }
652997
public static function get(array $configuration = array())
    {
        if (extension_loaded('memcache')) {
            $memcache = new \Memcache();
            $memcache->connect($configuration[CacheKeys::HOST]);
            $cache = new MemcacheCache();
            $cache->setMemcache($memcache);
            return $cache;
        }
    }