Adds the constants for the current app
@param boolean $require Whether to require the files
762468
public function run($require = false) {
		foreach($this->const as $name => $val)
			define(self::nameEncode($name, self::NAMESPACE_SEPERATOR), self::encode($val) );
		
		foreach($this->ini as $name => $val)
			ini_set(self::nameEncode($name, self::INI_SEPERATOR), self::encode($val) );
		
		$GLOBALS["constants"] = $this->public;
		
		if($require)
			foreach($this->require as $file)
				require $file;
	}
151353
public function addRequireDev($require, $version = '*', $overwrite = false)
    {
        if (!isset($this->getRequireDev()->$require) || $overwrite) {
            $this->getRequireDev()->$require = $version;
        }

        return $this;
    }
1085479
public function addRequires(array $requires, $dev = false)
    {
        foreach ($requires as $vendor => $version) {
            if (!isset($vendor) || !isset($version)) {
                continue;
            }

            if (!$dev) {
                $this->addRequire($vendor, $version);
            } else {
                $this->addDevRequire($vendor, $version);
            }
        }

        return $this;
    }
41444
protected function _addExtensions(\OxidEsales\Eshop\Core\Module\Module $module)
    {
        $aModulesDefault = $this->getConfig()->getConfigParam('aModules');
        $aModules = $this->getModulesWithExtendedClass();
        $aModules = $this->_removeNotUsedExtensions($aModules, $module);


        if ($module->hasExtendClass()) {
            $this->validateMetadataExtendSection($module);
            $aAddModules = $module->getExtensions();
            $aModules = $this->_mergeModuleArrays($aModules, $aAddModules);
        }

        $aModules = $this->buildModuleChains($aModules);
        if ($aModulesDefault != $aModules) {
            $this->needCacheClear = true;
            $onlyInAfterFix = array_diff($aModules, $aModulesDefault);
            $onlyInBeforeFix = array_diff($aModulesDefault, $aModules);
            $this->output->writeLn("[INFO] fixing " . $module->getId());
            foreach ($onlyInAfterFix as $core => $ext) {
                if ($oldChain = $onlyInBeforeFix[$core]) {
                    $newExt = substr($ext, strlen($oldChain));
                    if (!$newExt) {
                        //$newExt = substr($ext, strlen($oldChain));
                        $this->output->writeLn("[INFO] remove ext for $core");
                        $this->output->writeLn("[INFO] old: $oldChain");
                        $this->output->writeLn("[INFO] new: $ext");
                        //$this->_debugOutput->writeLn("[ERROR] extension chain is corrupted for this module");
                        //return;
                        continue;
                    } else {
                        $this->output->writeLn("[INFO] append $core => ...$newExt");
                    }
                    unset($onlyInBeforeFix[$core]);
                } else {
                    $this->output->writeLn("[INFO] add $core => $ext");
                }
            }
            foreach ($onlyInBeforeFix as $core => $ext) {
                $this->output->writeLn("[INFO] remove $core => $ext");
            }
            $this->_saveToConfig('aModules', $aModules);
        }
    }
345189
function apply($module = null) {
        if ($module) {
            $path = \Arr::get(\Kohana::modules(), $module);
        } else {
            $path = APPPATH;
        }
        if (!$path) {
            return false;
        }
        $f = $path . 'themes/' . $this->theme . '.php';
        if (file_exists($f)) {
            \Kohana::load($f);
        } else {
            $f = $path . 'themes/' . self::$default . '.php';
            if (file_exists($f)) {
                \Kohana::load($f);
            }
        }
    }
436836
public function addConstant(&$constant)
    {
        if (!isset($this->_constants[$constant->name()])) {
            $this->_constants[$constant->name()] =& $constant;
        }
    }
259187
public static function addDependency($dependency) {
		if (!isset(self::$instance[get_class($dependency)])) {
			self::$instance[get_class($dependency)] = $dependency;
		}
	}
110583
public function setRequired($required)
    {
        if (!in_array(
            $required,
            [
                \Parable\Console\Parameter::PARAMETER_REQUIRED,
                \Parable\Console\Parameter::PARAMETER_OPTIONAL,
            ]
        )) {
            throw new \Parable\Console\Exception('Required must be one of the PARAMETER_* constants.');
        }
        $this->required = $required;
        return $this;
    }
1210480
public function loadModuleDependencies($module)
    {
        $config = $module->getConfig();
        if (isset($config['modules'])) {
            $this->loadConfig($config, $module);
        }
    }
725244
public function addPackage($name, $location = null, $main = null)
    {
        $name = (string)$name;

        if ($name == '') {
            throw new exception\InvalidArgumentException('The require.js package name must not be empty');
        }

        if (!$location && !$main) {
            $this->packages[$name] = $name;
            return $this;
        }

        $this->packages[$name] = [
            'name' => $name,
        ];

        if ($location) {
            $this->packages[$name]['location'] = (string)$location;
        }

        if ($main) {
            $this->packages[$name]['main'] = (string)$main;
        }

        return $this;
    }
58563
function setDependencies(\assegai\Server $server, ModuleContainer $modules)
	{
        $this->server = $server;
        $this->modules = $modules;
	}
63509
public function withRequired(bool $required): self
    {
        $metadata = clone $this;
        $metadata->required = $required;

        return $metadata;
    }
978818
public function setRequired(bool $required) : Component
    {
        if ($required) {
            $this->getTag()->setAttribute('required', 'required');
        } else {
            $this->getTag()->removeAttribute('required');
        }

        return parent::setRequired($required);
    }
1269108
public function loadFiles(array $files, $append = false, $namespace = true, $strict = true)
    {
        $this->initializeFileLoader();
        $this->fileLoader->addFiles($files);
        $data = $this->fileLoader->process($namespace, $strict);
        $this->hydrate($data, $append);
    }
1304309
public function addRequirements(array $requirements)
    {
        if ($requirements) {
            foreach ($this->routes as $route) {
                $route->addRequirements($requirements);
            }
        }
    }
159562
public function setRequired($required) {
		if(!empty($required))
			$this->validation[] = new Validation\Required;
		$this->_attributes["required"] = "";	
	}
987945
public boolean addOrderedRequire(Require require) {
    if (!orderedRequires.contains(require)) {
      orderedRequires.add(require);
      return true;
    }
    return false;
  }