Method to get property Config

@return  Structure

@since   2.1
@throws \ReflectionException
960061
public function getConfig()
    {
        if (!$this->config) {
            $this->config = new Structure();

            $this->loadConfig($this->config);
        }

        return $this->config;
    }
382162
protected function getConfig()
    {
        if ($this->config !== null) {
            return $this->config;
        }

        $config = $this->merge(
            $this->defaultConfig,
            getValue($this->namespace, $this->composerJson)
        );

        if ($this->presetsPath === null || $config === null) {
            return $this->config = $config;
        }

        $presets = $this->loadPresets(getValue($this->presetsPath, $config, []));
        $presetsConfig = array_reduce($presets, $this->merge, array_shift($presets));

        return $this->config = $this->merge($presetsConfig, $config);
    }
215184
public function build()
    {
        $config = parent::build();
        $fields = $this->fieldsBuilder->build();
        $config['sub_fields'] = $fields['fields'];
        return $config;
    }
143432
public static function getClassConfigInherit()
    {
        $attribute = 'class-config-inherit';

        if (!static::hasClassAttribute($attribute)) {
            $class = static::getClass();
            $stack = [];
            $inherit = [];

            while ($class) {
                $stack[] = $class::getClassConfigArray();
                $class = get_parent_class($class);
            }

            $stack = array_reverse($stack);

            foreach ($stack as $config) {
                $inherit = array_replace_recursive($inherit, $config);
            }

            static::setClassAttribute($attribute, $inherit);
        }

        return static::getClassAttribute($attribute);
    }
1110984
public function getMetaFieldConfig()
    {
        // Obtain Default Config:
        
        $config = Config::inst()->get(self::class, 'default_meta_fields');
        
        // Merge Owner Config:
        
        if (is_array($this->owner->config()->meta_fields)) {
            $config = array_merge($config, $this->owner->config()->meta_fields);
        }
        
        // Answer Config:
        
        return $config;
    }
998144
public function getConstructor()
    {
        if (!isset($this->constructor)) {
            $this->constructor = new ProxyConstructor($this->fullOriginalClassName);
            $this->constructor->injectReflectionService($this->reflectionService);
        }
        return $this->constructor;
    }
85345
public function getProperty()
    {
        return '
    /**
     * @var ' . $this->getType()->getType() . ' $' . $this->getPropertyName() . '
     */
    protected $' . $this->getPropertyName() . ' = ' . $this->getDefault(true) . ';';
    }
963106
private function getCurrentStructureUuid(): ?string
    {
        $request = $this->requestStack->getCurrentRequest();
        if (!$request) {
            return null;
        }

        $structure = $request->get('structure');
        if (!$structure || !$structure instanceof StructureInterface) {
            return null;
        }

        return $structure->getUuid();
    }
1233921
public function asConfig()
	{
		// Remove properties that shouldn't be turned into config arrays
		$properties = get_object_vars($this);
		unset($properties['attributeFilters']);
		unset($properties['bundleGenerator']);
		unset($properties['javascript']);
		unset($properties['rendering']);
		unset($properties['rulesGenerator']);
		unset($properties['registeredVars']);
		unset($properties['templateChecker']);
		unset($properties['templateNormalizer']);
		unset($properties['stylesheet']);

		// Create the config array
		$config    = ConfigHelper::toArray($properties);
		$bitfields = RulesHelper::getBitfields($this->tags, $this->rootRules);

		// Save the root context
		$config['rootContext'] = $bitfields['root'];
		$config['rootContext']['flags'] = $config['rootRules']['flags'];

		// Save the registered vars (including the empty ones)
		$config['registeredVars'] = ConfigHelper::toArray($this->registeredVars, true);

		// Make sure those keys exist even if they're empty
		$config += [
			'plugins' => [],
			'tags'    => []
		];

		// Remove unused tags
		$config['tags'] = array_intersect_key($config['tags'], $bitfields['tags']);

		// Add the bitfield information to each tag
		foreach ($bitfields['tags'] as $tagName => $tagBitfields)
		{
			$config['tags'][$tagName] += $tagBitfields;
		}

		// Remove unused entries
		unset($config['rootRules']);

		return $config;
	}
1016146
protected function getStructureTables()
    {
        if (empty($this->config['structureTables'])) {
            return '';
        }
        $structureTables = [];
        foreach ($this->config['structureTables'] as $table) {
            $structureTables[] = escapeshellarg($table);
        }
        return implode(' ', $structureTables);
    }
1038842
protected function getFieldConfig()
    {
        $config = parent::getFieldConfig();
        
        if ($values = $this->getValueArray()) {
            
            $data = [];
            
            foreach ($values as $value) {
                
                if ($record = $this->getValueRecord($value)) {
                    $data[] = $this->getResultData($record, true);
                }
                
            }
            
            $config['data'] = $data;
            
        }
        
        return $config;
    }
887859
public function get_config()
	{
    $this->update();
		$tmp = bbn\x::remove_empty($this->cfg);
    if ( isset($tmp['content']) && \is_array($tmp['content']) ){
      foreach ( $tmp['content'] as $i => $c ){
        if ( \is_object($c) ){
          if (method_exists($c, 'get_config') ){
            $tmp['content'][$i] = $c->get_config();
          }
        }
      }
    }
    return $tmp;
	}
208486
final public static function get_create_structure() {
        $properties = self::properties_definition();
        $returns = array();

        foreach ($properties as $property => $definition) {
            if ($property == 'id') {
                // The can not be set on create.
                continue;

            } else if (isset($returns[$property]) && substr($property, -6) === 'format') {
                // We've already treated the format.
                continue;
            }

            $required = VALUE_REQUIRED;
            $default = null;

            // We cannot use isset here because we want to detect nulls.
            if (array_key_exists('default', $definition)) {
                $required = VALUE_DEFAULT;
                $default = $definition['default'];
            }

            // Magically treat the contextid fields.
            if ($property == 'contextid') {
                if (isset($properties['context'])) {
                    throw new coding_exception('There cannot be a context and a contextid column');
                }
                $returns += self::get_context_structure();

            } else {
                $returns[$property] = new external_value($definition['type'], $definition['description'], $required, $default,
                    $definition['null']);

                // Magically treat the format properties.
                if ($formatproperty = self::get_format_field($properties, $property)) {
                    if (isset($returns[$formatproperty])) {
                        throw new coding_exception('The format for \'' . $property . '\' is already defined.');
                    }
                    $returns[$formatproperty] = self::get_format_structure($property,
                        $properties[$formatproperty], VALUE_REQUIRED);
                }
            }
        }

        return new external_single_structure($returns);
    }
730147
public function getConfig() {
		if(!$this->config) {
			$this->config = $config = new \Asgard\Config\Config($this->getCache());
			if(file_exists($this->params['root'].'/config'))
				$config->loadDir($this->params['root'].'/config', $this->getEnv());
		}
		return $this->config;
	}
1367791
public function getConfig()
    {
        if ($this->config === null) {
            $path = $this->getInputDirectory() . '/makedocs.json';
            if (!is_file($path)) {
                throw new \RuntimeException('The input directory does not contain a makedocs.json file.');
            }

            $data = json_decode(file_get_contents($path));
            if (!$data) {
                throw new \RuntimeException('The JSON could not be loaded.');
            }

            $this->config = new Config((array)$data);
        }
        return $this->config;
    }
1122136
public function get_builder_config() {
		$vars = Arr::except( get_object_vars( $this ),
			[ 'sections', 'containers', 'properties', 'builder', '_form' ]
		);

		return array_merge( $vars, $this->properties );
	}
775874
public function getConfigTreeBuilder()
    {
        $treeBuilder = new TreeBuilder();
        $rootNode = $treeBuilder->root('nucleus_core');

        $rootNode
            ->fixXmlConfig('annotation_container_generator')
            ->children()
                ->arrayNode('annotation_container_generators')
                    ->prototype('array')
                        ->children()
                            ->scalarNode('annotationClass')
                                ->isRequired()
                                ->validate()
                                ->ifTrue(function($value) {return !class_exists($value,true);})
                                    ->thenInvalid('Class not found annotation [%s]')
                                ->end()
                            ->end()
                            ->scalarNode('generatorClass')
                                ->isRequired()
                                ->validate()
                                ->ifTrue(function($value) {return !class_exists($value,true);})
                                    ->thenInvalid('Class not found as annotation container generator [%s]')
                                ->ifTrue(function($value) {
                                        $reflection = new \ReflectionClass($value);
                                        return !$reflection->isSubclassOf(
                                            '\Nucleus\Bundle\CoreBundle\DependencyInjection\IAnnotationContainerGenerator'
                                        );
                                    })
                                    ->thenInvalid('Class [%s] must implement [Nucleus\Bundle\CoreBundle\DependencyInjection\IAnnotationContainerGenerator]')
                                ->end()
                            ->end()
                         ->end()
                    ->end()
                ->end()
            ->end();

        return $treeBuilder;
    }