Changeset 7459 in orxonox.OLD for branches/network

Timestamp:

Apr 30, 2006, 1:50:25 PM (19 years ago)

Author:

rennerc

Message:

finished some SynchronizeableVars classes

Location:

branches/network/src/lib/network

Files:

• synchronizeable.cc (modified) (1 diff)
• synchronizeable_var/synchronizeable_bool.cc (modified) (2 diffs)
• synchronizeable_var/synchronizeable_bool.h (modified) (1 diff)
• synchronizeable_var/synchronizeable_float.cc (modified) (4 diffs)
• synchronizeable_var/synchronizeable_float.h (modified) (1 diff)
• synchronizeable_var/synchronizeable_int.cc (modified) (3 diffs)
• synchronizeable_var/synchronizeable_int.h (modified) (1 diff)
• synchronizeable_var/synchronizeable_quaternion.cc (modified) (4 diffs)
• synchronizeable_var/synchronizeable_quaternion.h (modified) (1 diff)
• synchronizeable_var/synchronizeable_string.cc (modified) (3 diffs)
• synchronizeable_var/synchronizeable_string.h (modified) (1 diff)
• synchronizeable_var/synchronizeable_var.cc (modified) (2 diffs)
• synchronizeable_var/synchronizeable_var.h (modified) (1 diff)
• synchronizeable_var/synchronizeable_vector.cc (modified) (4 diffs)
• synchronizeable_var/synchronizeable_vector.h (modified) (1 diff)

branches/network/src/lib/network/synchronizeable.cc

@@ -121 +121 @@
 void Synchronizeable::varChangeHandler( std::list<int> & id )
 {
-#warning implement this
 }
 

branches/network/src/lib/network/synchronizeable_var/synchronizeable_bool.cc

@@ -43 +43 @@
 int SynchronizeableBool::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= 1 );
+  
+  buf[0] = ( *vPtrIn ) ? 1 : 0;
+  
+  return 1;
 }
 
@@ -54 +58 @@
 int SynchronizeableBool::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= 1 );
+  
+  *vPtrOut = buf[0] != 0;
+  
+  return 1;
 }

branches/network/src/lib/network/synchronizeable_var/synchronizeable_bool.h

@@ -18 +18 @@
     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)

branches/network/src/lib/network/synchronizeable_var/synchronizeable_float.cc

@@ -16 +16 @@
 
 #include "synchronizeable_float.h"
+#include "converter.h"
 
 
@@ -22 +23 @@
  * @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 +45 @@
 int SynchronizeableFloat::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int res = Converter::floatToByteArray( *vPtrIn, buf, maxLength );
+  
+  assert( res == FLOATSIZE );
+  
+  return res;
 }
 
@@ -55 +60 @@
 int SynchronizeableFloat::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= FLOATSIZE );
+  
+  int res = Converter::byteArrayToFloat( buf, vPtrOut );
+  
+  assert( res == FLOATSIZE );
+  
+  return res;
 }

branches/network/src/lib/network/synchronizeable_var/synchronizeable_float.h

@@ -17 +17 @@
     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:

branches/network/src/lib/network/synchronizeable_var/synchronizeable_int.cc

@@ -16 +16 @@
 
 #include "synchronizeable_int.h"
+#include "converter.h"
 
 
@@ -44 +45 @@
 int SynchronizeableInt::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int res = Converter::intToByteArray( *vPtrIn, buf, maxLength );
+  
+  assert( res == INTSIZE );
+  
+  return res;
 }
 
@@ -55 +60 @@
 int SynchronizeableInt::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  assert( maxLength >= INTSIZE );
+  
+  int res = Converter::byteArrayToInt( buf, vPtrOut );
+  
+  assert( res == INTSIZE );
+  
+  return res;
 }

branches/network/src/lib/network/synchronizeable_var/synchronizeable_int.h

@@ -18 +18 @@
     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)

branches/network/src/lib/network/synchronizeable_var/synchronizeable_quaternion.cc

@@ -16 +16 @@
 
 #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 +31 @@
 /**
  * standard deconstructor
-*/
+ */
 SynchronizeableQuaternion::~SynchronizeableQuaternion ()
 {
@@ -44 +44 @@
 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 +76 @@
 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;
 }

branches/network/src/lib/network/synchronizeable_var/synchronizeable_quaternion.h

@@ -19 +19 @@
     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:

branches/network/src/lib/network/synchronizeable_var/synchronizeable_string.cc

@@ -16 +16 @@
 
 #include "synchronizeable_string.h"
+#include "converter.h"
 
 
@@ -44 +45 @@
 int SynchronizeableString::writeToBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int res = Converter::stringToByteArray( *vPtrIn, buf, maxLength );
+  
+  assert( res > 0 );
+  
+  return res;
 }
 
@@ -55 +60 @@
 int SynchronizeableString::readFromBuf( byte * buf, int maxLength )
 {
-#warning implement this
+  int res = Converter::byteArrayToString( buf, *vPtrOut, maxLength );
+  
+  assert( res > 0 );
+  
+  return res;
 }

branches/network/src/lib/network/synchronizeable_var/synchronizeable_string.h

@@ -20 +20 @@
     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)

branches/network/src/lib/network/synchronizeable_var/synchronizeable_var.cc

@@ -24 +24 @@
 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 +44 @@
 }
 
-/**
- * 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
-}

branches/network/src/lib/network/synchronizeable_var/synchronizeable_var.h

@@ -22 +22 @@
     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;
     
     /**

branches/network/src/lib/network/synchronizeable_var/synchronizeable_vector.cc

@@ -16 +16 @@
 
 #include "synchronizeable_vector.h"
+#include "converter.h"
 
 
@@ -22 +23 @@
  * @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 +45 @@
 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 +73 @@
 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;
 }

branches/network/src/lib/network/synchronizeable_var/synchronizeable_vector.h

@@ -20 +20 @@
     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)