Include the configuration file used to setup the peridot
environment

@param $configuration
@return bool
8940
protected function includeConfiguration($configuration)
    {
        if (file_exists($configuration)) {
            $callable = include $configuration;
            if (is_callable($callable)) {
                call_user_func($callable, $this->eventEmitter);
            }
        }

        return true;
    }
1333589
public function init($configuration)
    {
        $returnValue = (bool) false;


    	if (isset($configuration['host'])) {
    		$this->host = $configuration['host'];
    	}

    	if (isset($configuration['port'])) {
    		$this->port = $configuration['port'];
    	}

    	$returnValue = parent::init($configuration);


        return (bool) $returnValue;
    }
222811
public function init($configuration)
    {
        $returnValue = (bool) false;

        
    	if (isset($configuration['file'])) {
    		$this->filename = $configuration['file'];
    		$returnValue = parent::init($configuration);
    	} else {
    		$returnValue = false;
    	}
        

        return (bool) $returnValue;
    }
553354
def include_config(include, orig_path, verbose, exit_on_config_errors=False):
    '''
    
    '''
    # Protect against empty option
    if not include:
        return {}

    if orig_path is None:
        # When the passed path is None, we just want the configuration
        # defaults, not actually loading the whole configuration.
        return {}

    if isinstance(include, six.string_types):
        include = [include]

    configuration = {}
    for path in include:
        # Allow for includes like ~/foo
        path = os.path.expanduser(path)
        if not os.path.isabs(path):
            path = os.path.join(os.path.dirname(orig_path), path)

        # Catch situation where user typos path in configuration; also warns
        # for empty include directory (which might be by design)
        glob_matches = glob.glob(path)
        if not glob_matches:
            if verbose:
                log.warning(
                    'Warning parsing configuration file: "include" path/glob '
                    "'%s' matches no files", path
                )

        for fn_ in sorted(glob_matches):
            log.debug('Including configuration from \'%s\'', fn_)
            try:
                opts = _read_conf_file(fn_)
            except salt.exceptions.SaltConfigurationError as error:
                log.error(error)
                if exit_on_config_errors:
                    sys.exit(salt.defaults.exitcodes.EX_GENERIC)
                else:
                    # Initialize default config if we wish to skip config errors
                    opts = {}
            schedule = opts.get('schedule', {})
            if schedule and 'schedule' in configuration:
                configuration['schedule'].update(schedule)
            include = opts.get('include', [])
            if include:
                opts.update(include_config(include, fn_, verbose))

            salt.utils.dictupdate.update(configuration, opts, True, True)

    return configuration
1329274
public function init($configuration)
    {
        $returnValue = (bool) false;

    	$this->appenders = array();
    	$this->minLevel = null;
    	foreach ($configuration as $appenderConfig) {
    		if (isset($appenderConfig['class'])) {
    			
    			$classname = $appenderConfig['class'];
    			if (!class_exists($classname)){
    				$classname = 'common_log_'.$classname;
                }
    			if (class_exists($classname) && is_subclass_of($classname, 'common_log_Appender')) {
    				$appender = new $classname();
    				if (!is_null($appender) && $appender->init($appenderConfig)) {
    					$this->addAppender($appender);
    				}
    			}
    		}
    	}
    	$returnValue = (count($this->appenders) > 0);
        

        return (bool) $returnValue;
    }
275669
private function checkTransitionsConfiguration(array $configuration)
    {
        foreach ($configuration as $transitionConfiguration) {
            if (
                is_array($transitionConfiguration) &&
                (count($transitionConfiguration) === 3) &&
                isset($transitionConfiguration[0]) &&
                is_string($transitionConfiguration[0]) &&
                $transitionConfiguration[0] &&
                isset($transitionConfiguration[1]) &&
                is_string($transitionConfiguration[1]) &&
                $transitionConfiguration[1] &&
                isset($transitionConfiguration[2]) &&
                is_string($transitionConfiguration[2]) &&
                $transitionConfiguration[2]
            ) {
                return $this;
            }
        }

        throw new TransitionNotValidException();
    }
818050
public function detectConfig(): ConfigurationInterface
    {
        if (file_exists($file = $this->rootDir.'/config/sculpin_site_'.$this->environment.'.yml')) {
            return $this->getConfigFile($file);
        }

        if (file_exists($file = $this->rootDir.'/config/sculpin_site.yml')) {
            return $this->getConfigFile($file);
        }

        return new Configuration();
    }
983144
public function init(?string $configuration = 'project'): void
    {
        $config = Core::i()->config->getConfiguration($configuration);
        if (isset($config['site_name'])) {
            $this->site_name = $config['site_name'];
        }
        if (isset($config['title_format'])) {
            $this->title_format = $config['title_format'];
        }
    }
411447
protected function setConfiguration(\stdClass $configuration)
    {
        $this->configuration = $configuration;
        $this->updateHash();
        $this->setDirty(true);
    }
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;
    }
1310428
public function getConfig()
    {
        $config = false;
        if (file_exists(realpath(__DIR__ . "/../ExactTargetLaravelConfig.php"))) {
            $config = include __DIR__ . "/../ExactTargetLaravelConfig.php";
            return $config;
        }
        return $config;
    }
1260465
public function hasConfig() {
		if ($this->_configSupplied !== null) {
			return true;
		}
		
		if ($this instanceof LocatorAwareInterface && $this->hasLocator()
			&& $this->getLocator()->has($this->getConfigServiceId())) {
			return true;
		}
		
		return false;
	}
929126
final public static function setConfig(ConfigInterface $configuration) {
        $previous = self::$defaultConfig;
        self::$defaultConfig = $configuration;
        if (self::$defaultDi)
            self::$defaultDi->set('config', $configuration);
        return $previous;
    }
1235448
public function setConfiguration($configuration)
	{
		if(is_array($configuration) or is_object($configuration))
			foreach($configuration as $name => $value)
			{
				$this->{$name} = $value;
			}
	}
1224131
protected function doSetup($config = array())
    {
        // Catch the configuration file path
        if (isset($config[self::CONFIG_KEY_FILE_PATH])) {
            $this->configFilePath = $config[self::CONFIG_KEY_FILE_PATH];
        } else {
            // Also consider throwing an exception here instead
            // of failing silently
            return $config;
        }

        // Catch the context
        if (isset($config[ConfigInterface::KEY_CONTEXT])) {
            $this->context = $config[ConfigInterface::KEY_CONTEXT];
        }

        return $this->readConfigurationFiles();
    }
1082870
public function addConfiguration(ConfigurationInterface $configuration)
    {
        if (isset($this->configurations[$configuration->getName()])) {
            throw new ConfigurationException(sprintf('Configuration "%s" already added.', $configuration->getName()));
        }

        $this->validateConfiguration($configuration);

        $this->configurations[$configuration->getName()] = $configuration;
    }
378077
public function generateSetupTyposcript($configuration, $settings)
    {
        // generate TypoScript setup
        $setupContent = [];

        // for backend module
        $setupContent[] = $this->convertArrayToTypoScript([
            'view' => [
                'templateRootPaths' => [
                    10 => 'EXT:mask/Resources/Private/Backend/Templates/'
                ],
                'partialRootPaths' => [
                    10 => 'EXT:mask/Resources/Private/Backend/Partials/'
                ],
                'layoutRootPaths' => [
                    10 => 'EXT:mask/Resources/Private/Backend/Layouts/'
                ]
            ],
            'persistence' => [
                'classes' => [
                    BackendLayout::class => [
                        'mapping' => [
                            'tableName' => 'backend_layout',
                            'columns' => [
                                'uid.mapOnProperty' => 'uid',
                                'title.mapOnProperty' => 'title'
                            ]
                        ]
                    ]
                ]
            ]
        ], 'module.tx_mask');

        // for base paths to fluid templates configured in extension settings
        $setupContent[] = $this->convertArrayToTypoScript([
            'templateRootPaths' => [
                10 => rtrim($settings['content'], '/') . '/'
            ],
            'partialRootPaths' => [
                10 => rtrim($settings['partials'], '/') . '/'
            ],
            'layoutRootPaths' => [
                10 => rtrim($settings['layouts'], '/') . '/'
            ]
        ], 'lib.maskContentElement');

        // for each content element
        if ($configuration["tt_content"]["elements"]) {
            foreach ($configuration["tt_content"]["elements"] as $element) {
                if (!$element["hidden"]) {
                    $setupContent[] = "tt_content.mask_" . $element["key"] .
                        " =< lib.maskContentElement\ntt_content.mask_" . $element["key"] .
                        " {\ntemplateName = " . MaskUtility::getTemplatePath(
                            $settings,
                            $element['key'],
                            true
                        ) . "\n}\n\n";
                }
            }
        }

        return implode("\n\n", $setupContent);
    }