Process power level updates.

 @param room [Room] The room this event came from.
 @param data [Hash{String=>Fixnum}] Power level data, a hash of user IDs
   and their associated power level.
962107
def process_power_levels(room, data)
      data.each do |id, level|
        get_user(id).process_power_level room, level
      end
    end
972923
def publishToMyself(self, roomId, name, data):
        
        self.publishToRoom(roomId, name, data, [self])
227888
def refresh_rooms(self):
        """"""
        for room_id in self.user_api.get_joined_rooms()["joined_rooms"]:
            self._rooms[room_id] = MatrixRoom(room_id, self.user_api)
971780
function( userId ) {

		return this.memory.createRoom( userId )
			   .then( function( id ) {

			   		rooms[ id ] = room( this.memory, id );
			   			
						return promise.resolve( rooms[ id ] );
			   }.bind( this ), function() {

			   		return promise.reject( 'could not get a roomID to create a room' );
			   });
	}
840280
private void onCacheEntryUpdated(ItemData data)
   {
      if (data == null || data instanceof NullItemData)
      {
         return;
      }
      for (WorkspaceStorageCacheListener listener : listeners)
      {
         try
         {
            listener.onCacheEntryUpdated(data);
         }
         catch (RuntimeException e) //NOSONAR
         {
            LOG.warn("The method onCacheEntryUpdated fails for the listener " + listener.getClass(), e);
         }
      }
   }
92551
def update_room_topic(self):
        """"""
        try:
            response = self.client.api.get_room_topic(self.room_id)
            if "topic" in response and response["topic"] != self.topic:
                self.topic = response["topic"]
                return True
            else:
                return False
        except MatrixRequestError:
            return False
1144049
function(user, stage, method){
		switch (method) {
			case 'withinRooms':
			
				var room = user.getRoom();
				if(stageCount(stage, room) == room.size) {
					console.log("Finished syncronising in " + room.name + ". Enough members in stage " + stage);
					
					// Once all members are present start experiment
					for(var key in room.getMembers(true)) {
						user = cloak.getUser(room.getMembers(true)[key].id);
						nextStage(user);
					}
				}
				break;
				
			case 'acrossRooms':
			default:
				if(stageCount(stage) == members.length) {
					console.log("Finished syncronising. Enough members in stage " + stage);

					// Once all members are present start experiment
					for(var key in members) {
						user = cloak.getUser(members[key]);
						nextStage(user);
					}
				}
				break;
		}
	}
1229437
def data=(data)
      raise "not yet used"
      raise "Data nil or invalid" if data.nil? or data.size == 0
      delete_all
      @data = data
      tme = TreeModelEvent.new(0, @data.length-1,:ALL_COLUMNS,  self, :INSERT)
      fire_handler :TREE_MODEL_EVENT, tme
    end
1076106
protected void onRPCComplete(int asyncHandle, String data) {
        IAsyncRPCEvent callback = getCallback(asyncHandle);
        
        if (callback != null) {
            callback.onRPCComplete(asyncHandle, data);
        }
    }
1151027
public void doInference(List data) {
	for (int i = 0; i < data.size(); i++) {
	    Observation obsr = (Observation)data.get(i);
	    
	    classify(obsr);
	}
    }
577500
def update(data)
      headers = @client.make_request(:post, @client.concat_user_path("#{CALL_PATH}/#{id}"), data)[1]
      if headers[:location]
         Client.get_id_from_location_header(headers[:location])
      end
    end
1182468
function(data) {
			data = utils.parseJSON(data);

			var userData = resources.getVocabulary('user') || {};
			resources.setVocabulary(utils.deepMerge(userData, data), 'user');
		}
409897
def process_data(data)
      case data
      when Hash  then Resource.new(agent, data)
      when Array then data.map { |hash| process_data(hash) }
      when nil   then nil
      else data
      end
    end
142237
function( data ){

            var candidates = data.candidates
                ,pair
                ,targets = this.getTargets()
                ,collisions = []
                ,ret
                ,prevContacts = this.prevContacts || {}
                ,contactList = {}
                ,pairHash = Physics.util.pairHash
                ,hash
                ;

            for ( var i = 0, l = candidates.length; i < l; ++i ){

                pair = candidates[ i ];

                if ( targets === this._world._bodies ||
                    // only check if the members are targeted by this behavior
                    (Physics.util.indexOf( targets, pair.bodyA ) > -1) &&
                    (Physics.util.indexOf( targets, pair.bodyB ) > -1)
                ){
                    ret = checkPair( pair.bodyA, pair.bodyB );

                    if ( ret instanceof Array ){

                        for ( var j = 0, r, ll = ret.length; j < ll; j++ ){
                            r = ret[j];
                            if ( r ){
                                hash = pairHash( pair.bodyA.uid, pair.bodyB.uid );
                                contactList[ hash ] = true;
                                r.collidedPreviously = prevContacts[ hash ];
                                collisions.push( r );
                            }
                        }

                    } else if ( ret ){
                        hash = pairHash( pair.bodyA.uid, pair.bodyB.uid );
                        contactList[ hash ] = true;
                        ret.collidedPreviously = prevContacts[ hash ];

                        collisions.push( ret );
                    }
                }
            }

            this.prevContacts = contactList;

            if ( collisions.length ){

                this._world.emit( this.options.channel, {
                    collisions: collisions
                });
            }
        }
610335
def _mkroom(self, room_id: str) -> Room:
        
        if room_id not in self.rooms:
            self.rooms[room_id] = Room(self, room_id)
        room = self.rooms[room_id]
        if not room.canonical_alias:
            room.update_aliases()
        return room
1082228
def _process_media_status(self, data):
        
        self.status.update(data)

        self.logger.debug("Media:Received status %s", data)

        # Update session active threading event
        if self.status.media_session_id is None:
            self.session_active_event.clear()
        else:
            self.session_active_event.set()

        self._fire_status_changed()
1159956
def update(self, data):
        
        if data:
            _dumps = self._dumps
            zargs = [
                _dumps(x) if (i % 2 == 1) else x
                for y in data.items()
                for i, x in enumerate(reversed(y))
            ]
            return self._client.zadd(self.key_prefix, *zargs)