Initialize the association.
513707
async def _init(self):
        
        chunk = InitChunk()
        chunk.initiate_tag = self._local_verification_tag
        chunk.advertised_rwnd = self._advertised_rwnd
        chunk.outbound_streams = self._outbound_streams_count
        chunk.inbound_streams = self._inbound_streams_max
        chunk.initial_tsn = self._local_tsn
        self._set_extensions(chunk.params)
        await self._send_chunk(chunk)

        # start T1 timer and enter COOKIE-WAIT state
        self._t1_start(chunk)
        self._set_state(self.State.COOKIE_WAIT)
917596
def init_relation(self, models, relation):
        
        for model in models:
            model.set_relation(relation, Result(None, self, model))

        return models
328211
public function initialize()
    {
        if (true === $this->hasBeenInitialized) {
            return;
        }

        $this->hasBeenInitialized = true;

        foreach ($this->service as $service) {
            list($serviceClassName, $serviceOptions) = $this->manageServiceData($service);

            $this->serviceInstances[$serviceClassName] = $this->getServiceInstance($serviceClassName, $serviceOptions);
        }
    }
1249605
public function initialize() : void
  {
    $connection = config('database.default');

    Accessor::$appRoot       = config('app.dir');
    UpstartConfig::$database = config("database.connections.{$connection}");

    if (!DB::start()) {
      $this->exception('Could not establish a database connection.');
    }

    $this->loadView();
  }
191543
public function initialize()
    {
        $this->initializeShortAliases();
        $this->initializeDefaultAliases();
        foreach ($this->schemaManager->getSchemaTables() as $table) {
            $this->loadMetadataForTable($table);
        }
        $this->initialized = true;
    }
122625
public function init()
	{
		//validate model is active record
		$this->modelInstance = new $this->targetClass;
		ComponentConfig::isActiveRecord($this->modelInstance, true);
	}
626851
public void initialize() {
		mIsForceStop = false;
		mTagStack.clear();
		mTagValueCache.clear();
		mTagAttrCache.clear();
		mCurrentTagKey = null;
	}
939604
def initialize_attributes(parent, inat)
      write_attribute(:parent, parent)
      write_attribute(:interface, inat)

      # Load the interface attributes associated with this model
      load_interface_attributes(inat)
      populate_relationships(inat)

      # Clear dirty and set as existing
      clear_dirty!
      existing_record!
    end
257296
public function initialize()
    {
        Facade::setContainer($this->container);

        if (null !== $loader = $this->loader) {
            $loader->register();
        }
    }
1181852
private function initialize()
    {
        if ($this->initialized) {
            return;
        }

        if ($this->session->isStarted() && $this->session->get('stack') !== null) {
            $paths = $this->session->get('stack');
            $this->files = $this->hydrateList($paths);
        } else {
            $paths = $this->users->getCurrentUser()['stack'];
            $this->files = $this->hydrateList($paths);
            $this->session->set('stack', $this->persistableList());
        }

        $this->initialized = true;
    }
794581
public function actionInit() : void
    {
        $this->initSURole();
        $config = $this->loadConfig();
        $this->applyConfig($config);
        $this->applyAssignConfig($config);
        $this->addAssignmentsToSu();
        $this->log(true);
    }
1361116
def setup_associates(klass, relation, meta, parent_relation)
      assoc_name =
        if relation.associations.key?(parent_relation)
          parent_relation
        else
          singular_name = Inflector.singularize(parent_relation).to_sym
          singular_name if relation.associations.key?(singular_name)
        end

      if assoc_name
        klass.associates(assoc_name)
      else
        klass.associates(parent_relation)
      end
    end
392432
public function initialize()
	{	
		foreach (array('login', 'apikey', 'field') as $name)
		{
			$this->$name = get_pref('rah_bitly_'.$name);
		}

		$this->field = (int) $this->field;

		if (!$this->login || !$this->apikey || !$this->field)
		{
			return;
		}

		include_once txpath.'/publish/taghandlers.php';

		$this->previous_state();
		register_callback(array($this, 'update'), 'article_saved');
		register_callback(array($this, 'update'), 'article_posted');
	}
200244
protected function initialize()
    {
        $this->id = $this->formatId($this->column);
        $this->group = new Collection();
        $this->name = "{$this->id}-filter-group";

        $this->setupDefaultPresenter();
    }
443383
def init_associations(self, hdr_only=False, prt=sys.stdout):
        """"""
        import timeit
        import datetime
        associations = []
        tic = timeit.default_timer()
        if self.filename is None:
            return associations
        ver = None
        ntgpadobj_make = None
        hdrobj = GpadHdr()
        ifstrm = nopen(self.filename)
        _add_ns = self.godag is not None
        _get_ntgpadvals = self._get_ntgpadvals
        for lnum, line in enumerate(ifstrm, 1):
            # Read data
            if ntgpadobj_make:
                flds = self._split_line(line)
                try:
                    # pylint: disable=not-callable
                    ntgpad = ntgpadobj_make(_get_ntgpadvals(flds, _add_ns))
                    associations.append(ntgpad)
                # pylint: disable=broad-except
                except Exception as inst:
                    import traceback
                    traceback.print_exc()
                    sys.stdout.write("\n  **FATAL: {MSG}\n\n".format(MSG=str(inst)))
                    sys.stdout.write("**FATAL: {FIN}[{LNUM}]:\n{L}\n".format(
                        FIN=self.filename, L=line, LNUM=lnum))
                    for idx, val in enumerate(flds):
                        sys.stdout.write('{I:2} {VAL}\n'.format(I=idx, VAL=val))
                    ## if datobj is not None:
                    ##     datobj.prt_line_detail(sys.stdout, line)
                    sys.exit(1)
            # Read header
            else:
                if line[0] == '!':
                    if ver is None and line[1:13] == 'gpa-version:':
                        ver = line[13:].strip()
                    hdrobj.chkaddhdr(line)
                else:
                    self.hdr = hdrobj.get_hdr()
                    if hdr_only:
                        return associations
                    ntgpadobj_make = self._get_ntgpadnt(ver, _add_ns)._make
        # GPAD file has been read
        prt.write('HMS:{HMS} {N:7,} annotations READ: {ANNO}\n'.format(
            N=len(associations), ANNO=self.filename,
            HMS=str(datetime.timedelta(seconds=(timeit.default_timer()-tic)))))
        return associations
557596
def _init_relationships(self, relationships_arg):
        """"""
        if relationships_arg:
            relationships_all = self._get_all_relationships()
            if relationships_arg is True:
                return relationships_all
            else:
                return relationships_all.intersection(relationships_arg)
        return set()
580404
function initialize()
    {
        if ( !$this->hasMetaData( 'current_step' ) )
        {
            $this->setMetaData( 'current_step', 0 );
        }

        if ( !$this->hasMetaData( 'current_stage' ) )
        {
            $this->setMetaData( 'current_stage', eZWizardBase::STAGE_PRE );
        }
    }