Strict C++ compliance.

[asdcplib.git] / src / KM_util.h

diff --git a/src/KM_util.h b/src/KM_util.h
index 5ca3baa5d5218db8d48fab31140f7adb88257320..d8b9bb3ddd2b82b800928c1fe92f622116080518 100755 (executable)
--- a/src/KM_util.h
+++ b/src/KM_util.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2006, John Hurst
+Copyright (c) 2005-2008, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -40,6 +40,8 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace Kumu
 {
+  // The version number declaration and explanation are in ../configure.ac
+  const char* Version();
 
   // a class that represents the string form of a value
   template <class T, int SIZE = 16>
@@ -170,11 +172,59 @@ namespace Kumu
     {
     public:
       virtual ~IArchive(){}
-      virtual bool HasValue() const = 0;
-      virtual bool Archive(MemIOWriter* Writer) const = 0;
-      virtual bool Unarchive(MemIOReader* Reader) = 0;
+      virtual bool   HasValue() const = 0;
+      virtual ui32_t ArchiveLength() const = 0;
+      virtual bool   Archive(MemIOWriter* Writer) const = 0;
+      virtual bool   Unarchive(MemIOReader* Reader) = 0;
     };
 
+  //
+  template <class T>
+  class ArchivableList : public std::list<T>, public IArchive
+    {
+    public:
+      ArchivableList() {}
+      virtual ~ArchivableList() {}
+
+      bool HasValue() const { return ! this->empty(); }
+
+      ui32_t ArchiveLength() const
+      {
+       ui32_t arch_size = sizeof(ui32_t);
+
+       typename ArchivableList<T>::const_iterator i = this->begin();
+       for ( ; i != this->end(); i++ )
+         arch_size += i->ArchiveLength();
+
+       return arch_size;
+      }
+
+      bool Unarchive(Kumu::MemIOReader* Reader)
+       {
+         if ( Reader == 0 ) return false;
+         ui32_t read_size = 0;
+         if ( ! Reader->ReadUi32BE(&read_size) ) return false;
+         for ( ui32_t i = 0; i < read_size; i++ )
+           {
+             T TmpTP;
+             if ( ! TmpTP.Unarchive(Reader) ) return false;
+             this->push_back(TmpTP);
+           }
+
+         return true;
+       }
+
+      bool Archive(Kumu::MemIOWriter* Writer) const
+       {
+         if ( Writer == 0 ) return false;
+         if ( ! Writer->WriteUi32BE(this->size()) ) return false;
+         typename ArchivableList<T>::const_iterator i = this->begin();
+         for ( ; i != this->end(); i++ )
+           if ( ! i->Archive(Writer) ) return false;
+
+         return true;
+       }
+    };
 
   //
   // the base of all identifier classes, Identifier is not usually used directly
@@ -190,7 +240,7 @@ namespace Kumu
     public:
       Identifier() : m_HasValue(false) { memset(m_Value, 0, SIZE); }
       Identifier(const byte_t* value) : m_HasValue(true) { memcpy(m_Value, value, SIZE); }
-      Identifier(const Identifier& rhs) {
+      Identifier(const Identifier& rhs) : IArchive() {
        m_HasValue = rhs.m_HasValue;
        memcpy(m_Value, rhs.m_Value, SIZE);
       }
@@ -256,6 +306,8 @@ namespace Kumu
 
       inline bool HasValue() const { return m_HasValue; }
 
+      inline ui32_t ArchiveLength() const { return SIZE; }
+
       inline bool Unarchive(Kumu::MemIOReader* Reader) {
        m_HasValue = Reader->ReadRaw(m_Value, SIZE);
        return m_HasValue;
@@ -266,42 +318,6 @@ namespace Kumu
       }
     };
 
-  //
-  template <class T>
-  class IdentifierList : public std::list<T>, public IArchive
-    {
-    public:
-      IdentifierList() {}
-      virtual ~IdentifierList() {}
-
-      bool HasValue() const { return ! this->empty(); }
-
-      bool Unarchive(Kumu::MemIOReader* Reader)
-       {
-         if ( Reader == 0 )return false;
-         ui32_t read_size = 0;
-         if ( ! Reader->ReadUi32BE(&read_size) ) return false;
-         for ( ui32_t i = 0; i < read_size; i++ )
-           {
-             T TmpTP;
-             if ( ! TmpTP.Unarchive(Reader) ) return false;
-             this->push_back(TmpTP);
-           }
-
-         return true;
-       }
-
-      bool Archive(Kumu::MemIOWriter* Writer) const
-       {
-         if ( Writer == 0 )return false;
-         if ( ! Writer->WriteUi32BE(this->size()) ) return false;
-         typename IdentifierList<T>::const_iterator i = this->begin();
-         for ( ; i != this->end(); i++ )
-           if ( ! (*i).Archive(Writer) ) return false;
-
-         return true;
-       }
-    };
 
   // UUID
   //
@@ -388,9 +404,10 @@ namespace Kumu
       // | 16 bits int, big-endian |    8 bits   |   8 bits  |   8 bits   |    8 bits    |    8 bits    |
       // |        Year A.D         | Month(1-12) | Day(1-31) | Hour(0-23) | Minute(0-59) | Second(0-59) |
       //
-      virtual bool HasValue() const;
-      virtual bool Archive(MemIOWriter* Writer) const;
-      virtual bool Unarchive(MemIOReader* Reader);
+      virtual bool   HasValue() const;
+      virtual ui32_t ArchiveLength() const { return 8L; }
+      virtual bool   Archive(MemIOWriter* Writer) const;
+      virtual bool   Unarchive(MemIOReader* Reader);
     };
 
   //
@@ -408,8 +425,7 @@ namespace Kumu
       ByteString(ui32_t cap);
       virtual ~ByteString();
 
-      // Sets the size of the internally allocated buffer.
-      // Resets content Size to zero.
+      // Sets or resets the size of the internally allocated buffer.
       Result_t Capacity(ui32_t cap);
 
       Result_t Append(const ByteString&);
@@ -437,6 +453,8 @@ namespace Kumu
 
       inline virtual bool HasValue() const { return m_Length > 0; }
 
+      inline virtual ui32_t ArchiveLength() const { return m_Length; }
+
       inline virtual bool Archive(MemIOWriter* Writer) const {
        assert(Writer);
        if ( ! Writer->WriteUi32BE(m_Length) ) return false;
@@ -446,9 +464,11 @@ namespace Kumu
 
       inline virtual bool Unarchive(MemIOReader* Reader) {
        assert(Reader);
-       if ( ! Reader->ReadUi32BE(&m_Length) ) return false;
-       if ( KM_FAILURE(Capacity(m_Length)) ) return false;
-       if ( ! Reader->ReadRaw(m_Data, m_Length) ) return false;
+       ui32_t tmp_len;
+       if ( ! Reader->ReadUi32BE(&tmp_len) ) return false;
+       if ( KM_FAILURE(Capacity(tmp_len)) ) return false;
+       if ( ! Reader->ReadRaw(m_Data, tmp_len) ) return false;
+       m_Length = tmp_len;
        return true;
       }
     };