Init
@contructor
774611
function() {

        if ( !ModelUtil.instance && !getContext('modelUtil') ) {
            self.models             = self.models || {}; // used when getModel(modelName) is called
            self.entities           = {};
            self.entitiesCollection = {}; // used when getEntity(entityName) is called - handles entity relations
            self.files              = {};
            ModelUtil.instance      = self;

            setContext('modelUtil', ModelUtil.instance);

            return self
        } else {
            //if (!ModelUtil.instance) {
            //    ModelUtil.instance = getContext('modelUtil')
            //}
            //self = ModelUtil.instance;
            //ModelUtil.instance = getContext('modelUtil');
            //ModelUtil.instance = ModelUtil.instance || getContext('modelUtil');
            //self = merge(self, ModelUtil.instance, true);
            // return self
            return ModelUtil.instance || getContext('modelUtil')
        }
    }
1164672
function init(config) {
            this.storage = {};
            if (typeof config !== 'undefined') {
                Object.keys(config).forEach(function (property) {
                    this[property] = config[property];
                }, this);
            }

            if(this.processors instanceof Array === false){
                this.processors = [].concat(this.constructor.processors);
            }
			if(this.preprocessors instanceof Array === false){
                this.preprocessors = [].concat(this.constructor.preprocessors);
            }
        }
869794
private function buildOnConstruct() {
        $content = '';
        foreach($this->getFields() as $field) {
            if(in_array($field->getType(), array('Date', 'DateTime'))) {
                $content .= '		$this->set' . ucfirst($field->getShortName()) . '(new ' . $field->getType() . '($this->get' . ucfirst($field->getShortName()) . '()));
';
            }
        }
        $content .= '		parent::onConstruct();';
        $method = new Object\Method();
        $method->setAccess('public');
        $method->setDescription('Used to Construct an instance');
        $method->setName('onConstruct');
        $method->setReturnType('void');
        $method->setContent($content);
        $this->getAbstractClass()->addMethod($method);
    }
838689
protected function init()
    {
        if ($this->container) {
            return;
        }

        $this->container = new Container();
        $this->connectionPool = new Pool();
        $this->cacheComponent = new CacheComponent();

        $this->container->instance(Pool::class, $this->connectionPool);
        $this->container->instance(CacheComponentInterface::class, $this->cacheComponent);
        Ioc::setContainer($this->container);

        static::$singleton = $this;
    }
103099
public function _construct()
    {
        $this->_init(
            \Dotdigitalgroup\Email\Model\Contact::class,
            \Dotdigitalgroup\Email\Model\ResourceModel\Contact::class
        );
    }
9971
private function init()
    {
        foreach ($this->configs as $webmaster => $content) {
            $this->add($webmaster, $content);
        }
    }
291885
public static function _init()
	{
		// select the current builder
		$builder_class = \ClanCats::$config->get( 'ui.builder', "\\UI\\Builder_Bootstrap" );
		static::$builder = new $builder_class;
		
		// load the ui configuration
		static::$config = \CCConfig::create( 'ui' );
	}
34269
public function _construct()
    {
        $this->_init(
            \Dotdigitalgroup\Email\Model\Review::class,
            \Dotdigitalgroup\Email\Model\ResourceModel\Review::class
        );
    }
1237339
function init() {
    var debugFile = path.join(__dirname, 'debug.js');

    if (debug) {
        if (fs.existsSync(debugFile)) { fs.unlinkSync(debugFile); }
        debugFD = fs.openSync(debugFile, 'a');
    }

    getFileList(modelsPath).forEach(defineModel);
    processAllRelations(defineRelation);

    if (debug) {
        fs.closeSync(debugFD);
    }
}
1016215
protected function _init()
    {
        if (!isset($this->_ob) ||
            ($this->_ob->md5 != hash('md5', $this->key))) {
            switch ($this->cipher) {
            case 'cbc':
                $this->_ob = new Horde_Crypt_Blowfish_Php_Cbc($this->key);
                break;

            case 'ecb':
                $this->_ob = new Horde_Crypt_Blowfish_Php_Ecb($this->key);
                break;
            }
        }
    }
85165
public function init() {
		foreach ( self::$modules as $key => $module_class ) {
			if ( class_exists( $module_class ) ) {
				// Use this syntax instead of $module_class::get_instance()
				// for PHP 5.2 compatibility.
				self::$active_modules[ $key ] = call_user_func( [ $module_class, 'get_instance' ] );
			}
		}
	}
1216916
public function init()
    {
        $this->loadResources();
        $this->prepRequestData();

        // initialize the output component by loading it, the component will register
        // handlers on construction
        $this["output.service"];

        $this["logger.service"]("System")->info("Application initialized");

        $this["hooks.service"]->setParams([$this]);
        $this["hooks.service"]->exec("application.init.after");
    }
1133992
public static function initialize()
    {
        if (static::$isConfigurationLoaded === true) {
            return;
        }
        
        foreach (static::$handlers as $handler) {
            EventManager::getInstance()->addEventHandler($handler[0], $handler[1], $handler[2], $handler[3]);
        }

        static::$isConfigurationLoaded = true;
    }
730913
function init(config) {
            Object.keys(config).forEach(function (property) {
                this[property] = config[property];
            }, this);
        }
1051971
private static function init() {
        if (self::$logDebug === null) {
            $loglevel        = Logger::getLogLevel(__CLASS__);
            self::$logDebug  = ($loglevel <= L_DEBUG );
            self::$logInfo   = ($loglevel <= L_INFO  );
            self::$logNotice = ($loglevel <= L_NOTICE);
        }
    }
491097
public static function init()
    {
        $properties = self::getProperties();

        self::$container = new Container();
        self::$container->setProperties($properties);
        self::$container->autoloadServerAnnotation();

        $definition = self::getServerDefinition();
        self::$container->addDefinitions($definition);
        self::$container->initBeans();
    }
288110
public function init()
    {
        if (empty($this->getOwningTarget()->getName())) {
            $project       = $this->getProject();
            $buildFileRoot = $project->getProperty('phing.file');
            $buildList     = $this->getBuildList($buildFileRoot);
            $targets       = array();

            foreach ($buildList as $buildFile => $info) {
                if (is_file($buildFile)) {
                    $target = new Target();
                    $target->setName('help-'.$info['name']);

                    $task = clone $this;
                    $task->setBuildFile($buildFile);
                    $task->setOwningTarget($target);

                    $target->addTask($task);
                    $this->project->addTarget('help-'.$info['name'], $target);

                    $targets[$buildFileRoot][] = array(
                        'name'        => $target->getName(),
                        'visibility'  => 'hidden',
                        'description' => $buildList[$buildFile]['description'],
                     );
                }

                if ($buildFile === $buildFileRoot) {
                    $project->setDefaultTarget($target->getName());
                }
            }//end foreach

            $this->project->helpTargets = $targets;
        }//end if

    }