Create new MUCLight.

@param roomName
@param occupants
@throws Exception
172323
public void create(String roomName, List<Jid> occupants) throws Exception {
        create(roomName, null, null, occupants);
    }
402550
public static GraqlQueryException insertMultipleProperties(
            Statement varPattern, String property, Object value1, Object value2
    ) {
        String message = "a concept `%s` cannot have multiple properties `%s` and `%s` for `%s`";
        return create(message, varPattern, value1, value2, property);
    }
577889
@Override
    void createEntry(int hash, K key, V value, int bucketIndex) {
	HashMapPro.Entry<K, V> old = table[bucketIndex];
	Entry<K, V> e = new Entry<K, V>(hash, key, value, old);
	table[bucketIndex] = e;
	e.addBefore(header);
	size++;
    }
119683
def join_room(self, room_id_or_alias):
        
        if not room_id_or_alias:
            raise MatrixError("No alias or room ID to join.")

        path = "/join/%s" % quote(room_id_or_alias)

        return self._send("POST", path)
272038
protected void initInputReaders() throws Exception {
		final int numInputs = getNumTaskInputs();
		final MutableReader<?>[] inputReaders = new MutableReader<?>[numInputs];

		int currentReaderOffset = 0;

		for (int i = 0; i < numInputs; i++) {
			//  ---------------- create the input readers ---------------------
			// in case where a logical input unions multiple physical inputs, create a union reader
			final int groupSize = this.config.getGroupSize(i);

			if (groupSize == 1) {
				// non-union case
				inputReaders[i] = new MutableRecordReader<IOReadableWritable>(
						getEnvironment().getInputGate(currentReaderOffset),
						getEnvironment().getTaskManagerInfo().getTmpDirectories());
			} else if (groupSize > 1){
				// union case
				InputGate[] readers = new InputGate[groupSize];
				for (int j = 0; j < groupSize; ++j) {
					readers[j] = getEnvironment().getInputGate(currentReaderOffset + j);
				}
				inputReaders[i] = new MutableRecordReader<IOReadableWritable>(
						new UnionInputGate(readers),
						getEnvironment().getTaskManagerInfo().getTmpDirectories());
			} else {
				throw new Exception("Illegal input group size in task configuration: " + groupSize);
			}

			currentReaderOffset += groupSize;
		}
		this.inputReaders = inputReaders;

		// final sanity check
		if (currentReaderOffset != this.config.getNumInputs()) {
			throw new Exception("Illegal configuration: Number of input gates and group sizes are not consistent.");
		}
	}
408070
def join(self, room_str):
        """"""
        response = self.user_api.join_room(room_str)
        return self._mkroom(response["room_id"])
497841
public void setRooms(java.util.Collection<RoomData> rooms) {
        if (rooms == null) {
            this.rooms = null;
            return;
        }

        this.rooms = new java.util.ArrayList<RoomData>(rooms);
    }
663823
def create_room(room):
    """"""

    if room.custom_server:
        return

    def _create_room(xmpp):
        muc = xmpp.plugin['xep_0045']
        muc.joinMUC(room.jid, xmpp.requested_jid.user)
        muc.configureRoom(room.jid, _set_form_values(xmpp, room))

    current_plugin.logger.info('Creating room %s', room.jid)
    _execute_xmpp(_create_room)
5899
public void setRoomConfigs(HashMap<String, String> customConfigs)
            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        setRoomConfigs(null, customConfigs);
    }
918040
private void createOrUpdateKeyspace(List<TableInfo> tableInfos) throws Exception
    {
        KsDef ksDef = onCreateKeyspace(); // create keyspace event.
        createColumnFamilies(tableInfos, ksDef); // create column family event.
    }
300571
private CreateRoomSettings createRoomSettings(ApiRoom agent) {
        validateRoomAgentClass(agent);
	    CreateRoomSettings settings = new CreateRoomSettings();
        settings.setName(agent.getName());
        settings.setPassword(agent.getPassword());
        settings.setDynamic(agent.isDynamic());
        settings.setGame(agent.isGame());
        settings.setHidden(agent.isHidden());
        settings.setMaxSpectators(agent.getMaxSpectators());
        settings.setMaxUsers(agent.getMaxUsers());
        settings.setMaxVariablesAllowed(agent.getMaxRoomVariablesAllowed());
        settings.setRoomProperties(agent.getProperties());
        settings.setGroupId(agent.getGroupdId());
        settings.setUseWordsFilter(agent.isUseWordsFilter());
        settings.setAutoRemoveMode(SFSRoomRemoveMode.fromString(agent.getRemoveMode().name()));
        if(agent.getExtension() != null) 
            settings.setExtension(new RoomExtensionSettings(agent.getExtension().getName(), agent.getExtension().getClazz()));
        return settings;
	}
266143
public Response addOutcast(String roomName, String jid) {
		return restClient.post("chatrooms/" + roomName + "/outcasts/" + jid, null, new HashMap<String, String>());
	}
1276399
@SuppressWarnings("unchecked")
    public StorableIndex<S> buildPkIndex(String... propertyNames) {
        Map<String, ? extends StorableProperty<S>> map = getAllProperties();
        int length = propertyNames.length;
        StorableProperty<S>[] properties = new StorableProperty[length];
        Direction[] directions = new Direction[length];
        for (int i=0; i<length; i++) {
            String name = propertyNames[i];
            char c = name.charAt(0);
            Direction dir = Direction.fromCharacter(c);
            if (dir != Direction.UNSPECIFIED || c == Direction.UNSPECIFIED.toCharacter()) {
                name = name.substring(1);
            } else {
                // Default to ascending if not specified.
                dir = Direction.ASCENDING;
            }
            if ((properties[i] = map.get(name)) == null) {
                throw new IllegalArgumentException("Unknown property: " + name);
            }
            directions[i] = dir;
        }
        return new StorableIndex<S>(properties, directions, true, true);
    }
179462
@Override
    public RoomInfo room(String name) {
        this.room = CommandUtil.getSfsRoom(name, extension);
        return this;
    }
145622
public JSONObject updateRoomMetadata(String company, String roomId, HashMap<String, String> params) throws JSONException {
        return oClient.put("/messages/v3/" + company + "/rooms/" + roomId, params);
    }
927215
public void appendEntries(LogEntry... newEntries) {
        int lastTerm = lastLogOrSnapshotTerm();
        long lastIndex = lastLogOrSnapshotIndex();

        if (!checkAvailableCapacity(newEntries.length)) {
            throw new IllegalStateException("Not enough capacity! Capacity: " + logs.getCapacity()
                    + ", Size: " + logs.size() + ", New entries: " + newEntries.length);
        }

        for (LogEntry entry : newEntries) {
            if (entry.term() < lastTerm) {
                throw new IllegalArgumentException("Cannot append " + entry + " since its term is lower than last log term: "
                        + lastTerm);
            }
            if (entry.index() != lastIndex + 1) {
                throw new IllegalArgumentException("Cannot append " + entry
                        + " since its index is bigger than (lastLogIndex + 1): " + (lastIndex + 1));
            }
            logs.add(entry);
            lastIndex++;
            lastTerm = Math.max(lastTerm, entry.term());
        }
    }
177370
public ResponseWrapper addChatRoomMember(long roomId, String... members)
            throws APIConnectionException, APIRequestException {
        return _chatRoomClient.addChatRoomMember(roomId, members);
    }