Retrieve the collection configset.

@return array|null
497222
public function collectionConfig()
    {
        if ($this->collectionConfig === null) {
            $this->collectionConfig = $this->createCollectionConfig();
        }

        return $this->collectionConfig;
    }
487041
public function getConfiguration(){
        $rest = $this->getService( self::API_CONNECTION_CONFIG);
        $rest->GET();

        return $rest->getResult( models\Connection\Config::class);
    }
1248433
public static function get( $key = null ) {
		$configs = self::$configs;
		if ( $key ) {
			$configs = ! empty( self::$configs[ $key ] ) ? self::$configs[ $key ] : null;
		} else {
			$configs = self::$configs;
		}

		return $configs;
	}
937257
public function getConfig($key = null)
	{
		if ($key === null)
		{
			return array_merge($this->configDefaults, $this->config);
		}
		elseif (isset($this->config[$key]))
		{
			return $this->config[$key];
		}
		elseif (isset($this->configDefaults[$key]))
		{
			return $this->configDefaults[$key];
		}

		return null;
	}
1305225
private function fetchCollection()
    {
        $contextOptions = $this->getContextOptions();

        if (isset($contextOptions[$this->_protocol]['collection'])) {
            $collection = $contextOptions[$this->_protocol]['collection'];
            if ($collection instanceof Collection) {
                throw new InvalidConfigException('"collection" context option should be an instance of "' . Collection::className() . '"');
            }

            return $collection;
        }

        $connection = isset($contextOptions[$this->_protocol]['db'])
            ? $contextOptions[$this->_protocol]['db']
            : 'mongodb';

        /* @var $connection Connection */
        $connection = Instance::ensure($connection, Connection::className());

        list($databaseName, $collectionPrefix) = explode('.', $this->_namespace, 2);
        return $connection->getDatabase($databaseName)->getFileCollection($collectionPrefix);
    }
340668
public function getConfig()
    {
        $this->_library->setEnvironment();
        
        $config = [
            'library' => [
                'session' => $this->_library->getSession(),
                'directPaymentJs' => $this->_library->getDirectPaymentUrl()
            ],
            'brazilFlagPath' => $this->_library->getImageUrl('UOL_PagSeguro::images/flag-origin-country.png'),
            'payment' => [
                'pagseguro' => [
                    'isDirect'   => $this->method->isDirectCheckout(),
                    'isLightbox' => $this->method->isLightboxCheckoutType(),
                    'checkout'   => [
                        'lightbox' => $this->method->getLightboxCheckoutPaymentUrl(),
                        'standard' => $this->method->getStandardCheckoutPaymentUrl(),
                        'direct'   => $this->method->getDirectCheckoutPaymentUrl()
                    ]
                ]
            ],
            'pagseguro_boleto' => $this->boletoMethod->getStandardCheckoutPaymentUrl(),
        ];
        return $config;
    }
974619
public function getConfig()
    {
        if(!$this->_config instanceof ObjectConfig) {
            $this->_config = new ObjectConfig($this->__config);
        }

        return $this->_config;
    }
1049516
public function getConfig()
    {
        $conf = [];
        foreach (glob(__DIR__.'/../../config/*.config.php') as $conFile) {
            $conFile = include_once $conFile;
            if (is_array($conFile))
                $conf = \Poirot\Core\array_merge($conf, $conFile);
        }

        // usually return like this
        return $conf;
    }
987013
public function getConfig()
	{
		return $this->_node->__isset( 'config' ) && is_array( $this->_node->config ) ? $this->_node->__get( 'config' ) : array();
	}
618323
public function get_setting() {
        global $CFG;

        $value = $this->config_read($this->name);
        $flag  = $this->config_read($this->name.'_flag');

        if (is_null($value) or is_null($flag)) {
            return NULL;
        }

        $flag   = (int)$flag;
        $forced = (boolean)(1 & $flag); // first bit
        $adv    = (boolean)(2 & $flag); // second bit

        return array('value' => $value, 'forced' => $forced, 'adv' => $adv);
    }
455895
protected function getConfigs()
    {
    	$session = $this->container->get('session');
    	if (!$configs = $session->get($this->getRequest()->get('thrace_media_id', false))){
            $configs = [
                'max_upload_size' => '200000000',
                'extensions' => 'application/*'
            ];
    	}
    	
    	return $configs;
    }
419300
protected static function _getConfig() {

		$sConfig = get_called_class();

		$aConfig =& static::$_lConfig[$sConfig];
		if ($aConfig) {
			return $aConfig;
		}

		$aConfigFull = Config::get('mongo');

		$aGet =& $aConfigFull['server'][$sConfig];
		if (!is_array($aGet)) {
			throw new TangoException('mongo server config "' . $sConfig . '"');
		}

		$aGet += $aConfigFull['default'];

		$sCustom =& $aGet['custom'];
		if ($sCustom && is_string($sCustom)) {

			$aCustom =& $aConfigFull['custom'][$sCustom];

			if (!is_array($aCustom)) {
				throw new TangoException('mongo server config custom "' . $sCustom . '"');
			}

			$aGet += $aCustom;
		}

		unset($aGet['custom']);
		$aGet += [
			'capacity' => 0,
			'pool' => [],
			'max_capacity' => 0,
		];

		if (!$aGet['pool'] || !is_array($aGet['pool'])) {
			throw new TangoException('mongo config "' . $sConfig . '" empty pool');
		}

		if ($aGet['capacity']) {
			if (static::$_sKeyType != 'int') {
				throw new TangoException('mongo config "' . $sConfig . '" enabled sharding but no int key');
			}
			$aGet['max_capacity'] = $aGet['capacity'] * count($aGet['pool']);
		}

		$aConfig = $aGet;
		return $aConfig;
	}
117034
protected function _getConf()
    {
        // retrieve and cache config
        $services = $this->services();

        /** @var aSapi $config */
        $config   = $services->get('/sapi');
        $orig = $config   = $config->config();
        /** @var DataEntity $config */
        $config   = $config->get(\Module\Authorization\Module::CONF, array());

        if (!isset($config[self::CONF]) && !is_array($config[self::CONF]))
            return null;


        $config   = $config[self::CONF];
        return $config;
    }
370238
public static function getConfig()
    {
        if (static::$config !== null) {
            return static::$config;
        }

        $configs = Registry::get('config');

        return static::$config = isset($configs['cookie']) ? $configs['cookie'] : [];
    }
997724
private function get_sets() {

        if (empty($this->raw_sets)) {
            $this->raw_sets = $this->flickr->call('photosets.getList');
        }

        if ($this->raw_sets === false) {
            // Authentication failed, drop the locally stored token to force re-authentication.
            $this->set_user_config([
                'accesstoken' => null,
                'accesstokensecret' => null,
            ]);
            return array();
        }

        $sets = array();
        foreach ($this->raw_sets->photosets->photoset as $set) {
            $sets[$set->id] = $set->title->_content;
        }
        return $sets;
    }
1230546
private function get_configured_typesets() {
        $typeslist = (string)$this->get_config('filetypeslist');

        $util = new \core_form\filetypes_util();
        $sets = $util->normalize_file_types($typeslist);

        return $sets;
    }
1374745
protected function getListConfig()
    {
        $name = $this->getParam(0);

        if (isset($name)) {
            $result = $this->config->get($name);
            if (!isset($result)) {
                $this->errorAndExit($this->text('Invalid argument'));
            }
            $list = array($name => $result);
        } else {
            $list = $this->config->get();
            $this->limitArray($list);
        }

        $saved = $this->config->select();

        $reindexed = array();
        foreach ($list as $key => $value) {
            $reindexed[] = array(
                'key' => $key,
                'value' => $value,
                'in_database' => isset($saved[$key])
            );
        }

        return $reindexed;
    }