added option to delay start of thread in createthread utility and added tagged serialisable objects

Author: brichards64

UnitTests/TaggedSerialise.cpp

@@ -0,0 +1,89 @@
+#include <iostream>
+#include <TaggedSerialisableObject.h>
+#include <SerialisableObject.h>
+
+using namespace ToolFramework;
+
+struct Bob : public TaggedSerialisableObject{
+
+  int a;
+  std::vector<int> vec;
+ 
+  std::string GetType(){ return "bob";}
+  unsigned int GetVersion(){ return 1;}
+  bool Print(){
+    std::cout<<a<<std::endl;
+    return true;
+  }
+  bool Serialise(BinaryStream &bs){
+
+    bs & a;
+    bs & vec;
+    
+    return true;
+  }
+  
+};
+
+struct Bill : public TaggedSerialisableObject{
+
+  std::vector<int> vec;
+ 
+  std::string GetType(){ return "bill";}
+  unsigned int GetVersion(){ return 1;}
+  bool Print(){ return true;}
+  bool Serialise(BinaryStream &bs){
+
+    bs & vec;
+    
+    return true;
+  }
+  
+};
+
+int main(){
+
+  Bob bob;
+  Bill bill;
+  
+  BinaryStream bs;
+  bs.Bopen("test", NEW, UNCOMPRESSED);
+
+  bob.a=23;
+  bs & bob;
+  
+  bill.vec.resize(1000);
+  bs & bill;
+  
+  bob.a= 46;
+  bs & bob;
+
+  bs & bill;
+  bs.Bclose();
+
+  std::cout<<"read"<<std::endl;
+
+   BinaryStream bs2;
+   bs2.Bopen("test", READ, UNCOMPRESSED);
+
+   Tag tag;
+   Bob bob2;
+    
+   bs2.m_write = false;
+
+   while (bs2 & tag){
+     tag.Print();
+     if(tag.type !="bob"){
+       tag.Skip(bs2);
+       continue;
+     }
+     bs2 & bob2;
+     bob2.Print();
+     
+   }
+
+   bs2.Bclose();
+
+  
+  return 0;
+}

src/DataModelBase/Utilities.cpp

@@ -7,15 +7,15 @@ Utilities::Utilities(){
 }
 
 
-Thread_args* Utilities::CreateThread(std::string ThreadName,  void (*func)(Thread_args*), Thread_args* args){
+Thread_args* Utilities::CreateThread(std::string ThreadName,  void (*func)(Thread_args*), Thread_args* args, bool start){
 
   if(Threads.count(ThreadName)==0){
 
     if(args==0) args = new Thread_args();  
 
     args->ThreadName=ThreadName;
     args->func=func;
-    args->running=true;
+    args->running=start;
     args->kill=false;
 
     pthread_create(&(args->thread), NULL, Utilities::Thread, args);

src/DataModelBase/Utilities.h

@@ -60,7 +60,7 @@ namespace ToolFramework{
   public:
 
     Utilities(); ///< Simple constructor
-    Thread_args* CreateThread(std::string ThreadName,  void (*func)(Thread_args*), Thread_args* args); ///< Create a thread with more complicated data exchange definned by arguments
+    Thread_args* CreateThread(std::string ThreadName,  void (*func)(Thread_args*), Thread_args* args, bool start=true); ///< Create a thread with more complicated data exchange definned by arguments
     bool KillThread(Thread_args* &args); ///< Kill a thread assosiated to args
     bool KillThread(std::string ThreadName); ///< Kill a thread by name
 

src/Store/BinaryStream.cpp

@@ -452,16 +452,26 @@ void BinaryStream::zerr(int ret){
 #endif
 }
 
+size_t BinaryStream::Size(){
+
+  return buffer.size();
+  
+}
+
+
 bool SerialisableObject::SerialiseWrapper(BinaryStream &bs){
   //  if(!m_serialise) return false; //not sure i should ahve a serialise flag, causes major issues with empty mapps and vector elements!!!! so remove. People wouldnt be calling serialise method if they didnt want to serialse
-  //std::cout<<"in serialise wrapper"<<std::endl;
+  /*
+  std::cout<<"in serialise wrapper"<<std::endl;
   if(bs.m_write){
-    if(!(bs << GetVersion())) return false;
+    //   if(!(bs << GetVersion())) return false;
   }
   else{
     std::string version="";
     if(!(bs >> version)) return false;
     if(version!=GetVersion()) return false;
   }
+  */
   return Serialise(bs);
 }
+

src/Store/BinaryStream.h

@@ -39,7 +39,8 @@ namespace ToolFramework{
     bool Print();
     bool Serialise(BinaryStream &bs);  
     std::string GetVersion();
-    
+    size_t Size();
+      
     enum_endpoint m_endpoint;
     FILE* pfile;
 #ifdef ZLIB

src/Store/SerialisableObject.h

@@ -22,9 +22,8 @@ namespace ToolFramework{
 
   public:
     virtual ~SerialisableObject(){};
-    bool SerialiseWrapper(BinaryStream &bs);
+    virtual bool SerialiseWrapper(BinaryStream &bs);
     virtual bool Serialise(BinaryStream &bs)=0;
-    virtual std::string GetVersion()=0;
     virtual bool Print()=0; ///< Simple virtual Pritn function to ensure inhereted classes have one
     // virtual ~SerialisableObject(){}; ///< Destructor
     //bool m_serialise; ///< Denotes if the calss should be serialised or not when added to a BoostStore. 

src/Store/TaggedSerialisableObject.h

@@ -0,0 +1,89 @@
+#ifndef TAGGED_SERIALISABLE_OBJECT_H
+#define TAGGED_SERIALISABLE_OBJECT_H
+
+#include <BinaryStream.h>
+#include <SerialisableObject.h>
+
+
+
+//fixme use zie_t for sizes but have todo in binary stream as well;
+
+namespace ToolFramework{
+
+  class Tag : public SerialisableObject{
+
+  public:
+
+    //unsigned int size = 0;
+    size_t size = 0;
+    std::string type = "";
+    unsigned int version = 0;
+    
+    bool Print(){
+      
+      std::cout<<"size:type:version = "<<size<<":"<<type<<":"<<version<<std::endl;
+      
+      return true;
+    }     
+
+    bool Serialise(BinaryStream &bs){
+
+      if(!(bs & type)) return false;
+      if(!(bs & version)) return false;
+      if(!(bs & size)) return false;
+
+      return true;
+    }
+    
+    void Skip(BinaryStream &bs){
+      
+      bs.Bseek(size, SEEK_CUR);
+      
+    }
+
+    
+  };
+
+
+  class TaggedSerialisableObject : public SerialisableObject{
+
+  public:
+
+    virtual std::string GetType()=0;
+    unsigned int GetSize(){
+
+      BinaryStream bs;
+      Serialise(bs);
+      return bs.Size();
+    }
+    virtual unsigned int GetVersion()=0;
+    bool SerialiseWrapper(BinaryStream &bs){
+
+      if(bs.m_write){
+	//size_t size= GetSize();
+	unsigned int version = GetVersion();
+	if(!(bs << GetType())) return false;    
+	if(!(bs << version)) return false;
+	//if(!(bs << size)) return false;
+	BinaryStream tmp_bs;
+	Serialise(tmp_bs);
+	return bs << tmp_bs;
+      }
+
+      return Serialise(bs);
+      
+      
+    }
+    
+
+
+  private:
+    
+    
+    
+    
+  };
+  
+}
+
+#endif