Create a new EJSHome instance.
508487
public EJSHome create(BeanMetaData beanMetaData)
                    throws RemoteException
    {
        J2EEName name = beanMetaData.j2eeName;
        HomeRecord hr = beanMetaData.homeRecord;

        StatelessBeanO homeBeanO = null;
        EJSHome result = null;
        try {
            result = (EJSHome) beanMetaData.homeBeanClass.newInstance();

            homeBeanO = (StatelessBeanO) beanOFactory.create(container, null, false);
            homeBeanO.setEnterpriseBean(result);
        } catch (Exception ex) {
            FFDCFilter.processException(ex, CLASS_NAME + ".create", "90", this);
            throw new InvalidEJBClassNameException("", ex);
        }

        homeBeanO.reentrant = true;
        hr.beanO = homeBeanO; //LIDB859-4

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "created new home bean", name);

        return result;
    }
776860
def create_instance(self, plugin_type, plugin_name, **instance_kwargs):
        """"""
        plugin_type = self._get_plugin_type(plugin_type)
        return plugin_type.create_instance(plugin_name, **instance_kwargs)
222723
def create(self, columns=None, type_map=None, overwrite=False):
        """"""
        # Check already exists #
        if self.count_bytes > 0:
            if overwrite: self.remove()
            else: raise Exception("File exists already at '%s'" % self)
        # If we want it empty #
        if columns is None:
            self.touch()
        # Make the table #
        else:
            self.add_table(self.main_table, columns=columns, type_map=type_map)
729148
def new():
    """"""
    dir_path = os.path.dirname(os.path.realpath(__file__))
    cookiecutter(os.path.join(dir_path, 'historical-cookiecutter/'))
1002731
def create_mackup_home(self):
        """"""
        if not os.path.isdir(self.mackup_folder):
            if utils.confirm("Mackup needs a directory to store your"
                             " configuration files\n"
                             "Do you want to create it now? <{}>"
                             .format(self.mackup_folder)):
                os.makedirs(self.mackup_folder)
            else:
                utils.error("Mackup can't do anything without a home =(")
331781
function createInstance (
  instanceId,
  appCode,
  config,
  data,
  env
) {
  if ( appCode === void 0 ) appCode = '';
  if ( config === void 0 ) config = {};
  if ( env === void 0 ) env = {};

  // Set active instance id and put some information into `instances` map.
  activeId = instanceId;

  // Virtual-DOM object.
  var document = new renderer.Document(instanceId, config.bundleUrl);

  // All function/callback of parameters before sent to native
  // will be converted as an id. So `callbacks` is used to store
  // these real functions. When a callback invoked and won't be
  // called again, it should be removed from here automatically.
  var callbacks = [];

  // The latest callback id, incremental.
  var callbackId = 1;

  instances[instanceId] = {
    instanceId: instanceId, config: config, data: data,
    document: document, callbacks: callbacks, callbackId: callbackId
  };

  // Prepare native module getter and HTML5 Timer APIs.
  var moduleGetter = genModuleGetter(instanceId);
  var timerAPIs = getInstanceTimer(instanceId, moduleGetter);

  // Prepare `jud` instance variable.
  var judInstanceVar = {
    config: config,
    document: document,
    require: moduleGetter
  };
  Object.freeze(judInstanceVar);

  // Each instance has a independent `Vue` variable and it should have
  // all top-level public APIs.
  var subVue = Vue$2.extend({});

  // ensure plain-object components are extended from the subVue
  subVue.options._base = subVue

  // expose global utility
  ;['util', 'set', 'delete', 'nextTick', 'version', 'judVersion', 'config'].forEach(function (name) {
    subVue[name] = Vue$2[name];
  });

  // The function which create a closure the JS Bundle will run in.
  // It will declare some instance variables like `Vue`, HTML5 Timer APIs etc.
  var instanceVars = Object.assign({
    Vue: subVue,
    jud: judInstanceVar,
    __jud_require_module__: judInstanceVar.require // deprecated
  }, timerAPIs);
  callFunction(instanceVars, appCode);

  // Send `createFinish` signal to native.
  renderer.sendTasks(instanceId + '', [{ module: 'dom', method: 'createFinish', args: [] }], -1);
}
8550
protected void addHome(BeanMetaData bmd) throws ContainerException {
        try {
            EJSContainer.homeOfHomes.addHome(bmd); //d200714 d429866.2 F743-26072
        } catch (Throwable ex) {
            ContainerException ex2 = new ContainerException(ex);
            Tr.error(tc, "CAUGHT_EXCEPTION_THROWING_NEW_EXCEPTION_CNTR0035E",
                     new Object[] { ex, ex2.toString() });
            throw ex2;
        }
    }
725050
function createSite() {
  function app(page) { app.handle(page); }
  mixin(app, EventEmitter.prototype, false);
  mixin(app, proto, false);
  app.init();
  return app;
}
1200154
def create(cls, path):
        """"""
        try:
            os.makedirs(path)
        except OSError as e:
            if not e.errno == errno.EEXIST:
                raise
        cmd = [SVNADMIN, 'create', path]
        subprocess.check_call(cmd)
        return cls(path)
753757
def create(provider, names, opts=None, **kwargs):
    '''
    
    '''
    client = _get_client()
    if isinstance(opts, dict):
        client.opts.update(opts)
    info = client.create(provider, names, **kwargs)
    return info
1250865
def cmd_create(self, name, auto=False):
        """"""

        LOGGER.setLevel('INFO')
        LOGGER.propagate = 0

        router = Router(self.database,
                        migrate_dir=self.app.config['PEEWEE_MIGRATE_DIR'],
                        migrate_table=self.app.config['PEEWEE_MIGRATE_TABLE'])

        if auto:
            auto = self.models

        router.create(name, auto=auto)
253190
function(name, title, content, setupTemplate, setup, showDevTools){
        const window = this.createNew(name, title, content, setupTemplate, setup, showDevTools);
        if(window) window.open();
        return window;
    }
182952
def new_plugin(self, config, *args, **kwargs):
        
        typ = None
        obj = None

        # if type is defined, create a new instance
        if 'type' in config:
            typ = config['type']

        # single key is overriding an existing plugin instance
        elif isinstance(config, collections.Mapping) and len(config) == 1:
            # get type name and shift out config to parent level
            (typ, config) = list(config.items())[0]

        obj = self._ctor(typ, config, *args, **kwargs)

        # store if named
        if 'name' in config:
            self._instance[config['name']] = obj
        else:
            # this could dupe on .name, make name=''?
            config['name'] = typ

        return obj
1173397
def setup(app):
    """"""
    app.add_config_value('jsdoc_source_root', '..', 'env')
    app.add_config_value('jsdoc_output_root', 'javascript', 'env')
    app.add_config_value('jsdoc_exclude', [], 'env')
    app.connect('builder-inited', generate_docs)
647634
def new(cls, *args, **kwargs):
        """"""
        new = cls(make_default(getattr(cls, 'spec', {})))
        new.update(args[0] if args and not kwargs else kwargs)
        return new
1116126
function EJS() {
  
  var opts = (app.config.engines && app.config.engines.ejs) || {};
  
  this.options = protos.extend({
    delimiter: '?'
  }, opts);
  
  this.module = ejs;
  this.multiPart = true;
  this.extensions = ['ejs', 'ejs.html'];

}
257829
def CreateConfigHBuilder(env):
    """"""
    action = SCons.Action.Action(_createConfigH,
                                 _stringConfigH)
    sconfigHBld = SCons.Builder.Builder(action=action)
    env.Append( BUILDERS={'SConfigHBuilder':sconfigHBld} )
    for k in list(_ac_config_hs.keys()):
        env.SConfigHBuilder(k, env.Value(_ac_config_hs[k]))