Constructor initialization.

@method initialize
182424
function(attributes, options){
      var t = this;
      t.fileWatchers = {};

      // Instance level constants (can be overridden in sub-classes)
      t.CONST = t.CONST || CONST;

      // Call parent constructor
      TreeProbe.prototype.initialize.apply(t, arguments);

      // Assume callback responsibility.
      options.asyncInit = true;
      var callback = options.callback;

      // Set the root path from the Server's DB
      t.rootPath = Path.join(UI.Server.currentServer.get('siteDbPath'), t.CONST.objectClass);

      // Build the full path to the directory, possibly routed to an app DB
      var path = t.get('path'),
          parts = path.replace(/^[\\\/]/,'').split('/'),
          appName = parts[0] === 'app' ? parts[1] : null;
      if (appName && UI.Server.currentServer.apps[appName]) {

        // Build the dirPath from the module DB
        var appDef = UI.Server.currentServer.apps[appName];
        parts.splice(0,2);
        t.dirPath = Path.join(appDef.moduleDir, 'site_db', t.CONST.objectClass, parts.join('/'));
      }
      else {

        // Normal path - under the site_db/Page directory
        t.dirPath = Path.join(t.rootPath, path);
      }

      // Go straight to sync (no stat/watch) if the path is the app directory
      if (t.get('path') === '/app') {
        return t.sync(callback);
      }

      // Watch the directory and synchronize objects in it.
      // This is called after the FS.stat (below)
      var watchSync = function() {
        t.dirWatcher = FS.watch(t.dirPath, {persistent:false}, function(type){
          t.sync();
        });

        // Synchronize this object with the directory.
        t.sync(callback);
      }

      // Make sure the directory exists
      FS.stat(t.dirPath, function(error, stat) {

        // Create the directory if it doesn't exist
        if (error && error.code == 'ENOENT') {
          FileProbe.mkdir_r(t.dirPath, '0777', function(error) {
            if (error) {
              return callback(error);
            }
            // Created
            return watchSync();
          });
          return;
        }

        // Other error than directory doesn't exist
        if (error) {
          return callback(error);
        }

        // This shouldn't happen
        if (!stat.isDirectory()) {
          return callback({err: 'Not a directory: ' + t.dirPath});
        }

        // Continue
        return watchSync();
      });
    }
894117
public function init() 
    {
        parent::init();
        if (!isset($this->container)):
            $this->container = 'div';
        endif;
        if (!is_array($this->containerOptions)):
            $this->containerOptions = [];
        endif;
        if (!is_array($this->pluginOptions)):
            $this->pluginOptions = [];
        endif;
        $this->initOptions();
        ob_start();
    }
110990
public function init()
    {
        $this->assets = array(
            'js' => YII_DEBUG ? 'foundation/foundation.clearing.js' : 'foundation.min.js'
        );
        Html::addCssClass($this->htmlOptions, Enum::CLEARING_THUMBS);
        ArrayHelper::addValue('data-clearing', 'data-clearing', $this->htmlOptions);
        parent::init();
    }
1259417
@PostConstruct
  public void initialize() {

    if (this.initializationState.setInitializing()) {
      if (this.visibility == null) {
        this.visibility = VisibilityModifier.PUBLIC;
      }
      this.initializationState.setInitialized();
    }
  }
1154767
function initialize() {
    if (aurelia_pal_1.isInitialized) {
        return;
    }
    let pal = nodejs_pal_builder_1.buildPal();
    aurelia_pal_1.initializePAL((platform, feature, dom) => {
        Object.assign(platform, pal.platform);
        Object.setPrototypeOf(platform, pal.platform.constructor.prototype);
        Object.assign(dom, pal.dom);
        Object.setPrototypeOf(dom, pal.dom.constructor.prototype);
        Object.assign(feature, pal.feature);
        Object.setPrototypeOf(feature, pal.feature.constructor.prototype);
        (function (global) {
            global.console = global.console || {};
            let con = global.console;
            let prop;
            let method;
            let empty = {};
            let dummy = function () { };
            let properties = 'memory'.split(',');
            let methods = ('assert,clear,count,debug,dir,dirxml,error,exception,group,' +
                'groupCollapsed,groupEnd,info,log,markTimeline,profile,profiles,profileEnd,' +
                'show,table,time,timeEnd,timeline,timelineEnd,timeStamp,trace,warn').split(',');
            while (prop = properties.pop())
                if (!con[prop])
                    con[prop] = empty;
            while (method = methods.pop())
                if (!con[method])
                    con[method] = dummy;
        })(platform.global);
        if (platform.global.console && typeof console.log === 'object') {
            if (typeof console['debug'] === 'undefined') {
                console['debug'] = this.bind(console['log'], console);
            }
            ['log', 'info', 'warn', 'error', 'assert', 'dir', 'clear', 'profile', 'profileEnd'].forEach(function (method) {
                console[method] = this.bind(console[method], console);
            }, Function.prototype.call);
        }
        Object.defineProperty(dom, 'title', {
            get: function () {
                return pal.global.document.title;
            },
            set: function (value) {
                pal.global.document.title = value;
            }
        });
        Object.defineProperty(dom, 'activeElement', {
            get: function () {
                return pal.global.document.activeElement;
            }
        });
        Object.defineProperty(platform, 'XMLHttpRequest', {
            get: function () {
                return pal.global.XMLHttpRequest;
            }
        });
    });
}
792438
function init(g) {
    g.nodes().forEach(function(u) {
      var attrs = g.node(u);
      attrs.y = _rankSep * attrs.rank;
      if (attrs.width) {
        attrs.width = parseInt(attrs.width);
      } else {
        attrs.width = attrs.dummy ? _edgeWidth : _nodeWidth;
      }
    });
  }
1013522
public function init() {

		parent::init();

		$this->modelService = isset( $this->modelService ) ? $this->modelService : $this->controller->modelService;
	}
646427
function init() {
      if ($el.hasClass('horizontal')){
        scrollDirection = 'horiz';
        scrollOffsetAttr = 'scrollLeft';
        sizeAttr = 'width';
        offsetAttr = 'left';
      }

      $el.prepend('<div class="tse-scrollbar"><div class="drag-handle"></div></div>');
      $scrollbarEl = $el.find('.tse-scrollbar');
      $dragHandleEl = $el.find('.drag-handle');

      if (options.wrapContent) {
        $contentEl.wrap('<div class="tse-scroll-content" />');
      }
      $scrollContentEl = $el.find('.tse-scroll-content');

      resizeScrollContent();

      if (options.autoHide) {
        $el.on('mouseenter', flashScrollbar);
      }

      $dragHandleEl.on('mousedown', startDrag);
      $scrollbarEl.on('mousedown', jumpScroll);
      $scrollContentEl.on('scroll', onScrolled);

      resizeScrollbar();

      $(window).on('resize', function() {
        recalculate();
      });

      if (!options.autoHide) {
        showScrollbar();
      }
    }
704378
final public function init()
    {
        $this->sourcePath = $this->getSourcePath();
        $this->depends    = [CpAsset::class];

        $this->js  = $this->getScripts();
        $this->css = $this->getStylesheets();

        parent::init();
    }
825339
public function initialize()
    {
        parent::initialize();

        //Loads helpers
        $this->loadHelper('MeTools.BBCode');
        $this->loadHelper('MeTools.Breadcrumbs');
        $this->loadHelper('RecaptchaMailhide.Mailhide');
        $this->loadHelper('MeCms.Widget');
    }
979763
public function init()
    {
        parent::init();
        $classes = array('table');
        if (!empty($this->type)) {
            if (is_string($this->type)) {
                $this->type = explode(' ', $this->type);
            }

            foreach ($this->type as $type) {
                $classes[] = 'table-' . $type;
            }
        }
        TbHtml::addCssClass($classes, $this->htmlOptions);
    }
1206411
function init() {  // {{{2
/**
 * Class constructor
 *
 * @method constructor
 */

  O.inherited(this)();

  this.setMaxListeners(Consts.coreListeners);

  this.subjectState = this.SUBJECT_STATE.INIT;

  this.homeTimeOffset = 0;

  this.lastTid = 0;  // {{{3
  /**
   * Autoincemental part of last transaction id created in this shard and peer
   *
   * @property lastTid
   * @type Number
   */

  this.lastEid = 0;  // {{{3
  /**
   * Autoincremental part of last entry id created in this shard and peer
   *
   * @property lastEid
   * @type Number
   */

  this.cache = {};  // {{{3
  /**
   * Object containing entries
   *
   * @property cache
   * @type Object
   */

  // }}}3

  return true;
}
788047
function initialise() {

	    DOMReady(function () {

	    	for (var i = 0; i < 10; i++) {
				createCommandHtml(true);
	    	}

			// var rellax = new Rellax('.rellax');

	    });

	    document.addEventListener('webkitAnimationEnd', onAnimationEnded);

	}
862655
public function init() {
        if (null != $this->url) {
            $this->pluginOptions['url'] = $this->url;
        } else {
            $this->pluginOptions['url'] = Url::to([$this->view->context->id.'/nodeMove']);
        }

		parent::init();
		$this->registerAssets();

        Html::addCssClass($this->options, 'dd');
		echo Html::beginTag('div', $this->options);

        if (null != $this->query) {
            $this->items = $this->prepareItems($this->query);
        }
		if (count($this->items) === 0) {
			echo Html::tag('div', '', ['class' => 'dd-empty']);
		}
	}
730913
function init(config) {
            Object.keys(config).forEach(function (property) {
                this[property] = config[property];
            }, this);
        }
398
function initialize() {
  var flags = [];

  Object.keys( levels ).forEach(function( type, level ) {
    var method = type.toLowerCase();
    exports[ method ] = log.bind( exports, type, level, false );
    exports[ method ].json = log.bind( exports, type, level, true );
    if ( new RegExp( '\\b' + type + '\\b', 'i' ).test( env ) ) {
      flags.push( level );
    }
  });

  loglevel = Math.min.apply( Math, flags );
}
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();
    }