Collage
1.7.0
High-performance C++ library for developing object-oriented distributed applications.
|
A distributed object. More...
#include <object.h>
Public Types | |
enum | ChangeType { NONE, STATIC, INSTANCE, DELTA, UNBUFFERED } |
Object change handling characteristics, see Programming Guide. More... | |
Public Types inherited from co::Dispatcher | |
typedef CommandFunc< Dispatcher > | Func |
The signature of the base Dispatcher callback. More... | |
Public Member Functions | |
virtual CO_API | ~Object () |
Destruct the distributed object. More... | |
Data Access | |
CO_API bool | isAttached () const |
CO_API LocalNodePtr | getLocalNode () |
CO_API void | setID (const uint128_t &identifier) |
Set the object's unique identifier. More... | |
CO_API const uint128_t & | getID () const |
CO_API uint32_t | getInstanceID () const |
CO_API bool | isBuffered () const |
CO_API bool | isMaster () const |
Versioning | |
virtual ChangeType | getChangeType () const |
virtual uint64_t | getMaxVersions () const |
Limit the number of queued versions on slave instances. More... | |
virtual CO_API CompressorInfo | chooseCompressor () const |
Return the compressor to be used for data transmission. More... | |
virtual bool | isDirty () const |
Return if this object needs a commit. More... | |
CO_API void | push (const uint128_t &groupID, const uint128_t &objectType, const Nodes &nodes) |
Push the instance data of the object to the given nodes. More... | |
virtual CO_API uint128_t | commit (const uint32_t incarnation=CO_COMMIT_NEXT) |
Commit a new version of this object. More... | |
CO_API void | setAutoObsolete (const uint32_t count) |
Automatically obsolete old versions. More... | |
CO_API uint32_t | getAutoObsolete () const |
virtual CO_API uint128_t | sync (const uint128_t &version=VERSION_HEAD) |
Sync to a given version. More... | |
CO_API uint128_t | getHeadVersion () const |
CO_API uint128_t | getVersion () const |
virtual CO_API void | notifyNewHeadVersion (const uint128_t &version) |
Notification that a new head version was received by a slave object. More... | |
virtual void | notifyNewVersion () |
Notification that a new version was received by a master object. More... | |
Serialization methods for instantiation and versioning. | |
virtual void | getInstanceData (DataOStream &os) |
Serialize all instance information of this distributed object. More... | |
virtual void | applyInstanceData (DataIStream &is) |
Deserialize the instance data. More... | |
virtual void | pack (DataOStream &os) |
Serialize the modifications since the last call to commit(). More... | |
virtual void | unpack (DataIStream &is) |
Deserialize a change. More... | |
Messaging API | |
CO_API ObjectOCommand | send (NodePtr node, const uint32_t cmd, const uint32_t instanceID=CO_INSTANCE_ALL) |
Send a command with optional data to object instance(s) on another node. More... | |
Notifications | |
virtual void | notifyAttach () |
Notify that this object will be registered or mapped. More... | |
virtual void | notifyAttached () |
Notify that this object has been registered or mapped. More... | |
virtual CO_API void | notifyDetach () |
Notify that this object will be deregistered or unmapped. More... | |
virtual void | notifyDetached () |
Notify that this object has been deregistered or unmapped. More... | |
uint32_t | getMasterInstanceID () const |
CO_API NodePtr | getMasterNode () |
CO_API void | removeSlave (NodePtr node, const uint32_t instanceID) |
CO_API void | removeSlaves (NodePtr node) |
void | setMasterNode (NodePtr node) |
void | addInstanceDatas (const ObjectDataIStreamDeque &, const uint128_t &) |
void | setupChangeManager (const Object::ChangeType type, const bool master, LocalNodePtr localNode, const uint32_t masterInstanceID) |
virtual CO_API void | attach (const uint128_t &id, const uint32_t instanceID) |
virtual CO_API void | detach () |
void | transfer (Object *from) |
void | applyMapData (const uint128_t &version) |
void | sendInstanceData (const Nodes &nodes) |
Public Member Functions inherited from co::Dispatcher | |
Dispatcher & | operator= (const Dispatcher &) |
template<typename T > | |
void | registerCommand (const uint32_t command, const CommandFunc< T > &func, CommandQueue *queue) |
Register a command member function for a command. More... | |
virtual CO_API bool | dispatchCommand (ICommand &command) |
Dispatch a command from the receiver thread to the registered queue. More... | |
Protected Member Functions | |
CO_API | Object () |
Construct a new distributed object. More... | |
Object & | operator= (const Object &) |
NOP assignment operator. More... | |
CO_API | Object (const Object &) |
Copy construct a new, unattached object. More... | |
Protected Member Functions inherited from co::Dispatcher | |
CO_API | Dispatcher (const Dispatcher &from) |
CO_API bool | _cmdUnknown (ICommand &command) |
The default handler for handling commands. More... | |
Friends | |
class | ObjectStore |
A distributed object.
Please refer to the Equalizer Programming Guide and examples on how to develop and use distributed objects. The Serializable implements a typical common use case based on the basic Object.
|
virtual |
Destruct the distributed object.
|
protected |
Construct a new distributed object.
|
explicitprotected |
Copy construct a new, unattached object.
|
inlinevirtual |
Deserialize the instance data.
This method is called during object mapping to populate slave instances with the master object's data.
is | the input stream. |
Reimplemented in co::Serializable, co::Barrier, and co::QueueSlave.
|
virtual |
Return the compressor to be used for data transmission.
This default implementation uses a heuristic to choose the best lossless compressor in terms of speed and compression ratio. The application may override this method to deactivate compression by returning the default pression::Data::CompressorInfo or to select object-specific compressors.
|
virtual |
Commit a new version of this object.
Objects using the change type STATIC can not be committed.
Master instances will increment new versions continuously, starting at VERSION_FIRST. If the object has not changed, no new version will be generated, that is, the current version is returned. The high value of the returned version will always be 0.
Slave objects can be committed, but have certain caveats for serialization. Please refer to the Equalizer Programming Guide for details. Slave object commits will return a random version on a successful commit, or VERSION_NONE if the object has not changed since the last commit. The high value of a successful slave commit will never be 0.
The incarnation count is meaningful for buffered master objects. The commit implementation will keep all instance data committed with an incarnation count newer than current_incarnation - getAutoObsolete()
. By default, each call to commit creates a new incarnation, retaining the data from last getAutoObsolete() commit calls. When the application wishes to auto obsolete by another metric than commit calls, it has to consistently provide a corresponding incarnation counter. Buffers with a higher incarnation count than the current are discarded. A typical use case is to tie the auto obsoletion to an application-specific frame loop. Decreasing the incarnation counter will lead to undefined results.
incarnation | the commit incarnation for auto obsoletion. |
Reimplemented in co::ObjectMap, and co::Serializable.
CO_API uint32_t co::Object::getAutoObsolete | ( | ) | const |
|
inlinevirtual |
Reimplemented in co::ObjectMap, co::Barrier, co::Serializable, and co::QueueSlave.
CO_API uint128_t co::Object::getHeadVersion | ( | ) | const |
CO_API const uint128_t& co::Object::getID | ( | ) | const |
Referenced by co::DataIStream::operator>>().
|
inlinevirtual |
Serialize all instance information of this distributed object.
os | The output stream. |
Reimplemented in co::Serializable, co::Barrier, and co::QueueSlave.
CO_API uint32_t co::Object::getInstanceID | ( | ) | const |
CO_API LocalNodePtr co::Object::getLocalNode | ( | ) |
|
inlinevirtual |
Limit the number of queued versions on slave instances.
Changing the return value of this method causes the master instance to block during commit() if any slave instance has reached the maximum number of queued versions. The method is called on the slave instance. Multiple slave instances may use different values.
Changing the return value at runtime, that is, after the slave instance has been mapped is unsupported and causes undefined behavior.
Not supported on master instances for slave object commits. Open an issue if you need this.
CO_API uint128_t co::Object::getVersion | ( | ) | const |
CO_API bool co::Object::isAttached | ( | ) | const |
Referenced by co::DataOStream::operator<<().
|
inlinevirtual |
Return if this object needs a commit.
This function is used for optimization, to detect early that no commit is needed. If it returns true, pack() or getInstanceData() will be executed. The serialization methods can still decide to not write any data, upon which no new version will be created. If it returns false, commit() will exit early.
Reimplemented in co::ObjectMap, and co::Serializable.
CO_API bool co::Object::isMaster | ( | ) | const |
|
inlinevirtual |
|
inlinevirtual |
Notify that this object has been registered or mapped.
The method is called from the thread initiating the registration or mapping, after the operation has been completed successfully.
Reimplemented in co::ObjectMap, and co::Serializable.
|
virtual |
Notify that this object will be deregistered or unmapped.
The method is called from the thread initiating the deregistration or unmapping, before the operation is executed.
|
inlinevirtual |
|
virtual |
Notification that a new head version was received by a slave object.
The notification is called from the receiver thread, which is different from the node main thread. The object cannot be sync()'ed from this notification, as this might lead to deadlocks and synchronization issues with the application thread changing the object. It should signal the application, which then takes the appropriate action. Do not perform any potentially blocking operations from this method.
version | The new head version. |
|
inlinevirtual |
Notification that a new version was received by a master object.
The same constraints as for notifyNewHeadVersion() apply.
NOP assignment operator.
Definition at line 430 of file object.h.
Referenced by co::Serializable::operator=().
|
inlinevirtual |
Serialize the modifications since the last call to commit().
No new version will be created if no data is written to the output stream.
os | the output stream. |
Reimplemented in co::Serializable, and co::Barrier.
CO_API void co::Object::push | ( | const uint128_t & | groupID, |
const uint128_t & | objectType, | ||
const Nodes & | nodes | ||
) |
Push the instance data of the object to the given nodes.
Used to push object data from a Node, instead of pulling it during mapping. Does not establish any mapping, that is, the receiving side will typically use LocalNode::mapObject with VERSION_NONE to establish a slave mapping. LocalNode::objectPush() is called once for each node in the nodes list.
Buffered objects do not reserialize their instance data. Multicast connections are preferred, that is, for a set of nodes sharing one multicast connection the data is only send once.
groupID | An identifier to group a set of push operations. |
objectType | A per-push identifier. |
nodes | The vector of nodes to push to. |
CO_API ObjectOCommand co::Object::send | ( | NodePtr | node, |
const uint32_t | cmd, | ||
const uint32_t | instanceID = CO_INSTANCE_ALL |
||
) |
Send a command with optional data to object instance(s) on another node.
The returned command can be used to pass additional data. The data will be send after the command object is destroyed, aka when it is running out of scope.
node | the node where to send the command to. |
cmd | the object command to execute. |
instanceID | the object instance(s) which should handle the command. |
CO_API void co::Object::setAutoObsolete | ( | const uint32_t | count | ) |
Automatically obsolete old versions.
The versions for the last count incarnations are retained for the buffered object types INSTANCE and DELTA.
count | the number of incarnations to retain. |
CO_API void co::Object::setID | ( | const uint128_t & | identifier | ) |
Set the object's unique identifier.
Only to be called on unattached objects. The application has to ensure the uniqueness of the identifier in the peer-to-peer node network. By default, each object has an identifier guaranteed to be unique. During mapping, the identifier of the object will be overwritten with the identifier of the master object.
|
virtual |
Sync to a given version.
Objects using the change type STATIC can not be synced.
Syncing to VERSION_HEAD syncs all received versions, does not block and always returns true. Syncing to VERSION_NEXT applies one new version, potentially blocking. Syncing to VERSION_NONE does nothing.
Slave objects can be synced to VERSION_HEAD, VERSION_NEXT or to any past or future version generated by a commit on the master instance. Syncing to a concrete version applies all pending versions up to this version and potentially blocks if given a future version.
Master objects can only be synced to VERSION_HEAD, VERSION_NEXT or to any version generated by a commit on a slave instance. Syncing to a concrete version applies only this version and potentially blocks.
The different sync semantics for concrete versions originate from the fact that master versions are continous and ordered, while slave versions are random and unordered.
This function is not thread safe, that is, calling sync() simultaneously on the same object from multiple threads has to be protected by the caller using a mutex.
version | the version to synchronize (see above). |
|
inlinevirtual |
Deserialize a change.
is | the input data stream. |
Reimplemented in co::Serializable, and co::Barrier.