Create a Space.

@param space CMASpace
@return {@link CMASpace} result instance
@throws IllegalArgumentException if space is null.
971951
public CMASpace create(CMASpace space) {
    assertNotNull(space, "space");

    final CMASystem system = space.getSystem();
    space.setSystem(null);

    try {
      return service.create(space).blockingFirst();
    } finally {
      space.setSystem(system);
    }
  }
898031
public CmsResource getOrCreateFolder(CmsObject cms) throws CmsException {

        CmsResource result = getFolder(cms);
        if (result != null) {
            return result;
        }
        return createFolder(cms);
    }
35353
public Method createFunction(String ns, String name)
    {
        return containsNamespace(ns) ? _functions.get(name) : null;
    }
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);
    }
371860
@NonNull
  public SelfT withKeyspace(@Nullable String keyspaceName) {
    return withKeyspace(keyspaceName == null ? null : CqlIdentifier.fromCql(keyspaceName));
  }
827445
public Cell<C,T> space (Value<C,T> space) {
		spaceTop = space;
		spaceLeft = space;
		spaceBottom = space;
		spaceRight = space;
		return this;
	}
919388
@NonNull
  public static CreateTypeStart createType(
      @Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier typeName) {
    return new DefaultCreateType(keyspace, typeName);
  }
236080
@NonNull
  public static CreateTypeStart createType(@Nullable String keyspace, @NonNull String typeName) {
    return createType(
        keyspace == null ? null : CqlIdentifier.fromCql(keyspace), CqlIdentifier.fromCql(typeName));
  }
468036
@Override
    public Namespace createNamespace(Namespace namespace) {
        requireNotDisposed();
        requireArgument(namespace != null, "null namespace cannot be created.");
        
        if (!_validateQualifier(namespace.getQualifier())) {
            throw new SystemException(new IllegalArgumentException(
                    "Illegal characters found while generating namespace. Cannot generate a namespace with this qualifier."));
        }
        
        if (Namespace.findByQualifier(emf.get(), namespace.getQualifier()) != null) {
            throw new SystemException(new IllegalArgumentException("Namespace already exists. Please try a different namespace."));
        }
        
        namespace = updateNamespace(namespace);
        _logger.debug("Generated namespace {}.", namespace);
        return namespace;
    }
338570
private ImageView createBlankSpace() {
        ImageView view = new ImageView(getContext());
        TableRow.LayoutParams params = new TableRow.LayoutParams(mSwatchLength, mSwatchLength);
        params.setMargins(mMarginSize, mMarginSize, mMarginSize, mMarginSize);
        view.setLayoutParams(params);
        return view;
    }
268512
public static base_response add(nitro_service client, cmpaction resource) throws Exception {
		cmpaction addresource = new cmpaction();
		addresource.name = resource.name;
		addresource.cmptype = resource.cmptype;
		addresource.deltatype = resource.deltatype;
		return addresource.add_resource(client);
	}
34638
String getSpaceIdOrThrow(CMAResource resource, String param) {
    final String spaceId = resource.getSpaceId();
    if (spaceId == null) {
      throw new IllegalArgumentException(String.format(
          "%s must have a space associated.", param));
    }
    return spaceId;
  }
443301
@Path("/{spaceID}")
    @GET
    @Produces(XML)
    public Response getSpace(@PathParam("spaceID") String spaceID,
                             @QueryParam("storeID") String storeID,
                             @QueryParam("prefix") String prefix,
                             @QueryParam("maxResults") long maxResults,
                             @QueryParam("marker") String marker) {
        StringBuilder msg = new StringBuilder("getting space contents(");
        msg.append(spaceID);
        msg.append(", ");
        msg.append(storeID);
        msg.append(", ");
        msg.append(prefix);
        msg.append(", ");
        msg.append(maxResults);
        msg.append(", ");
        msg.append(marker);
        msg.append(")");

        try {
            log.debug(msg.toString());
            return doGetSpace(spaceID, storeID, prefix, maxResults, marker);

        } catch (ResourceNotFoundException e) {
            return responseNotFound(msg.toString(), e, NOT_FOUND);

        } catch (ResourceException e) {
            return responseBad(msg.toString(), e, INTERNAL_SERVER_ERROR);

        } catch (Exception e) {
            return responseBad(msg.toString(), e, INTERNAL_SERVER_ERROR);
        }
    }
1360401
@Override
    public void createNamespace() {
        // Use a temporary, no-keyspace session
        try (DBConn dbConn = createAndConnectConn(null)) {
            synchronized (m_schemaLock) {
                if (!m_schemaMgr.keyspaceExists(dbConn, m_keyspace)) {
                    m_schemaMgr.createKeyspace(dbConn, m_keyspace);
                }
            }
        }
    }
416291
public static String createKey(final String namespace, final Iterable<String> parts) {
        final List<String> list = new LinkedList<String>();
        if (!"".equals(namespace)) {
            list.add(namespace);
        }
        for (final String part : parts) {
            list.add(part);
        }
        return join(COLON, list);
    }
1129294
@NonNull
  public static CreateKeyspaceStart createKeyspace(@NonNull String keyspaceName) {
    return createKeyspace(CqlIdentifier.fromCql(keyspaceName));
  }
45090
public CMASpaceMembership addRole(CMALink role) {
    if (role == null) {
      throw new IllegalArgumentException("Role cannot be null!");
    }

    if (roles == null) {
      roles = new ArrayList<CMALink>();
    }

    this.roles.add(role);
    return this;
  }