Create a new {@link ComponentManager} for the provided id.

@param namespace the identifier of the component manager
@return a new {@link ComponentManager} instance
543832
private ComponentManager createComponentManager(String namespace)
    {
        String prefix = NamespaceUtils.getPrefix(namespace);

        ComponentManagerFactory componentManagerFactory;
        try {
            componentManagerFactory = this.rootComponentManager.getInstance(ComponentManagerFactory.class, prefix);
        } catch (ComponentLookupException e) {
            componentManagerFactory = this.defaultComponentManagerFactory;
        }

        return componentManagerFactory.createComponentManager(namespace, this.rootComponentManager);
    }
366395
static public function create(string $namespace, string $mosaic = null)
    {
        if (empty($mosaic)) {
            // `namespace` should contain `FQN`
            $fullyQualifiedName = $namespace;
            $splitRegexp = "/([^:]+):([^:]+)/";

            // split with format: `namespace:mosaic`
            $namespace = preg_replace($splitRegexp, "$1", $fullyQualifiedName);
            $mosaic    = preg_replace($splitRegexp, "$2", $fullyQualifiedName);
        }

        if (empty($namespace) || empty($mosaic)) {
            throw new RuntimeException("Missing namespace or mosaic name for \\NEM\\Models\\Mosaic instance.");
        }

        return new static([
            "namespaceId" => $namespace,
            "name" => $mosaic
        ]);
    }
564135
public WebFacesConfigDescriptor addNamespace(String name, String value)
   {
      model.attribute(name, value);
      return this;
   }
399327
public void add(Namespace namespace) {
		if (has(namespace)) {
			get(namespace.getNamespace()).addPaths(namespace.getPaths());
		} else {
			namespace.addPropertyChangeListener(listener);
			set(namespace.getNamespace(), namespace);
		}
	}
102519
private static <T> T createCustomComponent(Class<T> componentType, String componentSpec,
            Map<String, String> configProperties, IPluginRegistry pluginRegistry) throws Exception {
        return createCustomComponent(componentType, componentSpec, configProperties, pluginRegistry, null);
    }
986818
public BshClassManager getClassManager() {
        if (this.classManager != null)
            return this.classManager;
        if (this.parent != null && this.parent != JAVACODE)
            return this.parent.getClassManager();
        this.setClassManager(BshClassManager
                .createClassManager(null/* interp */));
        // Interpreter.debug("No class manager namespace:" +this);
        return this.classManager;
    }
652334
public void useNamespace(SerializerContext serializerContext, String namespace)
	{
		if (namespace != null && namespace.length() > 0)
		{
			if (serializerContext.knownNamespaces == null)
			{
				serializerContext.knownNamespaces = new HashSet<String>(8);
			}
			serializerContext.knownNamespaces.add(namespace);
		}
	}
762880
function Messenger(namespace, options) {
  if (!(this instanceof Messenger)) {
    return new Messenger(namespace, options);
  }

  if (!namespace) {
    throw new Error('Cannot create Messenger without a namespace');
  }

  events.EventEmitter.call(this);

  this.namespace = namespace;
  this.options = merge(Object.create(Messenger.DEFAULTS), options || {});
  this.socketPath = this._getFileDescriptorPath(this.options.uid);

  this._init();
}
1130398
public JettyServiceBuilder sessionIdManagerFactory(
            Function<? super Server, ? extends SessionIdManager> sessionIdManagerFactory) {
        requireNonNull(sessionIdManagerFactory, "sessionIdManagerFactory");
        this.sessionIdManagerFactory = sessionIdManagerFactory;
        return this;
    }
623503
public ComponentVisitor createtVisitor(SessionWrapper session, TargetMetaDef targetMetaDef) {
		if (session != null)
			return createtSessionVisitor(session, targetMetaDef);
		else
			return new NoSessionProxyComponentVisitor(componentVisitor, targetMetaRequestsHolder);

	}
256912
function createModel (namespace) {
  const model = (namespace) ? { namespace: namespace } : {}
  model.models = {}
  model.reducers = {}
  model.effects = {}
  model.subscriptions = {}
  model.state = {}

  return {
    start: function () {
      return model
    },
    state: function (value) {
      mutate(model.state, value)
    },
    reducer: function (key, value) {
      model.reducers[key] = value
    },
    subscription: function (key, value) {
      model.subscriptions[key] = value
    },
    effect: function (key, value) {
      model.effects[key] = value
    }
  }
}
620967
function ConnectionManager(namespace) {
  this.namespace = namespace;
  this.clients = new ArrayKeys({
    identifier: 'id'
  });

  var reconnecting = false;
  var self = this;

  if (! reportingActive) {
    reportingActive = true;

    setInterval(function __report() {
      self.clients.forEachRecord(function (client) {
        var count = client.references.getCount();

        if ((count > 0) && ((typeof client.isConnected !== 'function') || (! client.isConnected())) && (! reconnecting)) {
          debug('client ' + client.id + ' is disconnected, but reference count: ' + count + ', reconnecting...');

          var scopes   = client.references.getIdentifiers();
          var scope    = client.references.getRecord(scopes[0]);
          reconnecting = true;

          client.connect.call(buildScope(scope, client), function (err, c) {
            if (err) {
              debug('failed reconnecting: ', err);
              throw new Error(err);
            }
            debug('client successfully reconnected.');
            client.connection = c;
            client = registerListeners(scope, client);
            reconnecting = false;
          });

          for (var i = 1, len = scopes.length; i < len; i++) {
            client = registerListeners(client.references.getRecord(scopes[i]), client);
          }
        }
      });
    }, 60000);
  }
}
299441
protected ComponentContainer createContainer(@Nullable ComponentContainer parent) {
    if (parent == null) {
      return new ComponentContainer();
    }
    return parent.createChild();
  }
1113180
public static ClientInterface create(
            HostMessenger messenger,
            CatalogContext context,
            ReplicationRole replicationRole,
            Cartographer cartographer,
            InetAddress clientIntf,
            int clientPort,
            InetAddress adminIntf,
            int adminPort,
            SslContext SslContext) throws Exception {

        /*
         * Construct the runnables so they have access to the list of connections
         */
        final ClientInterface ci = new ClientInterface(
                clientIntf, clientPort, adminIntf, adminPort, context, messenger, replicationRole, cartographer,
                SslContext);

        return ci;
    }
928455
protected Component newAddComponent() {
        return new PaletteButton("addButton") {
            private static final long serialVersionUID = 1L;

            @Override
            protected void onComponentTag(ComponentTag tag) {
                super.onComponentTag(tag);
                tag.getAttributes().put("onclick", getAddOnClickJS());
            }
        };
    }
1319321
public void createNamespace() {
        Map<String, String> namespaceAnnotations = annotationProvider.create(session.getId(), Constants.RUNNING_STATUS);
        if (namespaceService.exists(session.getNamespace())) {
            //namespace exists
        } else if (configuration.isNamespaceLazyCreateEnabled()) {
            namespaceService.create(session.getNamespace(), namespaceAnnotations);
        } else {
            throw new IllegalStateException("Namespace [" + session.getNamespace() + "] doesn't exist and lazily creation of namespaces is disabled. "
            + "Either use an existing one, or set `namespace.lazy.enabled` to true.");
        }
    }
151911
public WebFacesPartialResponseDescriptor addNamespace(String name, String value)
   {
      model.attribute(name, value);
      return this;
   }