Build and send an initialization message.
 @note make sure +@connection.local_entry+ is sendable before calling this
 @return [void]
18436
def send_initialization_message
      entry_properties = @connection.objects.convert_object_to_properties(@connection.local_entry)
      message = Messages::Initialization.build(entry: entry_properties)
      @connection.messenger.send(message)
    end
315754
static public function initialize()
    {
        if (!self::$_instance) {
            $cn = get_called_class();
            self::$_instance = new $cn();
            self::$_instance->name = substr($cn, 0, strpos($cn, '\\'));
        }
        self::$_instance->boot();
        
        if (Rails::cli())
            Rails::console()->run();
    }
638310
function init() {
			if (!oInitPromise) {
				oInitPromise = new Promise(function(resolve, reject) {

					oWorker = new window.Worker(WORKER.URL);

					// listen for confirmation from worker
					oWorker.addEventListener('message', function(oEvent) {
						var oData = oEvent.data;
						resolve(oData && oData[WORKER.RESPONSE_FIELDS.DONE] === true);
					}, false);

					// instruct the worker to fetch the index data
					oWorker.postMessage({
						"cmd": WORKER.COMMANDS.INIT,
						"bIsMsieBrowser": !!Device.browser.msie
					});
				});
			}

			return oInitPromise;
		}
442024
def create
      @msg = get_message
      if @msg.valid?
        @msg.remote_ip = request.remote_ip
        @msg.send_message
        flash[:success] = 'Your message has been sent.'
        redirect_to main_app.root_url
      else
        render 'new'
      end
    end
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)
264479
public function init()
    {
        $this->initAutoloader($this->swiftBasePath);

        $this->transport = Swift_SmtpTransport::newInstance($this->host, $this->port, $this->security);
        $this->transport->setUsername($this->username)->setPassword($this->password);

        parent::init();
    }
52259
def _init_event_data(params)
      # set state
      @state = {
        reloaded: !params[:evnt].nil?,
        saved: true
      }

      # set options
      initial_options = {
        exceptions: false,
        silent: false
      }
      default_options = _safe_default_options || {}
      params_options = params[:_options] || {}
      @options = initial_options.merge(default_options)
                                .merge(params_options)

      # set name and attributes
      @name = _safe_name
      @attributes = _safe_attributes

      # set payload
      payload = params.reject { |k, _v| k[0] == '_' }
      @payload = @state[:reloaded] ? payload : _generate_payload(payload)

      # set extras
      @extras = {}
      extras = params.select { |k, _v| k[0] == '_' }
      extras.each { |k, v| @extras[k[1..-1].to_sym] = v }
    end
633861
protected function _init() {
		$this->connection = $this->connection ?: new Memcached();
		$this->connection->addServers($this->_formatHostList($this->_config['host']));

		if ($this->_config['scope']) {
			$this->connection->setOption(Memcached::OPT_PREFIX_KEY, "{$this->_config['scope']}:");
		}
	}
355036
public function init()
    {
        if ($this->isEnabled()) {
            $this->client = \PHPDaemon\Clients\IRC\Pool::getInstance();
        }
    }
93035
def _init_connection(self):
        
        try:
            # We are changing self.is_ready: lock it up!
            self._lock.acquire()

            response = bytearray(22)
            self._send_raw(BRIDGE_INITIALIZATION_COMMAND)
            self._socket.recv_into(response)
            self._wb1 = response[19]
            self._wb2 = response[20]
            self.is_ready = True
        except (socket.error, socket.timeout):
            # Connection timed out, bridge is not ready for us
            self.is_ready = False
        finally:
            # Prevent deadlocks: always release the lock
            self._lock.release()

        return self.is_ready
318768
public function Initialize() {
      // You've got to be signed in to send private messages.
      if (!Gdn::Session()->IsValid())
         Redirect('/entry/signin?Target='.urlencode($this->SelfUrl));

      if ($this->DeliveryType() == DELIVERY_TYPE_ALL) {
         $this->Head = new HeadModule($this);
         $this->AddJsFile('jquery.js');
         $this->AddJsFile('jquery.livequery.js');
         $this->AddJsFile('jquery.form.js');
         $this->AddJsFile('jquery.popup.js');
         $this->AddJsFile('jquery.gardenhandleajaxform.js');
         $this->AddJsFile('jquery.autogrow.js');
         $this->AddJsFile('jquery.tokeninput.js');
         $this->AddJsFile('global.js');
         $this->AddJsFile('conversations.js');
      }
      
      $this->AddCssFile('style.css');
      $this->AddCssFile('conversations.css');
      parent::Initialize();
   }
1220003
def init(self):
        
        if not self.call_delegate('will_start_debug_core', core=self):
            if self.halt_on_connect:
                self.halt()
            self._read_core_type()
            self._check_for_fpu()
            self.build_target_xml()
            self.sw_bp.init()

        self.call_delegate('did_start_debug_core', core=self)
989690
def send!

      # Send the request
      request = HTTParty.post(self.target, :body => {
        :payload => generate_payload.to_json
      })

      unless request.code.eql? 200
        false
      end

      true

    end
981877
function Message () {

  if (!(this instanceof Message)) {
    if (typeof arguments[0] === 'object' && arguments[0] instanceof Message) {
      debug('message is a message so return it');
      return arguments[0];
    }
    else {
      debug('creating new message and initializing with arguments');
      var m = new Message();
      Message.prototype.initialize.apply(m, slice.call(arguments));
      return m;
    }
  }
  else {
    this.isMessage = true;
    if (arguments.length) {
      debug('initializing with arguments');
      Message.prototype.initialize.apply(this, slice.call(arguments));
    }
  }

}
695799
def initialize():
    
    global is_initialized
    # Add the custom multi-constructor
    yaml.add_multi_constructor('!obj:', multi_constructor)
    yaml.add_multi_constructor('!pkl:', multi_constructor_pkl)
    yaml.add_multi_constructor('!import:', multi_constructor_import)
    yaml.add_multi_constructor('!include:', multi_constructor_include)

    def import_constructor(loader, node):
        value = loader.construct_scalar(node)
        return try_to_import(value)

    yaml.add_constructor('!import', import_constructor)
    yaml.add_implicit_resolver(
        '!import',
        re.compile(r'(?:[a-zA-Z_][\w_]+\.)+[a-zA-Z_][\w_]+')
    )
    is_initialized = True
1163435
function init(entry) {  // {{{2
/**
 * Socket constructor
 *
 * @param entry {Object} Media player entry
 *
 * @method constructor
 */

  if ('playbackSocket' in entry) {
    throw O.log.error(this, 'DUPLICIT_PLAYBACK', entry.toString());
  }

  entry.playbackSocket = this;
  this.entry = entry;

  entry.shard.track(entry.dval.playback, this);
}
1106831
def init():
    '''  '''
    globals()["sock"] = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    globals()["sockfd"] = globals()["sock"].fileno()