Check if the config file has any missed attribute, and if any attribute
is missed will be overridden by a default attribute defined in this class.

@param $configurations
175378
private function parseAndFillConfiguration($configurations)
    {
        $this->default_include = isset($configurations['include']) ?
            array_merge($this->default_include, $configurations['include']) : $this->default_include;

        $this->default_exclude = isset($configurations['exclude']) ?
            array_merge($this->default_exclude, $configurations['exclude']) : $this->default_exclude;
    }
1262222
public function checkMethods(array $configuration)
    {
        foreach ($configuration as $classNamespace => $classConfiguration) {
            if (
                !isset($classConfiguration['idGetter']) ||
                !method_exists($classNamespace, $classConfiguration['idGetter']) ||
                !isset($classConfiguration['fields']) ||
                !is_array($classConfiguration['fields'])
            ) {
                throw new TranslationDefinitionException();
            }

            foreach ($classConfiguration['fields'] as $fieldName => $fieldConfiguration) {
                if (
                    $fieldName &&
                    $fieldConfiguration &&
                    is_array($fieldConfiguration) &&
                    isset($fieldConfiguration['getter']) &&
                    method_exists($classNamespace, $fieldConfiguration['getter']) &&
                    isset($fieldConfiguration['setter']) &&
                    method_exists($classNamespace, $fieldConfiguration['setter'])
                ) {
                    continue;
                }

                throw new TranslationDefinitionException(
                    'Field ' . $classNamespace . ' not found, or methods [' . $fieldConfiguration['getter'] . ', ' . $fieldConfiguration['setter'] . '] not found inside the class'
                );
            }
        }

        return $this;
    }
554353
private function _checkConfig($config = null)
    {
        if ($config === null) {
            $config = $this->config;
        }
        if (!($config instanceof ArrayAccess)
            && !is_array($config)
        ) {
            throw new Klarna_IncompleteConfigurationException;
        }
    }
127026
public function hasDirtyPreset($attribute)
    {

        // Require a previous encoding instance
        return ($encoding = $this->encoding($attribute))

            // Make sure the input actually contains a preset.  It won't in cases like
            // the AJAX PUT during listing drag and drop sorting or visibility toggle
            && ($preset_key = $this->encodingPresetInputKey($attribute))
            && request()->exists($preset_key)

            // Check if the preset has changed
            && request($preset_key) != $encoding->preset;
    }
1296045
protected function validateConfiguration($config)
    {
        $requiredFields = $this->getRequiredConfigurationFields();
        $missingFields = [];
        foreach ($requiredFields as $requiredField) {
            if (array_key_exists($requiredField, $config) === false) {
                $missingFields[] = $requiredField;
            }
        }
        if (count($missingFields) > 0) {
            throw new \RuntimeException('Some fields are not configured: ' . implode(', ', $missingFields));
        }
    }
241427
private static function setDefaultConfig() {
            if (!self::$defaults) {
                self::$defaults = [self::CFG_EXCEPTION_DEPTH        => 10,
                                   self::CFG_LOG_EXCEPTION_LOCATION => true];
            }
        }
998796
protected function initConfig($file) {
		if(file_exists($this->dir.'/'.$file)) {
			if(!$this->confirm('Do you want to override "'.$file.'"?'))
				return;
		}

		$config = file_get_contents(__DIR__.'/stubs/'.$file.'.stub');
		$key = \Asgard\Common\Tools::randStr(10);
		$config = str_replace('_KEY_', $key, $config);

		if(\Asgard\File\FileSystem::write($this->dir.'/'.$file, $config))
			$this->info('Configuration file "'.$file.'" created with success.');
		else
			$this->error('Configuration file "'.$file.'" creation failed.');
	}
238388
protected static function loadAdditionalConfiguration(Configuration $configuration)
    {
        if (null !== ($pattern = $configuration->getAdditionalConfigurationDirectory())) {
            $iterator = new \DirectoryIterator(sprintf($pattern, dirname($configuration->getIdentity())));
            foreach ($iterator as $file) {
                $configuration->merge(Configuration::createFromFile($file->getRealPath()));
            }
        }
    }
1041236
protected function checkConfig($config)
    {
        $required_fields = ['namespace', 'table', 'path', 'mapping', 'import_keys'];

        foreach ($required_fields as $key) {
            if (!array_has($config, $key)) {
                $this->error(sprintf('Missing \'%s\' from the dataset configuration file.', $key));
                $this->line('');
                $this->line('');

                exit(1);
            }
        }
    }
865161
def _check_configuration(self, *attrs):
        
        for attr in attrs:
            if getattr(self, attr, None) is None:
                raise ConfigurationError("{} not configured".format(attr))
84600
public function check()
    {
        $result = true;

        $configurationSettings = [
            'Database.Host',
            'Database.Username',
            'Database.Password',
            'Database.Port',
            'Database.Name',
        ];

        foreach ($configurationSettings as $setting) {
            if ($this->configuration->hasConfigurationKey($setting) === false) {
                $this->missingConfiguration[] = $setting;
                $result = false;
            }
        }

        return $result;
    }
994352
protected function processConfigurationTraitUpload(&$configuration)
    {
        //check parameters
        if(!isset($configuration['subjects'][$this->name]['Upload']) || empty($configuration['subjects'][$this->name]['Upload'])) {
            throw new \Exception(sprintf('missing Upload fields definitions into %s subject configuration', $this->name));
        } else {
            $this->uploadFieldsDefinitions = $configuration['subjects'][$this->name]['Upload'];
        }
    }
565494
protected function include_configuration() {
        $configuration = array();
        // We need to allow for late static bindings to allow for class path mudling happending for unit tests.
        $cachefile = static::get_config_file_path();

        if (!file_exists($cachefile)) {
            throw new cache_exception('Default cache config could not be found. It should have already been created by now.');
        }

        if (!include($cachefile)) {
            throw new cache_exception('Unable to load the cache configuration file');
        }

        if (!is_array($configuration)) {
            throw new cache_exception('Invalid cache configuration file');
        }
        if (!array_key_exists('stores', $configuration) || !is_array($configuration['stores'])) {
            $configuration['stores'] = array();
        }
        if (!array_key_exists('modemappings', $configuration) || !is_array($configuration['modemappings'])) {
            $configuration['modemappings'] = array();
        }
        if (!array_key_exists('definitions', $configuration) || !is_array($configuration['definitions'])) {
            $configuration['definitions'] = array();
        }
        if (!array_key_exists('definitionmappings', $configuration) || !is_array($configuration['definitionmappings'])) {
            $configuration['definitionmappings'] = array();
        }
        if (!array_key_exists('locks', $configuration) || !is_array($configuration['locks'])) {
            $configuration['locks'] = array();
        }

        return $configuration;
    }
998146
private function overrideConfiguration(array $configuration, array $override)
    {
        $configuration['parameters'] = array_replace(
            $configuration['parameters'],
            $override['parameters']
        );

        unset($override['parameters']);

        return array_replace($configuration, $override);
    }
780
public function isMode( Configuration $configuration ) {
		if( $this->inServiceChecker->isInService($configuration) )
			return false;

		if( $this->replaceUpgradeChecker->isReplaceUpgrade($configuration) )
			return false;

		return true;
	}
395112
private static function setDefaultConfig() {
            if (!self::$defaults) {
                self::$defaults = [self::CFG_ERROR_LEVEL        => error_reporting(),
                                   self::CFG_LOG_ERROR_LOCATION => true];
            }
        }
164256
private function applyConfiguration($configuration = [])
    {
        array_walk($configuration, function ($value, $key) {
            $this->updateAttribute($key, $value);
        });
    }