Public Instance Methods

 @see APIObject#initialize

 Public Class Methods

 Needed to support creation of new Computer Invitations to set their name.

 @return [JSS::ComputerInvitation]
162082
def create
      new_invitation_id = super

      jss_me = ComputerInvitation.fetch(id: new_invitation_id, name: 'set_by_request')
      @name = jss_me.name
      @invitation_type = jss_me.invitation_type
      @create_account_if_does_not_exist = jss_me.create_account_if_does_not_exist
      @expiration_date_epoch = jss_me.expiration_date_epoch
      @ssh_username = jss_me.ssh_username
      @hide_account = jss_me.hide_account
      @invitation_status = jss_me.invitation_status
      @multiple_uses_allowed = jss_me.multiple_uses_allowed
    end
659522
static function init()
  {
    if (self::$initialized) return;

    self::$initialized = TRUE;

    self::$COFFEE_KEYWORDS  = array_merge(self::$COFFEE_KEYWORDS, array_keys(self::$COFFEE_ALIASES));
    self::$COFFEE_RESERVED  = array_merge(self::$JS_RESERVED, self::$JS_KEYWORDS, self::$COFFEE_KEYWORDS, self::$STRICT_PROSCRIBED);
    self::$JS_FORBIDDEN     = array_merge(self::$JS_KEYWORDS, self::$JS_RESERVED, self::$STRICT_PROSCRIBED);
    self::$INDEXABLE        = array_merge(self::$CALLABLE, self::$INDEXABLE);
    self::$NOT_SPACED_REGEX = array_merge(self::$NOT_REGEX, self::$NOT_SPACED_REGEX);

    Rewriter::init();

    self::$INVERSES         = Rewriter::$INVERSES;
  }
624805
public function init() {
		// Registration class runs Filter::add($this) in __construct.
		$registration = new \Boldgrid\Library\Library\Registration();

		// Update class runs Filter::add($this) in __construct.
		$update = new \Boldgrid\Library\Library\Update();

		// PostNewKey class runs Filter::add($this) in __construct.
		$postNewKey = new \Boldgrid\Library\Library\Key\PostNewKey();

		$pluginChecker = new \Boldgrid\Library\Library\Plugin\Checker();
		$pluginChecker->run();

		Configs::setItem( 'menu-external', new Menu\External() );
		Configs::setItem( 'menu-reseller', new Menu\Reseller() );
		Configs::setItem( 'page-connect', new Page\Connect() );
		Configs::setItem( 'assets', new Asset() );
		new Editor();
	}
717970
function initialize(url) {
    this.socket = Requests[Requests.method](this);

    //
    // Open the socket BEFORE adding any properties to the instance as this might
    // trigger a thrown `InvalidStateError: An attempt was made to use an object
    // that is not, or is no longer, usable` error in FireFox:
    //
    // @see https://bugzilla.mozilla.org/show_bug.cgi?id=707484
    //
    this.socket.open(this.method.toUpperCase(), url, true);

    //
    // Register this as an active HTTP request.
    //
    Requests.active[this.id] = this;
  }
612903
private static function init()
	{
		$classes[] = array('id' => '1', 'name' => 'uppercase', 'regex' => '[A-Z]',                                       'flag' => '1');
		$classes[] = array('id' => '2', 'name' => 'numeric',   'regex' => '[0-9]',                                       'flag' => '1');
		$classes[] = array('id' => '3', 'name' => 'lowercase', 'regex' => '[a-z]',                                       'flag' => '1');
		$classes[] = array('id' => '4', 'name' => 'special',   'regex' => '[!"\'(),-.:;?[`{}#$%&*+<=>@^_|~\]\/\\\]',     'flag' => '1');
		$classes[] = array('id' => '5', 'name' => 'nonalpha',  'regex' => '[!"\'(),\-.:;?[`{}#$%&*+<=>@^_|~\]\/\\\0-9]', 'flag' => '0');
		$classes[] = array('id' => '6', 'name' => 'alpha',     'regex' => '[A-Za-z]',                                    'flag' => '0');

		self::$classes = $classes;
	}
578725
private Object init(Object[] arguments) throws PageException {
	object = Reflector.callConstructor(clazz, arguments);
	isInit = true;
	return object;
    }
1103552
final protected static function initializeMembers()
    {
        try {
            $reflector = new ReflectionClass(static::CONSTANCE_CLASS);
        } catch (ReflectionException $e) {
            throw new Exception\UndefinedClassException(
                static::CONSTANCE_CLASS,
                $e
            );
        }

        if (null === static::CONSTANCE_PATTERN) {
            foreach ($reflector->getConstants() as $key => $value) {
                new static($key, $value);
            }
        } else {
            foreach ($reflector->getConstants() as $key => $value) {
                if (preg_match(static::CONSTANCE_PATTERN, $key)) {
                    new static($key, $value);
                }
            }
        }
    }
949783
function init(properties) {
            this.eventListeners = [];

            if (typeof properties !== 'undefined') {
                Object.keys(properties).forEach(function (property) {
                    this[property] = properties[property];
                }, this);
            }

            return this;
        }
614478
private int[] createInitialLocals() {
        int[] initialLocals = new int[itsMaxLocals];
        int localsTop = 0;
        // Instance methods require the first local variable in the array
        // to be "this". However, if the method being created is a
        // constructor, aka the method is <init>, then the type of "this"
        // should be StackMapTable.UNINITIALIZED_THIS
        if ((itsCurrentMethod.getFlags() & ACC_STATIC) == 0) {
            if ("<init>".equals(itsCurrentMethod.getName())) {
                initialLocals[localsTop++] = TypeInfo.UNINITIALIZED_THIS;
            } else {
                initialLocals[localsTop++] = TypeInfo.OBJECT(itsThisClassIndex);
            }
        }

        // No error checking should be necessary, sizeOfParameters does this
        String type = itsCurrentMethod.getType();
        int lParenIndex = type.indexOf('(');
        int rParenIndex = type.indexOf(')');
        if (lParenIndex != 0 || rParenIndex < 0) {
            throw new IllegalArgumentException("bad method type");
        }
        int start = lParenIndex + 1;
        StringBuilder paramType = new StringBuilder();
        while (start < rParenIndex) {
            switch (type.charAt(start)) {
                case 'B':
                case 'C':
                case 'D':
                case 'F':
                case 'I':
                case 'J':
                case 'S':
                case 'Z':
                    paramType.append(type.charAt(start));
                    ++start;
                    break;
                case 'L':
                    int end = type.indexOf(';', start) + 1;
                    String name = type.substring(start, end);
                    paramType.append(name);
                    start = end;
                    break;
                case '[':
                    paramType.append('[');
                    ++start;
                    continue;
            }
            String internalType =
                descriptorToInternalName(paramType.toString());
            int typeInfo = TypeInfo.fromType(internalType, itsConstantPool);
            initialLocals[localsTop++] = typeInfo;
            if (TypeInfo.isTwoWords(typeInfo)) {
                localsTop++;
            }
            paramType.setLength(0);
        }
        return initialLocals;
    }
807176
function init(names) {  // {{{2
/**
 * Class constructor
 *
 * @method constructor
 */

  this.count = 0;
  this.deps = {};
  this.groups = {};
  this.cb = null;

  if (! names) return;

  this.add(names[0], function(cb) { cb() });
  for (var i = 1; i < names.length; i++) {
    this.add(names[i], names[i-1], function(cb) { cb() });
  }

  return;
}
1316225
private function _initialize()
    {
        $params = $this->getParameters();
        if ($params !== null) {
            for ($i = 0, $paramsCount = count($params); $i < $paramsCount; $i++) {
                if (self::COMMENTS_KEY === $params[$i]->getType()) {
                    $comment = new Comment();
                    $comment->setValue($params[$i]->getValue());
                    $this->_comments[] = $comment;
                }
            }
        }
    }
193047
private function _init()
    {
        // TODO: check if self::$instance is required here or if we can only set
        // decorated object

        // initialize and store the instance of template engine for further access
        self::$instance = Doozr_Loader_Serviceloader::load($this->library, $this->resource);

        // set this instance as decorated object of our generic Facade and
        // so we can access all the base methods of any lib easily!
        $this->setDecoratedObject(self::$instance);
    }
161955
@JRubyMethod
    public static IRubyObject initialize(IRubyObject self, IRubyObject klass, IRubyObject ivars) {
        ((RubyObject)self).fastSetInstanceVariable("@class", klass);
        ((RubyObject)self).fastSetInstanceVariable("@ivars", ivars);
        return self;
    }
63347
private static function initialize()
    {
        if (self::$initialized) return;

        self::$client = \OpenId::getClient();
        self::$version = config('openid.api-version');
        self::$initialized = TRUE;
    }
585257
public function initialize()
    {
        $this->data = new stdClass();
        $this->data->events = [];
        $this->data->media = self::NOTIFICATION_MEDIA;
    }
1247482
public function init()
    {
        $children = array();
        foreach ($this->children as $child_widget) {
            $children[] = $this->remove($child_widget);
        }

        $disclosure = new SwatDisclosure();
        $disclosure->id = $disclosure->getUniqueId();
        $prototype_id = $disclosure->id;

        foreach ($children as $child_widget) {
            $disclosure->add($child_widget);
        }

        $this->add($disclosure);

        parent::init();

        foreach ($this->replicators as $id => $title) {
            $disclosure = $this->getWidget($prototype_id, $id);
            $disclosure->title = $title;
        }
    }
916717
@Override
	@SuppressWarnings("unchecked")
	public void initialize() {
		
		// grab a handle to the hash table from the iteration broker
		if (taskContext instanceof AbstractIterativePactTask) {
			AbstractIterativePactTask<?, ?> iterativeTaskContext = (AbstractIterativePactTask<?, ?>) taskContext;
			String identifier = iterativeTaskContext.brokerKey();
			this.hashTable = (CompactingHashTable<IT1>) SolutionSetBroker.instance().get(identifier);
		} else {
			throw new RuntimeException("The task context of this driver is no iterative task context.");
		}
		
		TaskConfig config = taskContext.getTaskConfig();
		ClassLoader classLoader = taskContext.getUserCodeClassLoader();
		
		TypeSerializer<IT1> solutionSetSerializer = this.hashTable.getBuildSideSerializer();
		TypeSerializer<IT2> probeSideSerializer = taskContext.<IT2>getInputSerializer(0).getSerializer();
		
		TypeComparatorFactory<IT2> probeSideComparatorFactory = config.getDriverComparator(0, classLoader);
		TypeComparator<IT1> solutionSetComparator = this.hashTable.getBuildSideComparator().duplicate();
		this.probeSideComparator = probeSideComparatorFactory.createComparator();
		
		solutionSideRecord = solutionSetSerializer.createInstance();
		probeSideRecord = probeSideSerializer.createInstance();
		
		TypePairComparatorFactory<IT1, IT2> factory = taskContext.getTaskConfig().getPairComparatorFactory(taskContext.getUserCodeClassLoader());
		pairComparator = factory.createComparator21(solutionSetComparator, this.probeSideComparator);
	}