build init method {@link Init}

@return init
500978
public synchronized InitImpl buildInit(final Method initMethod, final boolean isLazy) {
        if (aroundInvokeImpl == null) {
            aroundInvokeImpl = new AroundInvokeImpl(businessObject, null);
        }
        if (pollingManager == null) {
            final TangoCacheManager cacheManager = new TangoCacheManager(name, deviceLock, aroundInvokeImpl);
            pollingManager = new PollingManager(name, cacheManager, attributeList, commandList, minPolling,
                    minCommandPolling, minAttributePolling, cmdPollRingDepth, attrPollRingDepth);
        }
        initImpl = new InitImpl(name, initMethod, isLazy, businessObject, pollingManager);
        return initImpl;
    }
95224
protected function Init()
    {
        $htmlWrap = ContentHtmlWrap::Schema()->ByContent($this->content);
        $this->html = $htmlWrap->GetHtml();
        $this->currentChild = $this->tree->FirstChildOf($this->item);
        return parent::Init();
    }
527140
protected function _initLoader()
    {
        $loader = $this->createProjectClass('Loader', $this->getContainer(), $this->_loaderDirs);

        \MUtil_Model::setSource($loader, true);

        return $loader;
    }
1001072
protected function _init() {
		$config = ['classes' => $this->_classes] + $this->_config;

		try {
			$this->connection = Libraries::instance('socket', $config['socket'], $config);
		} catch(ClassNotFoundException $e) {
			$this->connection = null;
		}
		$this->_responseTypes += [
			'headers' => function($response) { return $response->headers; },
			'body' => function($response) { return $response->body(); },
			'code' => function($response) { return $response->status['code']; }
		];
	}
737412
public function bootstrap()
    {
        if (! $this->runningInConsole && $this->initializeFs()) {
            $this->buildFsTree();
            $this->initialized = true;
        }

        return $this->initialized;
    }
938
public function initializeStructure()
    {
        $structure = [
            'id' => $this->getId(),
            'name' => $this->getName(),
            'description' => $this->getDescription(),
            'manualProgressionAllowed' => $this->manualProgressionAllowed,
            'steps' => [],
        ];

        $this->setStructure(json_encode($structure));

        return $this;
    }
805557
final public function init() {
		if ($this->request_initted)
			return;
		$this->init_request();
		if ($this->auto_shutdown)
			register_shutdown_function([$this, 'shutdown']);
		$this->request_initted = true;
		return $this;
	}
489491
public function init()
    {
        $this->cookiesFile = tempnam(sys_get_temp_dir(), 'WikiPublish.' . uniqid('', true) . '.cookies');

        $this->curl = curl_init();
        if (false === is_resource($this->curl)) {
            throw new BuildException('Curl init failed (' . $this->apiUrl . ')');
        }

        curl_setopt($this->curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($this->curl, CURLOPT_COOKIEJAR, $this->cookiesFile);
        curl_setopt($this->curl, CURLOPT_COOKIEFILE, $this->cookiesFile);
    }
667929
public function _construct()
    {
        $this->_init(
            \Dotdigitalgroup\Email\Model\Catalog::class,
            \Dotdigitalgroup\Email\Model\ResourceModel\Catalog::class
        );
    }
1094194
public function init()
    {
        $this->message = Swift_Message::newInstance(
            null,
            null,
            Config::get('content_type'),
            Config::get('charset')
        )
            ->setFrom(Config::get('addr'), Config::get('name'));

        return $this;
    }
117552
public static function init()
    {
        $files = File::getFolder(CONF_PATH)['file'];
        foreach ($files as $item => $file) {
            if (is_file(CONF_PATH . $file)) {
                $conf = self::load(CONF_PATH . $file);
                if (0 === $item) {
                    self::$config = $conf;
                } else {
                    self::$config[basename($file, EXT)] = $conf;
                }
            }
        }
        return self::$config;
    }
411964
public function initFormats()
    {
        $this->dependencies = new DependencyInjection();
        $this->mixins = new DependencyInjection();
        $this->destructors = new SplObjectStorage();
        $this->formats = [];

        return $this;
    }
857732
public function initialize()
    {
        // Create the application object
        $app = new Application;

        $this->setEnvironment($app);
        $this->registerConfig($app);

        // Handle init config
        $initConfig = $app['config']->load('init');

        if ($initConfig['debug']) {
            Debug::enable();
            $app['debug'] = true;
        }

        return $app;
    }
790462
public function init() {
		$this->_swift['transport'] = \Swift_SmtpTransport::newInstance($this->smtp, $this->port, true === $this->ssl ? 'ssl' : '');
		$this->_swift['transport']->setUsername($this->username);
		$this->_swift['transport']->setPassword($this->password);
		
		$this->_swift['mailer'] = \Swift_mailer::newInstance($this->_swift['transport']);
		
		$this->_swift['message'] = \Swift_message::newInstance();
		
		return $this;
	}
340766
protected function init()
    {
        // build the local matrix just once
        if (empty($this->errorCodeMatrix)) {
            // get type and order from Doozr_Form_Service_Validate so we don't need to define it manually again
            $typeMatrix = Doozr_Form_Service_Validator_Generic::getValidationTypeMatrix();

            // iterate over types and construct error-code-matrix of it
            foreach ($typeMatrix as $type => $order) {
                $this->errorCodeMatrix[$type] = ($order + 1);
            }
        }

        return $this;
    }
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();
    }
597106
public final T build(final boolean init) throws IllegalStateException {
    final T build = build(dependencySet().withoutMandatoryServices().with(services));
    if (init) {
      build.init();
    }
    return build;
  }