All Classes and Interfaces
Class
Description
The abstract class
AbstractExceptionHandler handles all exceptions by managing a list of
ExceptionListener objects and updating them when an exception event occursA generic implementation of the Observer pattern This abstract class implements the
Observer and ActionCommand interfaces, providing a basic framework for observers
in the Observer design patternThe class
AbstractSubject is an implementation of the Subject interface This
class encapsulates the observable object and notifies all registered observers when the
observable changesThe interface
ActionCommand represents a command that can be executed Implementations of
this interface encapsulate a specific action that can be triggeredThe class
ChatMessage represents a message in a chat application It implements the
Message interface and is serializableThe class
ChatRoom represents a chat room where users can send and receive messages It
extends AbstractSubject and implements Subject, Room, and
SerializableThe class
ChatRoomService manages the creation and retrieval of chat rooms It provides a
way to obtain a ChatRoom based on an observable message and a room nameThe class
ChatRoomUser represents a user in a chat room who can send and receive messages
This class implements Observer to observe messages in the chat room,
ActionCommand to define actions when a message is received, and Serializable for
serialization supportThe class
DefaultExceptionHandler provides a default implementation for handling
exception events It extends AbstractExceptionHandler and propagates exception events to
the registered listenersThe
EventListener interface is for receiving events The class that is interested in
processing an event implements this interface, and the object created with that class is
registered with a component using the component's addEventListener method When the
event occurs, that object's appropriate method is invokedThe class
EventObject serves, as its name suggests, as an event object It encapsulates
the source object on which an event initially occurredThe interface
EventSource represents a source of events It provides methods to manage
event listeners and to fire events to those listenersThe class
EventSubject is an implementation of the EventSource interface It
represents a subject that can have multiple event listeners and can fire events to themThe class
ExceptionEvent represents an event that encapsulates a Throwable object
It acts as an observable event that can be passed to listeners interested in handling exceptionsThe listener interface for receiving exception events The class that is interested in processing
an exception event implements this interface, and the object created with that class is
registered with a component using the component's
addExceptionListener method When
the exception event occurs, that object's appropriate method is invokedThe class
ExceptionMessage represents a message object used in exception handling It
encapsulates information such as a properties key and value, an ID, and additional data that may
be related to the exceptionThe class
ExceptionMessages manages a collection of exception messages organized by keys
It allows adding, retrieving, and removing exception messages based on specific keysThe class
ExceptionObservers is a singleton that manages a list of
ExceptionListener objects It allows classes to register and unregister for exception
events, and notifies registered listeners when an exception event occursThe Interface
Invitation represents an invitation to join a chat room It defines the
methods to retrieve the sender, recipient, and the room associated with the invitation, as well
as methods to check if the invitation has been accepted and if the denial is visible to the
senderThe interface
IUser represents a user in a chat application It provides methods to manage
the user's identity, including getting and setting the application user, retrieving the user's
unique identifier, and obtaining the user's nameThe interface
Message represents a message that can be sent in a chat application It
provides methods for getting and setting the value of the messageThe listener interface for receiving message events The class that is interested in processing a
message implements this interface, and the object created with that class is registered with a
component using the component's
addMessageListener method When the message event
occurs, the appropriate method of that object is invokedThe Class
MessageObject represents an object that contains a message event It
encapsulates the source object on which the message event initially occurredThe class
MessageRoomModelBean represents a model for a message in a chat room It
includes details such as the chat room name, the user who sent the message, the message content,
and any associated data, as well as the date the message was createdThe Interface
MessageSource represents a source that can send messages to registered
listeners It provides methods for adding, removing, and notifying MessageListener objectsThe class
MessageSubject represents a subject in the Observer design pattern for handling
messages It maintains a list of MessageListener objects that are notified when a message
is firedThe Interface
Observer represents an observer in the Observer design pattern It defines a
contract for objects that should be notified of changes in an observable subjectThe interface
Room represents a chat room in which users can participate It provides
methods to retrieve the list of users in the chat room, the history of messages sent in the room,
and to check whether the room is secureThe class
StringMessage represents a message that contains a string value It implements
the Message interface and provides methods to get and set the string valueThe interface
Subject represents the "subject" in the Observer design pattern The subject
is the object whose state changes are being observed by one or more observers When the state of
the subject changes, the observers are notified of the change