Create the default space in this context.

@return the created space.
503707
public EventSpace postConstruction() {
		this.spaceRepository.postConstruction();
		this.defaultSpace = createSpace(OpenEventSpaceSpecification.class, this.defaultSpaceID);
		if (this.defaultSpace == null) {
			// The default space could have been created before thanks to Hazelcast,
			// thus createSpace returns null because the space already exist,
			// in this case we return the already existing default space stored in the SpaceRepository
			this.defaultSpace = (OpenEventSpace) this.spaceRepository
					.getSpace(new SpaceID(this.id, this.defaultSpaceID, OpenEventSpaceSpecification.class));
		}
		return this.defaultSpace;
	}
921613
public Configuration create() {
        Configuration configuration;
        try {
            InputStream stream = null;
            try {
                // Search the user configuration
                stream = Utils.openResourceStream(DEFAULT_USER_CONFIGURATION_FILE);

                // If user configuration not found then use default
                if (stream == null) {
                    stream = Utils.openResourceStream(DEFAULT_CONFIGURATION_FILE);
                }

                if (stream != null) {
                    configuration = create(stream);
                } else {
                    throw new TextProcessorFactoryException("Can't find or open default configuration resource.");
                }
            } finally {
                if (stream != null) {
                    stream.close();
                }
            }

            Properties properties = new Properties();

            // Load properties from .property file
            InputStream propertiesStream = null;
            try {
                propertiesStream = Utils.openResourceStream(DEFAULT_PROPERTIES_FILE);
                if (propertiesStream != null) {
                    properties.load(propertiesStream);
                }
            } finally {
                if (propertiesStream != null) {
                    propertiesStream.close();
                }
            }

            // Load properties from xml file
            InputStream xmlPropertiesStream = null;
            try {
                xmlPropertiesStream = Utils.openResourceStream(DEFAULT_PROPERTIES_XML_FILE);
                if (xmlPropertiesStream != null) {
                    properties.loadFromXML(xmlPropertiesStream);
                }
            } finally {
                if (xmlPropertiesStream != null) {
                    xmlPropertiesStream.close();
                }
            }

            if (!properties.isEmpty()) {
                Map<String, CharSequence> params = new HashMap<String, CharSequence>();
                params.putAll(configuration.getParams());
                for (Map.Entry<Object, Object> entry : properties.entrySet()) {
                    Object key = entry.getKey();
                    if (key != null) {
                        params.put(key.toString(), entry.getValue().toString());
                    }
                }
                configuration.setParams(params);
            }
        } catch (IOException e) {
            throw new TextProcessorFactoryException(e);
        }

        return configuration;
    }
420690
public Properties<PartitionPlan<T>> getOrCreateProperties()
   {
      List<Node> nodeList = childNode.get("properties");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new PropertiesImpl<PartitionPlan<T>>(this, "properties", childNode, nodeList.get(0));
      }
      return createProperties();
   }
716618
public VisTable createTable () {
		VisTable table = new VisTable(true);

		table.left();

		boolean spacingValid = false;
		for (int i = 0; i < order.length(); i++) {
			char ch = order.charAt(i);

			if (ignoreSpacing == false && ch == ' ' && spacingValid) {
				table.add().width(sizes.buttonBarSpacing);
				spacingValid = false;
			}

			Button button = buttons.get(ch);

			if (button != null) {
				table.add(button);
				spacingValid = true;
			}
		}

		return table;
	}
170114
public boolean removeSpace() {
	int start = pos;
	while (pos < text.length && lcText[pos] == ' ') {
	    pos++;
	}
	return (start < pos);
    }
930901
public String createNamespace(String name) {
        String requestId = Long.toString(System.nanoTime());

        CreatePublicDnsNamespaceRequest publicDnsNamespaceRequest =
                new CreatePublicDnsNamespaceRequest().withCreatorRequestId(requestId)
                        .withName(name)
                        .withDescription("test");
        CreatePublicDnsNamespaceResult clientResult = getDiscoveryClient().createPublicDnsNamespace(publicDnsNamespaceRequest);
        String operationId = clientResult.getOperationId();
        GetOperationResult opResult = checkOperation(operationId);
        return opResult.getOperation().getTargets().get("NAMESPACE");
    }
918015
private static String getSpaces(int n) {

        // avoid negative NegativeArraySizeException in case uri is missing
        n = Math.max(n, 0);
        StringBuffer result = new StringBuffer(n);
        for (; n > 0; n--) {
            result.append(' ');
        }
        return result.toString();
    }
56565
private Extensions getOrCreate() {

		// Create table
		geoPackage.createExtendedRelationsTable();

		Extensions extension = getOrCreate(EXTENSION_NAME,
				ExtendedRelation.TABLE_NAME, null, EXTENSION_DEFINITION,
				ExtensionScopeType.READ_WRITE);

		return extension;
	}
806238
public void makeSpace(int sizeNeeded) {
        int needed = count + sizeNeeded - buf.length;
        if (needed > 0) {
            bump(needed);
        }
    }
376490
public static function createDefault(): self
    {
        return new self([
            new Type("any", "[^/]+"),
            new Type("alnum", "[a-zA-Z0-9]+"),
            new Type("alpha", "[a-zA-Z]+"),
            new Type("date", "\d{4}-\d{2}-\d{2}"),
            new Type("digit", "\d"),
            new Type("number", "\d+"),
            new Type("word", "\w+"),
        ]);
    }
856505
public SpaceDimension spaceDimension() throws Exception {
    String[]  	items;

    items = getItems();
    return new ListSpaceDimension(0, items.length - 1, items, getProperty());
  }
529093
public function create()
    {
        /**
         * @var StateLine $stateLine
         */
        $classNamespace = $this->getEntityNamespace();
        $stateLine = new $classNamespace();
        $stateLine->setCreatedAt($this->now());

        return $stateLine;
    }
1335975
def _get_space(self):
        
        assert 'space' in self.config, 'The search space is NOT configured!'
        
        space_config = self.config['space']
        constraint_config = self.config['constraints']
        from ..core.task.space import Design_space
        return Design_space.fromConfig(space_config, constraint_config)
1200146
public <S extends io.sarl.lang.core.Space> S createSpace(SpaceID spaceID,
			Class<? extends SpaceSpecification<S>> spec, Object... creationParams) {
		synchronized (getSpaceRepositoryMutex()) {
			if (!this.spaces.containsKey(spaceID)) {
				return createSpaceInstance(spec, spaceID, true, creationParams);
			}
		}
		return null;
	}
919388
@NonNull
  public static CreateTypeStart createType(
      @Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier typeName) {
    return new DefaultCreateType(keyspace, typeName);
  }
1070124
public Keyspace build() {
        final AstyanaxContext<Keyspace> context = new AstyanaxContext.Builder()
            .forCluster(clusterName)
            .forKeyspace(keyspaceName)
            .withAstyanaxConfiguration(new AstyanaxConfigurationImpl()
                .setDiscoveryType(RING_DESCRIBE)
            )
            .withConnectionPoolConfiguration(new ConnectionPoolConfigurationImpl("ConnectionPool")
                .setPort(thriftPort)
                .setSeeds(hosts)
            )
            .withConnectionPoolMonitor(new CountingConnectionPoolMonitor())
            .buildKeyspace(ThriftFamilyFactory.getInstance());

        context.start();

        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public synchronized void run() {
                context.shutdown();
            }
        });

        return context.getClient();
    }
38764
public T getDefaultExtension() {
        getExtensionClasses();
        if (null == cachedDefaultName || cachedDefaultName.length() == 0 || "true".equals(cachedDefaultName)) {
            return null;
        }
        return getExtension(cachedDefaultName);
    }