Index: branches/network/src/lib/network/synchronizeable.cc
===================================================================
--- branches/network/src/lib/network/synchronizeable.cc	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable.cc	(revision 7459)
@@ -121,5 +121,4 @@
 void Synchronizeable::varChangeHandler( std::list<int> & id )
 {
-#warning implement this
 }
 
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_bool.cc
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_bool.cc	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_bool.cc	(revision 7459)
@@ -43,5 +43,9 @@
 int SynchronizeableBool::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= 1 );
+  
+  buf[0] = ( *vPtrIn ) ? 1 : 0;
+  
+  return 1;
 }
 
@@ -54,4 +58,8 @@
 int SynchronizeableBool::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= 1 );
+  
+  *vPtrOut = buf[0] != 0;
+  
+  return 1;
 }
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_bool.h
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_bool.h	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_bool.h	(revision 7459)
@@ -18,4 +18,10 @@
     virtual int readFromBuf( byte * buf, int maxLength );
     
+    /**
+     * check if writeToBuf will return the same size every time
+     * @return true if same size every time
+     */
+    virtual bool hasStaticSize(){ return true; };
+    
   private:
     bool * vPtrIn;       //!< pointer to data (read)
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_float.cc
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_float.cc	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_float.cc	(revision 7459)
@@ -16,4 +16,5 @@
 
 #include "synchronizeable_float.h"
+#include "converter.h"
 
 
@@ -22,5 +23,5 @@
  * @todo this constructor is not jet implemented - do it
 */
-SynchronizeableFloat::SynchronizeableFloat( float * ptrIn, float * ptrOut, std::string name, int permission, int priority) : SynchronizeableVar( ptrIn, ptrOut, name, 0, permission, priority )
+SynchronizeableFloat::SynchronizeableFloat( float * ptrIn, float * ptrOut, std::string name, int permission, int priority) : SynchronizeableVar( ptrIn, ptrOut, name, FLOATSIZE, permission, priority )
 {
   this->vPtrIn = ptrIn;
@@ -44,5 +45,9 @@
 int SynchronizeableFloat::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int res = Converter::floatToByteArray( *vPtrIn, buf, maxLength );
+  
+  assert( res == FLOATSIZE );
+  
+  return res;
 }
 
@@ -55,4 +60,10 @@
 int SynchronizeableFloat::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= FLOATSIZE );
+  
+  int res = Converter::byteArrayToFloat( buf, vPtrOut );
+  
+  assert( res == FLOATSIZE );
+  
+  return res;
 }
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_float.h
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_float.h	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_float.h	(revision 7459)
@@ -17,4 +17,10 @@
     virtual int writeToBuf( byte * buf, int maxLength );
     virtual int readFromBuf( byte * buf, int maxLength );
+        
+    /**
+     * check if writeToBuf will return the same size every time
+     * @return true if same size every time
+     */
+    virtual bool hasStaticSize(){ return true; };
     
   private:
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_int.cc
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_int.cc	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_int.cc	(revision 7459)
@@ -16,4 +16,5 @@
 
 #include "synchronizeable_int.h"
+#include "converter.h"
 
 
@@ -44,5 +45,9 @@
 int SynchronizeableInt::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int res = Converter::intToByteArray( *vPtrIn, buf, maxLength );
+  
+  assert( res == INTSIZE );
+  
+  return res;
 }
 
@@ -55,4 +60,10 @@
 int SynchronizeableInt::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= INTSIZE );
+  
+  int res = Converter::byteArrayToInt( buf, vPtrOut );
+  
+  assert( res == INTSIZE );
+  
+  return res;
 }
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_int.h
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_int.h	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_int.h	(revision 7459)
@@ -18,4 +18,10 @@
     virtual int readFromBuf( byte * buf, int maxLength );
     
+    /**
+     * check if writeToBuf will return the same size every time
+     * @return true if same size every time
+     */
+    virtual bool hasStaticSize(){ return true; };
+    
   private:
     int * vPtrIn;       //!< pointer to data (read)
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_quaternion.cc
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_quaternion.cc	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_quaternion.cc	(revision 7459)
@@ -16,11 +16,11 @@
 
 #include "synchronizeable_quaternion.h"
+#include "converter.h"
 
 
 /**
  * standard constructor
- * @todo this constructor is not jet implemented - do it
-*/
-SynchronizeableQuaternion::SynchronizeableQuaternion( Quaternion * ptrIn, Quaternion * ptrOut, std::string name, int permission, int priority) : SynchronizeableVar( ptrIn, ptrOut, name, 0, permission, priority )
+ */
+SynchronizeableQuaternion::SynchronizeableQuaternion( Quaternion * ptrIn, Quaternion * ptrOut, std::string name, int permission, int priority) : SynchronizeableVar( ptrIn, ptrOut, name, 4*INTSIZE, permission, priority )
 {
   this->vPtrIn = ptrIn;
@@ -31,5 +31,5 @@
 /**
  * standard deconstructor
-*/
+ */
 SynchronizeableQuaternion::~SynchronizeableQuaternion ()
 {
@@ -44,5 +44,26 @@
 int SynchronizeableQuaternion::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int n = 0;
+  int res;
+  
+  res = Converter::floatToByteArray( vPtrIn->v.x, buf, maxLength - n );
+  assert( res > 0 );
+  n += res;
+  
+  res = Converter::floatToByteArray( vPtrIn->v.y, buf, maxLength - n );
+  assert( res > 0 );
+  n += res;
+  
+  res = Converter::floatToByteArray( vPtrIn->v.z, buf, maxLength - n );
+  assert( res > 0 );
+  n += res;
+  
+  res = Converter::floatToByteArray( vPtrIn->w, buf, maxLength - n );
+  assert( res > 0 );
+  n += res;
+  
+  assert( 4*FLOATSIZE == n );
+  
+  return n;
 }
 
@@ -55,4 +76,30 @@
 int SynchronizeableQuaternion::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= 4*FLOATSIZE );
+  
+  float x,y,z,w;
+  
+  int res;
+  int n = 0;
+  
+  res += Converter::byteArrayToFloat( buf + n, &x );
+  assert( res > 0 );
+  n += res;
+  
+  res += Converter::byteArrayToFloat( buf + n, &x );
+  assert( res > 0 );
+  n += res;
+  
+  res += Converter::byteArrayToFloat( buf + n, &x );
+  assert( res > 0 );
+  n += res;
+  
+  res += Converter::byteArrayToFloat( buf + n, &w );
+  assert( res > 0 );
+  n += res;
+  
+  *vPtrOut = Quaternion( Vector(x, y, z), w );
+  
+  assert( res == 4*FLOATSIZE );
+  return res;
 }
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_quaternion.h
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_quaternion.h	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_quaternion.h	(revision 7459)
@@ -19,4 +19,10 @@
     virtual int writeToBuf( byte * buf, int maxLength );
     virtual int readFromBuf( byte * buf, int maxLength );
+        
+    /**
+     * check if writeToBuf will return the same size every time
+     * @return true if same size every time
+     */
+    virtual bool hasStaticSize(){ return true; };
     
   private:
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_string.cc
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_string.cc	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_string.cc	(revision 7459)
@@ -16,4 +16,5 @@
 
 #include "synchronizeable_string.h"
+#include "converter.h"
 
 
@@ -44,5 +45,9 @@
 int SynchronizeableString::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int res = Converter::stringToByteArray( *vPtrIn, buf, maxLength );
+  
+  assert( res > 0 );
+  
+  return res;
 }
 
@@ -55,4 +60,8 @@
 int SynchronizeableString::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int res = Converter::byteArrayToString( buf, *vPtrOut, maxLength );
+  
+  assert( res > 0 );
+  
+  return res;
 }
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_string.h
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_string.h	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_string.h	(revision 7459)
@@ -20,4 +20,11 @@
     virtual int readFromBuf( byte * buf, int maxLength );
     
+        
+    /**
+     * check if writeToBuf will return the same size every time
+     * @return true if same size every time
+     */
+    virtual bool hasStaticSize(){ return false; };
+    
   private:
     std::string * vPtrIn;       //!< pointer to data (read)
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_var.cc
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_var.cc	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_var.cc	(revision 7459)
@@ -24,4 +24,7 @@
 SynchronizeableVar::SynchronizeableVar ( void * ptrIn, void * ptrOut, std::string name, int length, int permission, int priority)
 {
+  assert( ptrIn );
+  assert( ptrOut );
+  
   this->ptrIn = ptrIn;
   this->ptrOut = ptrOut;
@@ -41,23 +44,2 @@
 }
 
-/**
- * write var data to byte buffer
- * @param buf pointer to write to
- * @param maxLength writeToBuf will not write more than maxLength bytes
- * @return number bytes written
- */
-int SynchronizeableVar::writeToBuf( byte * buf, int maxLength )
-{
-#warning implement this
-}
-
-/**
- * read var data from byte buffer
- * @param buf pointer to read from
- * @param maxLength readFromBuf will not read more than maxLength bytes
- * @return number bytes read
- */
-int SynchronizeableVar::readFromBuf( byte * buf, int maxLength )
-{
-#warning implement this
-}
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_var.h
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_var.h	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_var.h	(revision 7459)
@@ -22,6 +22,25 @@
     inline bool beWatched(){ return this->bWatched; }
     
-    virtual int writeToBuf( byte * buf, int maxLength );
-    virtual int readFromBuf( byte * buf, int maxLength );
+    /**
+     * write var data to byte buffer
+     * @param buf pointer to write to
+     * @param maxLength writeToBuf will not write more than maxLength bytes
+     * @return number bytes written
+     */
+    virtual int writeToBuf( byte * buf, int maxLength ) = 0;
+    
+    /**
+     * read var data from byte buffer
+     * @param buf pointer to read from
+     * @param maxLength readFromBuf will not read more than maxLength bytes
+     * @return number bytes read
+     */
+    virtual int readFromBuf( byte * buf, int maxLength ) = 0;
+    
+    /**
+     * check if writeToBuf will return the same size every time
+     * @return true if same size every time
+     */
+    virtual bool hasStaticSize() = 0;
     
     /**
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_vector.cc
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_vector.cc	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_vector.cc	(revision 7459)
@@ -16,4 +16,5 @@
 
 #include "synchronizeable_vector.h"
+#include "converter.h"
 
 
@@ -22,5 +23,5 @@
  * @todo this constructor is not jet implemented - do it
 */
-SynchronizeableVector::SynchronizeableVector( Vector * ptrIn, Vector * ptrOut, std::string name, int permission, int priority) : SynchronizeableVar( ptrIn, ptrOut, name, 0, permission, priority )
+SynchronizeableVector::SynchronizeableVector( Vector * ptrIn, Vector * ptrOut, std::string name, int permission, int priority) : SynchronizeableVar( ptrIn, ptrOut, name, 3*FLOATSIZE, permission, priority )
 {
   this->vPtrIn = ptrIn;
@@ -44,5 +45,22 @@
 int SynchronizeableVector::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int n = 0;
+  int res;
+  
+  res = Converter::floatToByteArray( vPtrIn->x, buf, maxLength - n );
+  assert( res > 0 );
+  n += res;
+  
+  res = Converter::floatToByteArray( vPtrIn->y, buf, maxLength - n );
+  assert( res > 0 );
+  n += res;
+  
+  res = Converter::floatToByteArray( vPtrIn->z, buf, maxLength - n );
+  assert( res > 0 );
+  n += res;
+  
+  assert( 3*FLOATSIZE == n );
+  
+  return n;
 }
 
@@ -55,4 +73,26 @@
 int SynchronizeableVector::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= 3*FLOATSIZE );
+  
+  float x,y,z;
+  
+  int res;
+  int n = 0;
+  
+  res += Converter::byteArrayToFloat( buf + n, &x );
+  assert( res > 0 );
+  n += res;
+  
+  res += Converter::byteArrayToFloat( buf + n, &x );
+  assert( res > 0 );
+  n += res;
+  
+  res += Converter::byteArrayToFloat( buf + n, &x );
+  assert( res > 0 );
+  n += res;
+  
+  *vPtrOut = Vector( x, y, z );
+  
+  assert( res == 3*FLOATSIZE );
+  return res;
 }
Index: branches/network/src/lib/network/synchronizeable_var/synchronizeable_vector.h
===================================================================
--- branches/network/src/lib/network/synchronizeable_var/synchronizeable_vector.h	(revision 7446)
+++ branches/network/src/lib/network/synchronizeable_var/synchronizeable_vector.h	(revision 7459)
@@ -20,4 +20,10 @@
     virtual int readFromBuf( byte * buf, int maxLength );
     
+    /**
+     * check if writeToBuf will return the same size every time
+     * @return true if same size every time
+     */
+    virtual bool hasStaticSize(){ return true; };
+    
   private:
     Vector * vPtrIn;       //!< pointer to data (read)
