Return to chapter index

4 Actor Chat

4.1 Defining message classes

case class User(name: String)

case class Subscribe(user: User)

case class Unsubscribe(user: User)

case class Post(msg: String)

case class UserPost(user: User, post: Post)


  

4.2 Processing messages

import scala.actors.Actor

class ChatRoom extends Actor {
  def act() {
    // the actor's behavior
  }
}


val chatRoom = new ChatRoom
chatRoom.start()


class ChatRoom extends Actor {
  def act() {
    while (true) {
      receive {
        case Subscribe(user) =>       // handle subscriptions
        case Unsubscribe(user) =>     // handle unsubscriptions
        case UserPost(user, post) =>  // handle user posts
      }
    }
  }
}


val chatRoom = 
  actor {
    while (true) {
      receive {
        case Subscribe(user) => 
        case Unsubscribe(user) => 
        case UserPost(user, post) => 
      }
    }
  }


var session = Map.empty[User, Actor]

while (true) {
  receive {
    case Subscribe(user) => 
      val sessionUser = 
        actor {
          while (true) {
            self.receive {
              case Post(msg) => // Send message to sender
            }
          }
        }
      session = session + (user -> sessionUser)

      // handle UserPost message
      // handle Unsubscribe message
  }
}


  

4.3 Sending actor messages

val chatRoom = new ChatRoom
chatRoom ! Subscribe(User("Bob"))


var session = Map.empty[User, Actor]

while (true) {
  receive {
    case Subscribe(user) => 
      val subscriber = sender
      val sessionUser = 
        actor {
          while (true) {
            self.receive {
              case Post(msg) => subscriber ! Post(msg)
            }
          }
        }
      session = session + (user -> sessionUser)

    // handle UserPost message
    // handle Unsubscribe message
  }
}


val chatRoom = new ChatRoom
chatRoom !? Subscribe(User("Bob"))


var session = Map.empty[User, Actor]

while (true) {
  receive {
    case Subscribe(user) => 
      val subscriber = sender
      val sessionUser = 
      actor {
        while (true) {
          self.receive {
            case Post(msg) => subscriber ! Post(msg)
          }
        }
     }
     session = session + (user -> sessionUser)
     reply("Subscribed " + user) 
  }
}


chatRoom !? Subscribe(User("Bob")) match {
  case response: String => println(response)
}


val future = chatRoom !! Subscribe(User("Bob"))

// Do useful work
println(future()) // Wait for the future


val sessionUser = actor {
  while (true) {
    self.receiveWithin (1800 * 1000) {
      case Post(msg) => subscriber ! Post(msg)
      case TIMEOUT =>
        room ! Unsubscribe(user)
        self.exit()
    }
  }
}


var session = Map.empty[User, Actor]

def act() {
  while (true) {
    receive {
      case UserPost(user, msg) =>
        for (key <- session.keys; if key != user) {
          session(key) ! msg
        }                     
      // Handle Subscribe message
      // Handle Unsubscribe message
    }
  }
}