Introduction Manual Class Reference Header Reference

ZCom_Replicate_StringWp Class Reference

Inheritance diagram for ZCom_Replicate_StringWp:

Inheritance graph
[legend]
Collaboration diagram for ZCom_Replicate_StringWp:

Collaboration graph
[legend]
List of all members.

Detailed Description

Replicator for C-strings.


Public Member Functions

 ZCom_Replicate_StringWp (wchar_t *_data, zU16 _maxlen, zU8 _flags, zU8 _rules, zU8 _intercept_id=0, zS16 _mindelay=-1, zS16 _maxdelay=-1)
 constructor, builds the replicatorsetup automatically
 ZCom_Replicate_StringWp (wchar_t *_data, ZCom_RSetupString *_setup)
 constructor, taking a ZCom_ReplicatorSetup pointer
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.
Construction / Deconstruction.
void operator delete (void *_p)
 Overloaded memory operator ensuring that always Zoidcom's delete gets called.
void * operator new (size_t _size)
 Overloaded memory operator ensuring that always Zoidcom's new gets called.

Protected Member Functions

Interceptor peek support.

The methods getPeekData() and clearPeekData() need to be implemented when the replicator is supposed to be intercepted. Using these methods, the interceptor callback can ask the replicator to peek into the stream, without altering it's read position. Inspecting the data provided by the peekData() method, the callback can then decide if the update should be let through or not.

A interceptor trying to see what is in the stream only needs to call the peekData() method. Everything else is handled by the replicator itself.

A replicator that should support peeking has to implement peekData(), using getPeekStream() to get the currently processed bitstream. If it needs to allocate memory to hold the data, it has to make use of peekDataStore() in peekData(), and peekDataRetrieve() in clearPeekData().

      class MyReplicator : public ZCom_Replicator {
      void * peekData() {
        int size = getPeekStream()->getStringSize();
        char *string = new char[size];
        getPeekStream()->getString(string, size);
        // store it so it can be deleted later
        peekDataStore(buf);
        return (void*) buf;
      }

      void  clearPeekData() {
        char *str = peekDataRetrieve();
        if (str) delete []str;
      }

Zoidcom automatically notices if data has been stored and calls clearPeekData() after the interceptor has completed.

If the stream contains very simple data for which no memory allocation is needed, this will do: 

      void *MyReplicator::peekData() {
        return (void*) getPeekStream()->getInt(32);
      }
      void MyReplicator::clearPeekData() {}

More information can be found in the documentation of each peek method.

ZCom_BitStream * getPeekStream () const
 Get stream currently processed for peeking the data.
void * peekDataRetrieve ()
 Retrieve the peekbuffer pointer currently stored.
void peekDataStore (void *_ptr)
 Store pointer to allocated peekbuffer, so it can be deleted again.
Interceptor peek support.

The methods getPeekData() and clearPeekData() need to be implemented when the replicator is supposed to be intercepted. Using these methods, the interceptor callback can ask the replicator to peek into the stream, without altering it's read position. Inspecting the data provided by the peekData() method, the callback can then decide if the update should be let through or not.

A interceptor trying to see what is in the stream only needs to call the peekData() method. Everything else is handled by the replicator itself.

A replicator that should support peeking has to implement peekData(), using getPeekStream() to get the currently processed bitstream. If it needs to allocate memory to hold the data, it has to make use of peekDataStore() in peekData(), and peekDataRetrieve() in clearPeekData().

      class MyReplicator : public ZCom_Replicator {
      void * peekData() {
        int size = getPeekStream()->getStringSize();
        char *string = new char[size];
        getPeekStream()->getString(string, size);
        // store it so it can be deleted later
        peekDataStore(buf);
        return (void*) buf;
      }

      void  clearPeekData() {
        char *str = peekDataRetrieve();
        if (str) delete []str;
      }

Zoidcom automatically notices if data has been stored and calls clearPeekData() after the interceptor has completed.

If the stream contains very simple data for which no memory allocation is needed, this will do: 

      void *MyReplicator::peekData() {
        return (void*) getPeekStream()->getInt(32);
      }
      void MyReplicator::clearPeekData() {}

More information can be found in the documentation of each peek method.

ZCom_BitStream * getPeekStream () const
 Get stream currently processed for peeking the data.
void * peekDataRetrieve ()
 Retrieve the peekbuffer pointer currently stored.
void peekDataStore (void *_ptr)
 Store pointer to allocated peekbuffer, so it can be deleted again.
Interceptor peek support.

The methods getPeekData() and clearPeekData() need to be implemented when the replicator is supposed to be intercepted. Using these methods, the interceptor callback can ask the replicator to peek into the stream, without altering it's read position. Inspecting the data provided by the peekData() method, the callback can then decide if the update should be let through or not.

A interceptor trying to see what is in the stream only needs to call the peekData() method. Everything else is handled by the replicator itself.

A replicator that should support peeking has to implement peekData(), using getPeekStream() to get the currently processed bitstream. If it needs to allocate memory to hold the data, it has to make use of peekDataStore() in peekData(), and peekDataRetrieve() in clearPeekData().

      class MyReplicator : public ZCom_Replicator {
      void * peekData() {
        int size = getPeekStream()->getStringSize();
        char *string = new char[size];
        getPeekStream()->getString(string, size);
        // store it so it can be deleted later
        peekDataStore(buf);
        return (void*) buf;
      }

      void  clearPeekData() {
        char *str = peekDataRetrieve();
        if (str) delete []str;
      }

Zoidcom automatically notices if data has been stored and calls clearPeekData() after the interceptor has completed.

If the stream contains very simple data for which no memory allocation is needed, this will do: 

      void *MyReplicator::peekData() {
        return (void*) getPeekStream()->getInt(32);
      }
      void MyReplicator::clearPeekData() {}

More information can be found in the documentation of each peek method.

ZCom_BitStream * getPeekStream () const
 Get stream currently processed for peeking the data.
void * peekDataRetrieve ()
 Retrieve the peekbuffer pointer currently stored.
void peekDataStore (void *_ptr)
 Store pointer to allocated peekbuffer, so it can be deleted again.
Interceptor peek support.

The methods getPeekData() and clearPeekData() need to be implemented when the replicator is supposed to be intercepted. Using these methods, the interceptor callback can ask the replicator to peek into the stream, without altering it's read position. Inspecting the data provided by the peekData() method, the callback can then decide if the update should be let through or not.

A interceptor trying to see what is in the stream only needs to call the peekData() method. Everything else is handled by the replicator itself.

A replicator that should support peeking has to implement peekData(), using getPeekStream() to get the currently processed bitstream. If it needs to allocate memory to hold the data, it has to make use of peekDataStore() in peekData(), and peekDataRetrieve() in clearPeekData().

      class MyReplicator : public ZCom_Replicator {
      void * peekData() {
        int size = getPeekStream()->getStringSize();
        char *string = new char[size];
        getPeekStream()->getString(string, size);
        // store it so it can be deleted later
        peekDataStore(buf);
        return (void*) buf;
      }

      void  clearPeekData() {
        char *str = peekDataRetrieve();
        if (str) delete []str;
      }

Zoidcom automatically notices if data has been stored and calls clearPeekData() after the interceptor has completed.

If the stream contains very simple data for which no memory allocation is needed, this will do: 

      void *MyReplicator::peekData() {
        return (void*) getPeekStream()->getInt(32);
      }
      void MyReplicator::clearPeekData() {}

More information can be found in the documentation of each peek method.

ZCom_BitStream * getPeekStream () const
 Get stream currently processed for peeking the data.
void * peekDataRetrieve ()
 Retrieve the peekbuffer pointer currently stored.
void peekDataStore (void *_ptr)
 Store pointer to allocated peekbuffer, so it can be deleted again.
Interceptor peek support.

The methods getPeekData() and clearPeekData() need to be implemented when the replicator is supposed to be intercepted. Using these methods, the interceptor callback can ask the replicator to peek into the stream, without altering it's read position. Inspecting the data provided by the peekData() method, the callback can then decide if the update should be let through or not.

A interceptor trying to see what is in the stream only needs to call the peekData() method. Everything else is handled by the replicator itself.

A replicator that should support peeking has to implement peekData(), using getPeekStream() to get the currently processed bitstream. If it needs to allocate memory to hold the data, it has to make use of peekDataStore() in peekData(), and peekDataRetrieve() in clearPeekData().

      class MyReplicator : public ZCom_Replicator {
      void * peekData() {
        int size = getPeekStream()->getStringSize();
        char *string = new char[size];
        getPeekStream()->getString(string, size);
        // store it so it can be deleted later
        peekDataStore(buf);
        return (void*) buf;
      }

      void  clearPeekData() {
        char *str = peekDataRetrieve();
        if (str) delete []str;
      }

Zoidcom automatically notices if data has been stored and calls clearPeekData() after the interceptor has completed.

If the stream contains very simple data for which no memory allocation is needed, this will do: 

      void *MyReplicator::peekData() {
        return (void*) getPeekStream()->getInt(32);
      }
      void MyReplicator::clearPeekData() {}

More information can be found in the documentation of each peek method.

ZCom_BitStream * getPeekStream () const
 Get stream currently processed for peeking the data.
void * peekDataRetrieve ()
 Retrieve the peekbuffer pointer currently stored.
void peekDataStore (void *_ptr)
 Store pointer to allocated peekbuffer, so it can be deleted again.
Interceptor peek support.

The methods getPeekData() and clearPeekData() need to be implemented when the replicator is supposed to be intercepted. Using these methods, the interceptor callback can ask the replicator to peek into the stream, without altering it's read position. Inspecting the data provided by the peekData() method, the callback can then decide if the update should be let through or not.

A interceptor trying to see what is in the stream only needs to call the peekData() method. Everything else is handled by the replicator itself.

A replicator that should support peeking has to implement peekData(), using getPeekStream() to get the currently processed bitstream. If it needs to allocate memory to hold the data, it has to make use of peekDataStore() in peekData(), and peekDataRetrieve() in clearPeekData().

      class MyReplicator : public ZCom_Replicator {
      void * peekData() {
        int size = getPeekStream()->getStringSize();
        char *string = new char[size];
        getPeekStream()->getString(string, size);
        // store it so it can be deleted later
        peekDataStore(buf);
        return (void*) buf;
      }

      void  clearPeekData() {
        char *str = peekDataRetrieve();
        if (str) delete []str;
      }

Zoidcom automatically notices if data has been stored and calls clearPeekData() after the interceptor has completed.

If the stream contains very simple data for which no memory allocation is needed, this will do: 

      void *MyReplicator::peekData() {
        return (void*) getPeekStream()->getInt(32);
      }
      void MyReplicator::clearPeekData() {}

More information can be found in the documentation of each peek method.

ZCom_BitStream * getPeekStream () const
 Get stream currently processed for peeking the data.
void * peekDataRetrieve ()
 Retrieve the peekbuffer pointer currently stored.
void peekDataStore (void *_ptr)
 Store pointer to allocated peekbuffer, so it can be deleted again.
Interceptor peek support.

The methods getPeekData() and clearPeekData() need to be implemented when the replicator is supposed to be intercepted. Using these methods, the interceptor callback can ask the replicator to peek into the stream, without altering it's read position. Inspecting the data provided by the peekData() method, the callback can then decide if the update should be let through or not.

A interceptor trying to see what is in the stream only needs to call the peekData() method. Everything else is handled by the replicator itself.

A replicator that should support peeking has to implement peekData(), using getPeekStream() to get the currently processed bitstream. If it needs to allocate memory to hold the data, it has to make use of peekDataStore() in peekData(), and peekDataRetrieve() in clearPeekData().

      class MyReplicator : public ZCom_Replicator {
      void * peekData() {
        int size = getPeekStream()->getStringSize();
        char *string = new char[size];
        getPeekStream()->getString(string, size);
        // store it so it can be deleted later
        peekDataStore(buf);
        return (void*) buf;
      }

      void  clearPeekData() {
        char *str = peekDataRetrieve();
        if (str) delete []str;
      }

Zoidcom automatically notices if data has been stored and calls clearPeekData() after the interceptor has completed.

If the stream contains very simple data for which no memory allocation is needed, this will do: 

      void *MyReplicator::peekData() {
        return (void*) getPeekStream()->getInt(32);
      }
      void MyReplicator::clearPeekData() {}

More information can be found in the documentation of each peek method.

ZCom_BitStream * getPeekStream () const
 Get stream currently processed for peeking the data.
void * peekDataRetrieve ()
 Retrieve the peekbuffer pointer currently stored.
void peekDataStore (void *_ptr)
 Store pointer to allocated peekbuffer, so it can be deleted again.
Interceptor peek support.

The methods getPeekData() and clearPeekData() need to be implemented when the replicator is supposed to be intercepted. Using these methods, the interceptor callback can ask the replicator to peek into the stream, without altering it's read position. Inspecting the data provided by the peekData() method, the callback can then decide if the update should be let through or not.

A interceptor trying to see what is in the stream only needs to call the peekData() method. Everything else is handled by the replicator itself.

A replicator that should support peeking has to implement peekData(), using getPeekStream() to get the currently processed bitstream. If it needs to allocate memory to hold the data, it has to make use of peekDataStore() in peekData(), and peekDataRetrieve() in clearPeekData().

      class MyReplicator : public ZCom_Replicator {
      void * peekData() {
        int size = getPeekStream()->getStringSize();
        char *string = new char[size];
        getPeekStream()->getString(string, size);
        // store it so it can be deleted later
        peekDataStore(buf);
        return (void*) buf;
      }

      void  clearPeekData() {
        char *str = peekDataRetrieve();
        if (str) delete []str;
      }

Zoidcom automatically notices if data has been stored and calls clearPeekData() after the interceptor has completed.

If the stream contains very simple data for which no memory allocation is needed, this will do: 

      void *MyReplicator::peekData() {
        return (void*) getPeekStream()->getInt(32);
      }
      void MyReplicator::clearPeekData() {}

More information can be found in the documentation of each peek method.

ZCom_BitStream * getPeekStream () const
 Get stream currently processed for peeking the data.
void * peekDataRetrieve ()
 Retrieve the peekbuffer pointer currently stored.
void peekDataStore (void *_ptr)
 Store pointer to allocated peekbuffer, so it can be deleted again.

Protected Attributes

zU8 m_flags
 Additional replicator flags. ZCom_Replicator() c'tor will set this to 0. (ZCOM_REPLICATOR_*).
ZCom_ReplicatorSetup * m_setup
 pointing to an instance of the setup class - all replication parameters are stored here

Constructor & Destructor Documentation

ZCom_Replicate_StringWp::ZCom_Replicate_StringWp (  wchar_t *  _data,
ZCom_RSetupString *  _setup
) 
 

constructor, taking a ZCom_ReplicatorSetup pointer

ZCom_Replicate_StringWp::ZCom_Replicate_StringWp (  wchar_t *  _data,
zU16  _maxlen,
zU8  _flags,
zU8  _rules,
zU8  _intercept_id = 0,
zS16  _mindelay = -1,
zS16  _maxdelay = -1
) 
 

constructor, builds the replicatorsetup automatically

Member Function Documentation

void* ZCom_Replicator::operator new (  size_t  _size  )  [inherited]
 

Overloaded memory operator ensuring that always Zoidcom's new gets called.

Attention:
Don't overload this unless you are 100% sure what you are doing.

void ZCom_Replicator::operator delete (  void *  _p  )  [inherited]
 

Overloaded memory operator ensuring that always Zoidcom's delete gets called.

Attention:
Don't overload this unless you are 100% sure what you are doing.

ZCom_BitStream* ZCom_Replicator::getPeekStream (   )  const [protected, inherited]
 

Get stream currently processed for peeking the data.

Returns:
Pointer to current ZCom_BitStream.
As you might have noticed, peekData() does not have a ZCom_BitStream parameter. That's the case because peekData() must be called from inside ZCom_NodeReplicationInterceptor::inPreUpdateItem(), and this interceptor callback has no access to the currently processed stream. Use this method to get a pointer to the currently processed stream instead.

This will only return a valid result when called from inside the above mentioned interceptor callback.

void ZCom_Replicator::peekDataStore (  void *  _ptr  )  [protected, inherited]
 

Store pointer to allocated peekbuffer, so it can be deleted again.

Parameters:
_ptr Pointer to the allocated memory.
The pointer will get stored in a global Thread Local Storage, so that multiple ZCom_Controls can safely operate simultaneously in different threads. When a replicator's peekData() makes use of this method, expect to get a call to clearPeekData() sometime soon, which is supposed to free the allocated memory again.

When you call peekDataStore() more than once with a pointer != NULL, clearPeekData() will get called automatically.

Thread Local Storage means, there is one variable for each thread of the program. Replicators could as well declare a member variable used for that purpose instead, but that would waste a lot of memory when peeking interceptors are not used.

void* ZCom_Replicator::peekDataRetrieve (   )  [protected, inherited]
 

Retrieve the peekbuffer pointer currently stored.

Returns:
Pointer previously stored with peekDataStore().

Member Data Documentation

zU8 ZCom_Replicator::m_flags [protected, inherited]
 

Additional replicator flags. ZCom_Replicator() c'tor will set this to 0. (ZCOM_REPLICATOR_*).

ZCom_ReplicatorSetup* ZCom_Replicator::m_setup [protected, inherited]
 

pointing to an instance of the setup class - all replication parameters are stored here

This file is part of the documentation for Zoidcom. Documentation copyright © 2004-2008 by Jörg Rüppel. Generated on Sat Aug 16 15:26:50 2008 for Zoidcom by doxygen 1.4.6-NO