Initializer for this `Routes` class.

@param {Ravel} ravelInstance - Instance of a Ravel app.
@param {Object} koaRouter - Instance of koa-router.
@private
971511
function initRoutes (ravelInstance, koaRouter) {
  const proto = Object.getPrototypeOf(this);
  // handle class-level @mapping decorators
  const classMeta = Metadata.getClassMeta(proto, '@mapping', Object.create(null));
  for (const r of Object.keys(classMeta)) {
    buildRoute(ravelInstance, this, koaRouter, r, classMeta[r]);
  }

  // handle methods decorated with @mapping
  const meta = Metadata.getMeta(proto).method;
  const annotatedMethods = Object.keys(meta);
  for (const r of annotatedMethods) {
    const methodMeta = Metadata.getMethodMetaValue(proto, r, '@mapping', 'info');
    if (methodMeta) {
      buildRoute(ravelInstance, this, koaRouter, r, methodMeta);
    }
  }
}
962458
public static void initInstance(Context context, String meteorServerHostname, boolean useSsl) {
        initInstance(context, meteorServerHostname, sMeteorPort, useSsl);
    }
361343
function init(ctx) {
        var server = ctx.server;
        server.ext('onRequest', checkIfSSL);
        return new Q(ctx);
    }
968408
function aceInitialized(hook, context){
  var editorInfo = context.editorInfo;
  editorInfo.ace_doInsertHeading = _(doInsertHeading).bind(context);
}
1160724
function init (router) {
  router.use((err, req, res, next) => {
    res._headers = res._headers || {}

    next(err)
  })
}
814961
function init(msg) {
      function iFrameLoaded() {
        trigger('iFrame.onload', msg, iframe, undefined, true)
        checkReset()
      }

      function createDestroyObserver(MutationObserver) {
        if (!iframe.parentNode) {
          return
        }

        var destroyObserver = new MutationObserver(function(mutations) {
          mutations.forEach(function(mutation) {
            var removedNodes = Array.prototype.slice.call(mutation.removedNodes) // Transform NodeList into an Array
            removedNodes.forEach(function(removedNode) {
              if (removedNode === iframe) {
                closeIFrame(iframe)
              }
            })
          })
        })
        destroyObserver.observe(iframe.parentNode, {
          childList: true
        })
      }

      var MutationObserver = getMutationObserver()
      if (MutationObserver) {
        createDestroyObserver(MutationObserver)
      }

      addEventListener(iframe, 'load', iFrameLoaded)
      trigger('init', msg, iframe, undefined, true)
    }
1354408
private static function init() {
        self::$routes = new RoutesManager();
        self::$beforeRoutes = new RoutesManager();
        self::$afterRoutes = new RoutesManager();
        self::$errorRoutes = new RoutesManager();
        self::$notFoundRoutes = new RoutesManager();
    }
363070
function initPlugins(router, site) {
  return bluebird.all(module.exports.plugins.map(plugin => {
    return bluebird.try(() => {
      if (typeof plugin === 'function') {
        return plugin(router, pluginDBAdapter, publish, sites, site);
      } else {
        log('warn', 'Plugin is not a function');
        return bluebird.resolve();
      }
    });
  }));
}
131711
public void initialize(UimaContext context)
			throws ResourceInitializationException {

		super.initialize(context);

		this.context = context;

		mLogger = context.getLogger();

		if (mLogger.isLoggable(Level.INFO)) {
			mLogger.log(Level.INFO, "Initializing the CoGrOO annotator.");
		}

		ComponentFactory factory = ComponentFactory.create(new Locale("pt",
				"BR"));
		cogroo = factory.createPipe();
	}
1254219
public final void initActor(UUID uuid, String path, ActorContext context, Mailbox mailbox) {
        this.uuid = uuid;
        this.path = path;
        this.context = context;
        this.mailbox = mailbox;
        this.askPattern = new ActorAskImpl(self());
        this.typedAsk = new TypedAskExtensions(self());
        this.callbackExtension = new CallbackExtension(self());
        this.extensions.add(askPattern);
        this.extensions.add(typedAsk);
        this.extensions.add(callbackExtension);
        this.extensions.add(new RunnableExtension());
    }
104593
function luigiClientInit() {
  /**
   * Save context data every time navigation to a different node happens
   * @private
   */
  function setContext(rawData) {
    for (var index = 0; index < defaultContextKeys.length; index++) {
      var key = defaultContextKeys[index];
      try {
        if (typeof rawData[key] === 'string') {
          rawData[key] = JSON.parse(rawData[key]);
        }
      } catch (e) {
        console.info(
          'unable to parse luigi context data for',
          key,
          rawData[key],
          e
        );
      }
    }
    currentContext = rawData;
  }

  function setAuthData(eventPayload) {
    if (eventPayload) {
      authData = eventPayload;
    }
  }

  window.addEventListener('message', function messageListener(e) {
    if ('luigi.init' === e.data.msg) {
      setContext(e.data);
      setAuthData(e.data.authData);
      luigiInitialized = true;
      _callAllFns(_onInitFns, currentContext.context);
    } else if ('luigi.navigate' === e.data.msg) {
      setContext(e.data);
      if (!currentContext.internal.isNavigateBack) {
        window.location.replace(e.data.viewUrl);
      }

      // execute the context change listener if set by the microfrontend
      _callAllFns(_onContextUpdatedFns, currentContext.context);

      window.parent.postMessage(
        {
          msg: 'luigi.navigate.ok'
        },
        '*'
      );
    } else if ('luigi.auth.tokenIssued' === e.data.msg) {
      setAuthData(e.data.authData);
    }

    if ('luigi.navigation.pathExists.answer' === e.data.msg) {
      var data = e.data.data;
      pathExistsPromises[data.correlationId].resolveFn(data.pathExists);
      delete pathExistsPromises[data.correlationId];
    }

    if ('luigi.ux.confirmationModal.hide' === e.data.msg) {
      const data = e.data.data;
      const promise = promises.confirmationModal;
      if (promise) {
        data.confirmed ? promise.resolveFn() : promise.rejectFn();
        delete promises.confirmationModal;
      }
    }

    if ('luigi.ux.alert.hide' === e.data.msg) {
      const { id } = e.data;
      if (id && promises.alerts[id]) {
        promises.alerts[id].resolveFn(id);
        delete promises.alerts[id];
      }
    }
  });

  window.parent.postMessage(
    {
      msg: 'luigi.get-context'
    },
    '*'
  );
}
300717
function init(ctx) {
  context = ctx;
  projectRoot = ctx.opts.projectRoot;
  projectName = getProjectName(ctx, projectRoot);
  iosPlatformPath = path.join(projectRoot, 'platforms', 'ios');

  var wkWebViewPluginPath = path.join(projectRoot, 'plugins', WKWEBVIEW_PLUGIN_NAME);
  isWkWebViewEngineUsed = isDirectoryExists(wkWebViewPluginPath) ? 1 : 0;
}
751231
function init(ctx) {
        var server = ctx.server;

        if (!privateKey) {
            throw new Error('Please set config.security.token.privateKey');
        }

        server.ext('onPreAuth', validateToken);

        return new Q(ctx);
    }
1359062
public void initialize() {
        try {
            if (tidyInstance == null) {
                tidyInstance = new Tidy();
                tidyInstance.setXHTML(true);
                tidyInstance.setShowWarnings(false);
                tidyInstance.setQuiet(true);
                tidyInstance.setEscapeCdata(true);
                tidyInstance.setTidyMark(false);

                if (tidyConfiguration != null) {
                    tidyInstance.setConfigurationFromFile(tidyConfiguration.getFile().getAbsolutePath());
                }
            }
        } catch (IOException e) {
            throw new CitrusRuntimeException("Failed to initialize XHTML tidy instance");
        }
    }
459299
function init(options = {}, handlebars) {
  const opts = deepExtend({}, defaults, options);
  normalizePaths(opts);
  opts.handlebars = handlebars || Handlebars.create();
  return Promise.resolve(opts);
}
738024
def __initialize_instance(self):
        
        config = self.config

        # Initialize instance of the Authentication class
        self.instance.auth = self.authentication_class(self.app, config=config)

        init_handlers = (
            handlers if config.auth_mode() else auth_mode_agnostic_handlers
        )

        for handler in init_handlers:
            if handler.keys is None:
                self.__check_method_in_auth(handler.name, handler.exception)
            else:
                if all(map(config.get, handler.keys)):
                    self.__check_method_in_auth(
                        handler.name, handler.exception
                    )

        for handler in init_handlers:
            if handler.name in self.kwargs:
                method = self.kwargs.pop(handler.name)
                setattr(self.instance.auth, handler.name, method)
246767
function init(msg, done) {
  var config = {
    context: opts.context,
    adapter: opts.adapter,
    routes: opts.routes,
    auth: opts.auth,
    options: opts.options
  }

  setServer.call(this, config, done)
}