---

CAVERNdb_sharedState_c Class Reference

#include <CAVERNdb_sharedState_c.hxx>

Inheritance diagram for CAVERNdb_sharedState_c::

List of all members.

Public Methods
	CAVERNdb_sharedState_c ()
	Class constructor.
	CAVERNdb_sharedState_c (CAVERNdb_client_c *dbclient, char *path, char *key)
virtual	~CAVERNdb_sharedState_c ()
	Class destructor.
bool	isSharingEnabled ()
	Returns the sharing status of this state.
void	enableSharing ()
	Sets the sharing enabled flag to TRUE.
void	disableSharing ()
	Sets the sharing enabled flag to FALSE.
int	refresh ()
virtual void	update (CAVERNmisc_subject_c *subj)
Protected Methods
virtual int	packAndSendState ()=0
virtual int	unpackState (char *data)=0
Protected Attributes
CAVERNnet_datapack_c	_packer
	data packing object.
CAVERNdb_client_c*	_dbclient
	pointer to a database client which will make the transmissions.
bool	_sharingEnabled
	flag for indicating whether or not sharing is enabled.
char*	_path
	path name in the database for storing this state.
char*	_key
	key name in the database for storing this state.

---

Detailed Description

Encapsulates a shared state to be maintained between multiple users. This class provides a base abstract class from which to derives shared state information which multiple users encounter. This state needs to be managed by a database client in order to maintain consistency, but the client itself is external to the scope of the state. This state is associated with a particular path and key that should not change throughout the life of the state.

Updates are handled through the user of the subject-observer pattern. The shared state observes the client, so when new data arrives, it will unpack the state information provided that sharing is enabled. Sharing is initially disabled for initialization purposes, but can be enabled and disabled later as required.

Subclasses of the shared state have the responsiblity of handling the format of the state for transmission. The state will need to be packed using the packer instance and then sent through the database client. This process is handled by each client because the packing will vary, and the send is dependent upon the size of the packed data. Unpacking state information, however, can be done with just the data itself.

Author:

cavern@evl.uic.edu

Version:

03/26/2000

---

Constructor & Destructor Documentation

CAVERNdb_sharedState_c::CAVERNdb_sharedState_c ( CAVERNdb_client_c * dbclient, char * path, char * key )

Class constructor. Creating an instance of a shared state requires a reference to a database client which already exists. The state will be registered with the client as an observer. Additionally, path and key names are stored within the state for tranmitting and receiving state updates. Parameters: dbclient   pointer to an instantiated database client path   path string to associate with this state key   key string to associate with this state

---

Member Function Documentation

int CAVERNdb_sharedState_c::packAndSendState ( ) [protected, pure virtual]

Packs the object state and transmits it to the database server. The state information must be packed into a data buffer and sent to the database server. The responsibility of packing the state AND sending are placed within this method, so subclasses must put the state information into the database themselves. Returns: result Result of the attempt to send the state to the server

int CAVERNdb_sharedState_c::refresh ( )

Requests a refresh of the data. This method requests the remote state information from the database. It may be useful to call after creating the state.

int CAVERNdb_sharedState_c::unpackState ( char * data ) [protected, pure virtual]

Unpacks the object state from the data buffer. The state receives a data buffer from the client when an update has occurred, but the state information must be unpacked from that buffer. This virtual method must be implemented in any derived subclass to extract the appropriate information from the data buffer received from the client. It is highly advisable to check the data's path, key, and size for security. Parameters: data   character data buffer received from the server

void CAVERNdb_sharedState_c::update ( CAVERNmisc_subject_c * subj ) [virtual]

This method is executed whenever a subject this observer is "watching" calls its notify() method. You can think of this as the equivalent of a callback function. This is a pure virtual function that should be implemented by classes that inherit from the observer. Parameters: CAVERnmisc_subject_c   This is a pointer to the subject that woke us up. We can then access its public member variables and even execute its public methods. Reimplemented from CAVERNmisc_observer_c.

---

The documentation for this class was generated from the following file:

• CAVERNdb_sharedState_c.hxx

---