BugID: 1075

Added support for STL containers

LCS/Blob/include/Blob/BlobSTL.h

+//# BlobSTL.h: Blob handling for STL sequences
+//#
+//# Copyright (C) 2007
+//# ASTRON (Netherlands Foundation for Research in Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
+//#
+//# This program is free software; you can redistribute it and/or modify
+//# it under the terms of the GNU General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or
+//# (at your option) any later version.
+//#
+//# This program is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License
+//# along with this program; if not, write to the Free Software
+//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//#
+//# $Id$
+
+#ifndef LOFAR_BLOB_BLOBSTL_H
+#define LOFAR_BLOB_BLOBSTL_H
+
+// \file
+// Blob handling for STL sequences
+
+#include <Blob/BlobOStream.h>
+#include <Blob/BlobIStream.h>
+#include <map>
+#include <list>
+#include <set>
+#include <queue>
+#include <deque>
+
+namespace LOFAR
+{
+
+// \ingroup %pkgname%
+
+  // Define functions to write a map into a blob and to read it back.
+  // The map is preceeded by the header 'map<T,U>', where T and U are
+  // the type names as defined in TypeNames.h.
+  // Type names are only defined for the basic types. Other types
+  // are set to 'unknown'.
+  //   <group>
+  // \name Write a map.
+  template<typename T, typename U>
+  BlobOStream& operator<< (BlobOStream&, const std::map<T,U>&);
+
+  // \name Read back a map.
+  template<typename T, typename U>
+  BlobIStream& operator>> (BlobIStream&, std::map<T,U>&);
+  //   </group>
+
+
+  // Define helper functions to write any STL sequence into a blob and to
+  // read it back.
+  // The sequence is preceeded by the header 'array<T>', where T is
+  // the type name of Seq::value_type as defined in TypeNames.h.
+  // Type names are only defined for the basic types. Other types
+  // are set to 'unknown'.
+  // All sequences are written in the same way (as 1-dim arrays). It means
+  // that they can be read back using any other sequence type.
+  //   <group>
+  // \name Write a sequence.
+  template<typename Seq>
+  void sequenceToBlob (BlobOStream&, const Seq&);
+
+  // \name Read back a sequence.
+  template<typename Seq>
+  void sequenceFromBlob (BlobOStream&, const Seq&);
+  //   </group>
+
+
+  // Define helper functions to write an STL sequence into a blob and to
+  // read it back.
+  // The sequence is preceeded by the header 'array<T>', where T is
+  // the type name of T as defined in TypeNames.h.
+  // Type names are only defined for the basic types. Other types
+  // are set to 'unknown'.
+  // All sequences are written in the same way (as 1-dim arrays). It means
+  // that they can be read back in any other sequence type (including
+  // AIPS++ and Blitz arrays).
+  // <note> STL vectors are handled by BlobArray.h. </note>
+  //   <group>
+  // \name Write a list.
+  template<typename T>
+  BlobOStream& operator<< (BlobOStream& bs, const std::list<T>& seq)
+    { sequenceToBlob (bs, seq);  return bs; }
+
+  // \name Read back a list.
+  template<typename T>
+  BlobIStream& operator>> (BlobIStream& bs, std::list<T>& seq)
+    { sequenceFromBlob (bs, seq);  return bs; }
+
+  // \name Write a set.
+  template<typename T>
+  BlobOStream& operator<< (BlobOStream& bs, const std::set<T>& seq)
+    { sequenceToBlob (bs, seq);  return bs; }
+
+  // \name Read back a set.
+  template<typename T>
+  BlobIStream& operator>> (BlobIStream& bs, std::set<T>& seq)
+    { sequenceFromBlob (bs, seq);  return bs; }
+
+  // \name Write a queue.
+  template<typename T>
+  BlobOStream& operator<< (BlobOStream& bs, const std::queue<T>& seq)
+    { sequenceToBlob (bs, seq);  return bs; }
+
+  // \name Read back a queue.
+  template<typename T>
+  BlobIStream& operator>> (BlobIStream& bs, std::queue<T>& seq)
+    { sequenceFromBlob (bs, seq);  return bs; }
+
+  // \name Write a deque.
+  template<typename T>
+  BlobOStream& operator<< (BlobOStream& bs, const std::deque<T>& seq)
+    { sequenceToBlob (bs, seq);  return bs; }
+
+  // \name Read back a deque.
+  template<typename T>
+  BlobIStream& operator>> (BlobIStream& bs, std::deque<T>& seq)
+    { sequenceFromBlob (bs, seq);  return bs; }
+  //   </group>
+
+} // end namespace LOFAR
+
+
+#include <Blob/BlobSTL.tcc>
+
+using LOFAR::operator<<;
+using LOFAR::operator>>;
+
+#endif

LCS/Blob/include/Blob/BlobSTL.tcc

+//# BlobSTL.tcc: Blob handling for STLs
+//#
+//# Copyright (C) 2007
+//# ASTRON (Netherlands Foundation for Research in Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
+//#
+//# This program is free software; you can redistribute it and/or modify
+//# it under the terms of the GNU General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or
+//# (at your option) any later version.
+//#
+//# This program is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License
+//# along with this program; if not, write to the Free Software
+//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//#
+//# $Id$
+
+#ifndef LOFAR_BLOB_BLOBSTL_TCC
+#define LOFAR_BLOB_BLOBSTL_TCC
+
+#include <Blob/BlobSTL.h>
+#include <Blob/BlobArray.h>
+#include <Common/TypeNames.h>
+
+namespace LOFAR
+{
+  template<typename T, typename U>
+  BlobOStream& operator<< (BlobOStream& bs, const std::map<T,U>& m)
+  {
+    bs.putStart ("map<" + typeName((T*)0) + ',' + typeName((U*)0) + '>', 1);
+    bs << static_cast<uint32>(m.size());
+    for (typename std::map<T,U>::const_iterator it=m.begin();
+         it!=m.end();
+         ++it) {
+      bs << it->first << it->second;
+    }
+    bs.putEnd();
+    return bs;
+  }
+
+  template<typename T, typename U>
+  BlobIStream& operator>> (BlobIStream& bs, std::map<T,U>& m)
+  {
+    bs.getStart ("map<" + typeName((T*)0) + ',' + typeName((U*)0) + '>');
+    m.clear();
+    uint32 size;
+    bs >> size;
+    T t;
+    U u;
+    for (uint32 i=0; i<size; ++i) {
+      bs >> t >> u;
+      m[t] = u;
+    }
+    bs.getEnd();
+    return bs;
+  }
+
+  template<typename Seq>
+  void sequenceToBlob (BlobOStream& bs, const Seq& s)
+  {
+    uint32 n = s.size();
+    putBlobArrayHeader (bs, true,
+                        LOFAR::typeName((const typename Seq::value_type**)0),
+                        &n, 1, true, 1);
+    for (typename Seq::const_iterator it=s.begin();
+         it!=s.end();
+         ++it) {
+      bs << *it;
+    }
+    bs.putEnd();
+  }
+
+  template<typename Seq>
+  void sequenceFromBlob (BlobIStream& bs, Seq& s)
+  {
+    bs.getStart (LOFAR::typeName((const typename Seq::value_type**)0));
+    bool fortranOrder;
+    uint16 ndim;
+    uint nalign = getBlobArrayStart (bs, fortranOrder, ndim);
+    ASSERT(ndim == 1);
+    uint32 size;
+    getBlobArrayShape (bs, &size, 1, false, nalign);
+    typename Seq::value_type t;
+    s.clear();
+    for (uint32 i=0; i<size; ++i) {
+      bs >> t;
+      s.push_back (t);
+    }
+    bs.getEnd();
+  }
+
+} // end namespace LOFAR
+
+#endif

LCS/Blob/include/Blob/Makefile.am

@@ -21,6 +21,8 @@ pkginclude_HEADERS = \
         BlobOBufString.h \
         BlobOBufVector.h \
         BlobOStream.h \
+	BlobSTL.h \
+	BlobSTL.tcc \
 	BlobStreamable.h \
         BlobString.h \
         BlobStringTraits.h \

LCS/Blob/test/Makefile.am

-check_PROGRAMS	      =	tBlobString tBlobStream tBlobArray tBlobField \
-			tBlobAipsIO tKeyValueMap
+check_PROGRAMS	      =	tBlobString tBlobStream tBlobArray tBlobSTL \
+			tBlobField tBlobAipsIO tKeyValueMap
 
 # programs to run through supplied checktools
-CHECKTOOLPROGS	      =	tBlobString tBlobStream tBlobArray tBlobField \
-			tBlobAipsIO tKeyValueMap
-#ENDCHECKTOOLPROGS
+CHECKTOOLPROGS	      =	tBlobString tBlobStream tBlobArray tBlobSTL
+			tBlobField tBlobAipsIO tKeyValueMap
 
 TESTSCRIPTS = \
+          tBlobString_test.sh \
+          tBlobStream_test.sh \
 	  tBlobArray_test.sh \
+	  tBlobSTL_test.sh \
 	  tBlobField_test.sh \
-          tBlobStream_test.sh \
-          tBlobString_test.sh \
 	  tBlobAipsIO_test.sh \
 	  tKeyValueMap_test.sh 
 
@@ -33,6 +33,10 @@ tBlobArray_SOURCES		= tBlobArray.cc
 tBlobArray_LDADD		= ../src/libblob.la
 tBlobArray_DEPENDENCIES		= ../src/libblob.la $(LOFAR_DEPEND)
 
+tBlobSTL_SOURCES		= tBlobSTL.cc
+tBlobSTL_LDADD			= ../src/libblob.la
+tBlobSTL_DEPENDENCIES		= ../src/libblob.la $(LOFAR_DEPEND)
+
 tBlobField_SOURCES		= tBlobField.cc
 tBlobField_LDADD		= ../src/libblob.la
 tBlobField_DEPENDENCIES		= ../src/libblob.la $(LOFAR_DEPEND)

LCS/Blob/test/tBlobSTL.cc

+//# tBlobSTL.cc: Test program for BlobSTL functions
+//#
+//# Copyright (C) 2007
+//# ASTRON (Netherlands Foundation for Research in Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
+//#
+//# This program is free software; you can redistribute it and/or modify
+//# it under the terms of the GNU General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or
+//# (at your option) any later version.
+//#
+//# This program is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License
+//# along with this program; if not, write to the Free Software
+//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//#
+//# $Id$
+
+//# Always #include <lofar_config.h> first!
+#include <lofar_config.h>
+
+#include <Blob/BlobSTL.h>
+#include <Blob/BlobArray.h>
+#include <Blob/BlobOBufStream.h>
+#include <Blob/BlobIBufStream.h>
+#include <Blob/BlobOBufString.h>
+#include <Blob/BlobIBufString.h>
+#include <Blob/BlobOBufNull.h>
+#include <iostream>
+#include <fstream>
+
+using namespace LOFAR;
+
+void doOut (BlobOBuffer& bb)
+{
+  BlobOStream bs(bb);
+  bs.putStart ("test", 1);
+  // Write a vector and set into the blob.
+  std::vector<double> seq1(3);
+  seq1[0] = double(2);
+  seq1[1] = double(1e10);
+  seq1[2] = double(-3.1);
+  bs << seq1;
+  std::list<std::string> seq2;
+  seq2.push_back ("s1");
+  seq2.push_back ("st2");
+  bs << seq2;
+  // Write maps.
+  std::map<std::string, std::list<std::string> > m;
+  m["k1"] = seq2;
+  seq2.push_back ("str3");
+  m["k2"] = seq2;
+  bs << m;
+  std::map<int, std::vector<int> > m2;
+  bs << m2;                     // also test empty map
+  bs.putEnd();
+}
+
+void doIn (BlobIBuffer& bb)
+{
+  BlobIStream bs(bb);
+  bs.getStart ("test");
+  // Read the vector from the blob as a deque and check if it is correct.
+  std::deque<double> seq1;
+  seq1.push_back (1);          // should be cleared by operator>>
+  bs >> seq1;
+  ASSERT (seq1.size() == 3);
+  ASSERT (seq1[0] == double(2));
+  ASSERT (seq1[1] == double(1e10));
+  ASSERT (seq1[2] == double(-3.1));
+  // Read the list as a vector.
+  std::vector<std::string> seq2;
+  seq2.push_back ("");         // should be cleared by operator>>
+  bs >> seq2;
+  ASSERT (seq2.size() == 2);
+  ASSERT (seq2[0] == "s1");
+  ASSERT (seq2[1] == "st2");
+  // Read the first map.
+  std::map<std::string, std::vector<std::string> > m;
+  bs >> m;
+  std::map<std::string, std::vector<std::string> >::const_iterator it;
+  it = m.find("k1");
+  ASSERT (it != m.end());
+  ASSERT (it->second.size() == 2);
+  ASSERT (it->second[0] == "s1");
+  ASSERT (it->second[1] == "st2");
+  it = m.find("k2");
+  ASSERT (it != m.end());
+  ASSERT (it->second.size() == 3);
+  ASSERT (it->second[0] == "s1");
+  ASSERT (it->second[1] == "st2");
+  ASSERT (it->second[2] == "str3");
+  it = m.find("k3");
+  ASSERT (it == m.end());
+  // Read the second map.
+  std::map<int, std::list<int> > m2;
+  m2[1] = std::list<int>();    // should be cleared by operator>>
+  bs >> m2;
+  ASSERT (m2.empty());
+  bs.getEnd();
+}
+
+int main()
+{
+  try {
+    INIT_LOGGER("tBlobSTL");
+    {
+      {
+	// Create the blob in a file.
+	std::ofstream os ("tBlobArray_tmp.dat");
+	BlobOBufStream bob(os);
+        doOut (bob);
+      }
+      {
+	// Read it back from the file.
+	std::ifstream is ("tBlobArray_tmp.dat");
+	BlobIBufStream bib(is);
+	doIn (bib);
+      }
+    }
+    {
+      // Create the blob in memory.
+      BlobString str(BlobStringType(false));
+      BlobOBufString bob(str);
+      doOut (bob);
+      BlobIBufString bib(str);
+      doIn (bib);
+    }
+  } catch (std::exception& x) {
+    std::cout << "Unexpected exception: " << x.what() << std::endl;
+    return 1;
+  }
+  std::cout << "OK" << std::endl;
+  return 0;
+}
+

LCS/Blob/test/tBlobSTL_test.sh

+#!/bin/sh
+$lofar_sharedir/runtest.sh tBlobSTL 2>&1 > tBlobSTL_test.log