S3FC project page

S3FC home page

---

               

---

s3_streamable.h

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#ifndef S3_STREAMABLE_H
#define S3_STREAMABLE_H

#include <s3fc/s3_macros.h>

#include <cstring>
#include <vector>
#include <string>
#include <complex>

class s3_pack_buffer
{
  protected:
   size_t capacity;
   //   size_t size;
   size_t pos;
   unsigned char* buf;
   bool own_storage;
  public:
   s3_pack_buffer(size_t n_capacity = 0);
   s3_pack_buffer(void* n_buf,
        size_t n_size);
   ~s3_pack_buffer();
   void reset();
   const s3_pack_buffer& operator+=(int n) const;
   s3_pack_buffer& operator+=(int n);
   const void* get_buffer() const;
   void* get_buffer();
   const void* get_current() const;
   void* get_current();
   void set_capacity(size_t n);
   size_t get_size() const;
   void copy_in(const void* src, size_t n);
   void copy_out(void* dst, size_t n) const;
  protected:
   void enlarge(size_t n);
};

class s3_typegroup_pod { };

template<typename T> 
struct s3_streamable_helper_pod
{
   static void pack(const T &t, s3_pack_buffer& b);
   static void unpack(T &t, const s3_pack_buffer& b);
   static void pack_array(const T* const &t, 
           s3_pack_buffer& b, 
           const size_t& n);
   static void unpack_array(T* &t, 
             const s3_pack_buffer& b,
             bool inplace);
};


class s3_typegroup_streamable { };

template<typename T> 
struct s3_streamable_helper_streamable
{
   static void pack(const T &t,
          s3_pack_buffer& b);
   static void unpack(T &t, 
            const s3_pack_buffer& b);
};

class s3_typegroup_stl { };

template<typename T> 
struct s3_streamable_helper_stl
{
   //
   static void pack(const T& t,
          s3_pack_buffer& b);
   //
   static void unpack(T& t,
            const s3_pack_buffer& b);
};

class s3_typegroup_other { };

template<typename T> struct s3_streamable_helper_other;
 
#ifdef S3_STREAMABLE_USE_PTS

template<typename T> struct s3_typegroup_traits
{
   typedef s3_typegroup_streamable typegroup;
};

#define S3_TYPEGROUP_TRAITS_POD(T) template<> \
struct s3_typegroup_traits<T > \
   { typedef s3_typegroup_pod typegroup; };

#define S3_TYPEGROUP_TRAITS_STREAMABLE(T) template<> \
struct s3_typegroup_traits<T > \
   { typedef s3_typegroup_streamable typegroup; };

#define S3_TYPEGROUP_TRAITS_STREAMABLE_1(T) \
template<typename T1> \
struct s3_typegroup_traits<T<T1> > \
   { typedef s3_typegroup_streamable typegroup; };

#define S3_TYPEGROUP_TRAITS_OTHER(T)\
template<> \
struct s3_typegroup_traits<T > \
   { typedef s3_typegroup_other typegroup; };

#define S3_TYPEGROUP_TRAITS_STL_1(T) \
template<typename T1> \
struct s3_typegroup_traits<T<T1> > \
   { typedef s3_typegroup_stl typegroup; };

template<typename T, typename typegroup = typename s3_typegroup_traits<T>::typegroup > struct s3_streamable_dispatcher;

// dispatcher specialisation for s3_typegroup_pod - forward all calls
//  to s3_streamable_helper_pod
template<typename T>
struct s3_streamable_dispatcher<T, s3_typegroup_pod>
{
   //
   static void pack(const T &t, s3_pack_buffer& b)
   {
      s3_streamable_helper_pod<T>::pack(t, b);
   }
   //
   static void unpack(T& t, const s3_pack_buffer& b)
   {
      s3_streamable_helper_pod<T>::unpack(t, b);
   }
   //
   static void pack_array(const T* const &t, 
           s3_pack_buffer& b, 
           const size_t& n)
   {
      s3_streamable_helper_pod<T>::pack_array(t, b, n);
   }
   //
   static void unpack_array(T* &t, 
             const s3_pack_buffer& b,
             bool inplace)
   {
      s3_streamable_helper_pod<T>::unpack_array(t, b, inplace);
   }
};

// dispatcher specialisation for s3_typegroup_streamable - forward
// to *member* functions of s3_streamable
template<typename T>
struct s3_streamable_dispatcher<T, s3_typegroup_streamable>
{
   //
   static void pack(const T &t, 
          s3_pack_buffer& b)
   {
      s3_streamable_helper_streamable<T>::pack(t, b);
   }
   //
   static void unpack(T& t, 
            const s3_pack_buffer& b)
   {
      s3_streamable_helper_streamable<T>::unpack(t, b);
   }
};

// dispatcher specialisation for s3_typegroup_other - forward
// to specialised s3_streamable_helper_other<T>
template<typename T>
struct s3_streamable_dispatcher<T, s3_typegroup_other>
{
   //
   static void pack(const T &t, s3_pack_buffer& b)
   {
      s3_streamable_helper_other<T>::pack(t, b);
   }
   //
   static void unpack(T& t, const s3_pack_buffer& b)
   {
      s3_streamable_helper_other<T>::unpack(t, b);
   }
};

// dispatcher specialisation for s3_typegroup_stl - forward 
// to s3_streamable_helper_stl
template<typename T>
struct s3_streamable_dispatcher<T, s3_typegroup_stl>
{
   //
   static void pack(const T &t, s3_pack_buffer& b)
   {
      s3_streamable_helper_stl<T>::pack(t, b);
   }
   //
   static void unpack(T& t, const s3_pack_buffer& b)
   {
      s3_streamable_helper_stl<T>::unpack(t, b);
   }
};

#else

template<typename T> struct s3_typegroup_traits
{
   static inline s3_typegroup_streamable typegroup() 
   {
      return s3_typegroup_streamable();
   }
};

#define S3_TYPEGROUP_TRAITS_POD(T) template<> \
struct s3_typegroup_traits<T > { \
   static inline s3_typegroup_pod typegroup() { \
   return s3_typegroup_pod(); \
   } \
 };

#define S3_TYPEGROUP_TRAITS_STREAMABLE(T) template<> \
struct s3_typegroup_traits<T > { \
   static inline s3_typegroup_streamable typegroup() { \
   return s3_typegroup_streamable(); \
   } \
 };

#define S3_TYPEGROUP_TRAITS_STREAMABLE_1(T) \
template<typename T1> \
struct s3_typegroup_traits<T<T1> > { \
   static inline s3_typegroup_streamable typegroup() { \
   return s3_typegroup_streamable(); \
   } \
 };

#define S3_TYPEGROUP_TRAITS_OTHER(T)\
template<> \
struct s3_typegroup_traits<T > { \
   static inline s3_typegroup_other typegroup() { \
   return s3_typegroup_other(); \
   } \
 };

#define S3_TYPEGROUP_TRAITS_STL_1(T) \
template<typename T1> \
struct s3_typegroup_traits<T<T1> > { \
   static inline s3_typegroup_stl typegroup() { \
   return s3_typegroup_stl(); \
   } \
 };

// dispatcher specialisation for s3_typegroup_pod - forward all calls
//  to s3_streamable_helper_pod
template<typename T>
struct s3_streamable_dispatcher
{
   /*
    * Dispatchers invoked by s3_streamable: resolve typegroup from type and
    * forward to typegroup-specific dispatcher.
    */
   //
   static void pack(const T& t, s3_pack_buffer& b)
   {
      pack(t, b, s3_typegroup_traits<T>::typegroup());
   }
   //
   static void unpack(T& t, const s3_pack_buffer& b)
   {
      unpack(t, b, s3_typegroup_traits<T>::typegroup());
   }
   //
   static void pack_array(const T* const &t, 
           s3_pack_buffer& b, 
           const size_t& n)
   {
      pack_array(t, b, n, s3_typegroup_traits<T>::typegroup());
   }
   //
   static void unpack_array(T* &t, 
             const s3_pack_buffer& b,
             bool inplace)
   {
      unpack_array(t, b, inplace, s3_typegroup_traits<T>::typegroup());
   }

   /* Dispatchers for s3_typegroup_pod */
   //
   static void pack(const T &t, s3_pack_buffer& b,
          const s3_typegroup_pod&)
   {
      s3_streamable_helper_pod<T>::pack(t, b);
   }
   //
   static void unpack(T& t, const s3_pack_buffer& b,
            const s3_typegroup_pod&)
   {
      s3_streamable_helper_pod<T>::unpack(t, b);
   }
   //
   static void pack_array(const T* const &t, 
           s3_pack_buffer& b, 
           const size_t& n,
           const s3_typegroup_pod&)
   {
      s3_streamable_helper_pod<T>::pack_array(t, b, n);
   }
   //
   static void unpack_array(T* &t, 
             const s3_pack_buffer& b,
             bool inplace,
             const s3_typegroup_pod&)
   {
      s3_streamable_helper_pod<T>::unpack_array(t, b, inplace);
   }

   /* Dispatchers for s3_typegroup_streamable   */   
   //
   static void pack(const T &t, s3_pack_buffer& b,
          const s3_typegroup_streamable&)
   {
      s3_streamable_helper_streamable<T>::pack(t, b);
   }
   //
   static void unpack(T& t, const s3_pack_buffer& b,
            const s3_typegroup_streamable&)
   {
      s3_streamable_helper_streamable<T>::unpack(t, b);
   }

   /* Dispatchers for s3_typegroup_other  */
   //
   static void pack(const T &t, s3_pack_buffer& b,
          const s3_typegroup_other&)
   {
      s3_streamable_helper_other<T>::pack(t, b);
   }
   //
   static void unpack(T& t, const s3_pack_buffer& b,
            const s3_typegroup_other&)
   {
      s3_streamable_helper_other<T>::unpack(t, b);
   }

   /* Dispatchers for s3_typegroup_stl */
   //
   static void pack(const T &t, s3_pack_buffer& b,
          const s3_typegroup_stl&)
   {
      s3_streamable_helper_stl<T>::pack(t, b);
   }
   //
   static void unpack(T& t, const s3_pack_buffer& b,
            const s3_typegroup_stl&)
   {
      s3_streamable_helper_stl<T>::unpack(t, b);
   }
};

#endif

template<>
struct s3_streamable_helper_other<std::string>
{
   static void pack(const std::string &s, 
          s3_pack_buffer& b);
   static void unpack(std::string &s, 
            const s3_pack_buffer& b);
};

// string is in typegroup other
S3_TYPEGROUP_TRAITS_OTHER(std::string);

// some POD types
S3_TYPEGROUP_TRAITS_POD(bool);
S3_TYPEGROUP_TRAITS_POD(char);
S3_TYPEGROUP_TRAITS_POD(unsigned char);
S3_TYPEGROUP_TRAITS_POD(short);
S3_TYPEGROUP_TRAITS_POD(unsigned short);
S3_TYPEGROUP_TRAITS_POD(int);
S3_TYPEGROUP_TRAITS_POD(unsigned int);
S3_TYPEGROUP_TRAITS_POD(long int);
S3_TYPEGROUP_TRAITS_POD(unsigned long int);
S3_TYPEGROUP_TRAITS_POD(float);
S3_TYPEGROUP_TRAITS_POD(double);
S3_TYPEGROUP_TRAITS_POD(std::complex<float>);
S3_TYPEGROUP_TRAITS_POD(std::complex<double>);

S3_TYPEGROUP_TRAITS_STL_1(std::vector);

#define S3_DECLARE_MAGIC_STRING virtual const char* get_magic_string() const

#define S3_DEFINE_MAGIC_STRING(C)              \
     const char* C::get_magic_string() const   \
     { return  #C; }
 
#define S3_DEFINE_MAGIC_STRING_T(C,T)           \
     template <typename T>                      \
     const char* C<T>::get_magic_string() const \
     { return  #C; }

class s3_streamable
{
  public:
   virtual const char* get_magic_string() const = 0;
   virtual void pack(s3_pack_buffer &v) const = 0;
   virtual void unpack(const s3_pack_buffer &v) = 0;
   template<typename T>
   static void pack(T const &t, 
          s3_pack_buffer &b);
   template<typename T>
   static void unpack(T const &t,
            const s3_pack_buffer &b);
   template<typename T>
   static void pack_array(T* const &t, 
           s3_pack_buffer& b, 
           size_t n);
   template<typename T>
   static void unpack_array(T* const &t, 
             const s3_pack_buffer& b,
             bool inplace);
   template<typename T>
   static void pack_array(const T* const &t, 
           s3_pack_buffer& b, 
           size_t n);
   template<typename T>
   static void unpack_array(const T* const &t, 
             const s3_pack_buffer& b,
             bool inplace);
  public:
#ifdef S3_VERBOSE_PACKING

   static void pack_string(const std::string& str,
            s3_pack_buffer& b);
   static std::string unpack_string(const s3_pack_buffer& b);
#endif
  private:
   // these should NEVER succeed when called - pointers may 
   // *not* be packed (yes, really).
   template<typename T>
   static void pack(const T* t, s3_pack_buffer& b, size_t n);
   template<typename T>
   static void unpack(const T* &t, const s3_pack_buffer& b);
   template<typename T>
   static void unpack(T* &t, const s3_pack_buffer& b);
   template<typename T>
   static void unpack(T* const &t, const s3_pack_buffer& b);
   template<typename T>
   static void unpack(const T* const &t, const s3_pack_buffer& b);
};

#include <s3fc/s3_streamable.tcc>

#endif

---

Send comments to: s3fc@stonethree.com