Set the room type.
        :param room_type:
487223
def set_room_type(self, room_type):
        
        if not isinstance(room_type, RoomType):
            raise DaftException("room_type should be an instance of RoomType.")
        self._query_params += str(QueryParam.ROOM_TYPE) + str(room_type)
745725
def enter_room(self, sid, room, namespace=None):
        
        return self.server.enter_room(sid, room,
                                      namespace=namespace or self.namespace)
1367781
public void setLedType(final LedType LED_TYPE) {
        if (ledType == LED_TYPE) {return;}

        ledType = LED_TYPE;
        final boolean LED_WAS_ON = currentLedImage.equals(ledImageOn) ? true : false;
        flushImages();
        ledImageOff = create_LED_Image(getWidth(), 0, ledColor, ledType);
        ledImageOn = create_LED_Image(getWidth(), 1, ledColor, ledType);

        currentLedImage = LED_WAS_ON == true ? ledImageOn : ledImageOff;

        repaint();
    }
1367042
def __set_config_value(self, key, value):
        """"""

        self.check_owner()
        params = {"room": self.room_id, "config": to_json({key: value})}
        resp = self.conn.make_api_call("setRoomConfig", params)
        if "error" in resp:
            raise RuntimeError(f"{resp['error'].get('message') or resp['error']}")
        return resp
77906
def channels_set_description(self, room_id, description, **kwargs):
        """"""
        return self.__call_api_post('channels.setDescription', roomId=room_id, description=description, kwargs=kwargs)
998511
def set_room_alias(self, room_id, room_alias):
        
        data = {
            "room_id": room_id
        }

        return self._send("PUT", "/directory/room/{}".format(quote(room_alias)),
                          content=data)
287091
def set_room_name(self, name):
        """"""
        try:
            self.client.api.set_room_name(self.room_id, name)
            self.name = name
            return True
        except MatrixRequestError:
            return False
763244
public void setType(final Type type) {
		getOrCreateComponentModel().type = type == null ? Type.TABLE : type;
	}
614780
def SetDocumentType(self, document_type):
    
    self._document_type = document_type
    logger.debug('Elasticsearch document type: {0:s}'.format(document_type))
1062054
def set_variable_type(index, type)
      case type
      when :continuous
        Cbc.Cbc_setContinuous @ptr, index
      when :integer, :binary
        Cbc.Cbc_setInteger @ptr, index
      else
        fail :type
      end
    end
771869
def __set_rate_type(self, value):
        '''
        
        '''
        if value not in [RATE_TYPE_FIXED, RATE_TYPE_PERCENTAGE]:
            raise ValueError("Invalid rate type.")

        self.__rate_type = value
727362
public void setType(String type) {

        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(type)) {
            m_type = Type.parse(type.trim());
        }
    }
62711
def setTableType(self, tableType, autoRefresh=True):
        
        self.uiRecordTREE.setTableType(tableType)
        self._queryWidget.setTableType(tableType)
        
        if autoRefresh:
            self.setQuery(Q())
1229656
def setTableType(self, tableType):
        
        self.navigator().setTableType(tableType)
        completer = XJoinCompleter(self.navigator().model(), self)
        completer.setCompletionMode(XJoinCompleter.InlineCompletion)
        self.setCompleter(completer)
666179
public function updateRoom(Room $room)
    {
        $this->client->put(sprintf("/v2/room/%s", $room->getId()), $room->toJson());
    }
1308282
function (name, type, opts) {
            opts = opts || {};
            this.operations.push(merge({op:"setColumnType", name:name, type:type}, opts));
        }
516641
def rooms(&callback)
      http(:get, "/rooms.json") do |data, http|
        if data && data[:rooms]
          callback.call(data[:rooms].map{|room| Firering::Room.instantiate(self, room)}) if callback
        else
          logger.error(http.response)
          callback.call([])
        end
      end
    end