S3FC project page

S3FC home page

---

               

---

s3_streamable.tcc

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_TCC 
#define S3_STREAMABLE_TCC

#include <s3fc/s3_streamable.h>
#include <sstream>
#include <typeinfo>

//
template<typename T>
void s3_streamable_helper_pod<T>::pack(const T& t,
                   s3_pack_buffer& b)
{
#ifdef S3_VERBOSE_PACKING
   std::stringstream str;
   str << "POD " << typeid(T).name() << ":";
   s3_streamable::pack_string(str.str(), b);
#endif
   b.copy_in(&t, sizeof(T));
}

//
template<typename T>
void s3_streamable_helper_pod<T>::unpack(T &t, 
                const s3_pack_buffer& b)
{
#ifdef S3_VERBOSE_PACKING
   s3_streamable::unpack_string(b);
#endif   
   b.copy_out(&t, sizeof(T));
}

//
template<typename T>
void s3_streamable_helper_pod<T>::pack_array(const T* const &t,
                    s3_pack_buffer& b,
                    const size_t& n)
{
#ifdef S3_VERBOSE_PACKING
   std::stringstream str;
   str << "POD " << typeid(T).name() << "[" << n << "]:";
   s3_streamable::pack_string(str.str(), b);
#endif
   // write size
   b.copy_in(&n, sizeof(size_t));
   // write data
   b.copy_in(t, sizeof(T)*n);
}

//
template<typename T>
void s3_streamable_helper_pod<T>::unpack_array(T* &t, 
                      const s3_pack_buffer& b,
                      bool inplace)
{
#ifdef S3_VERBOSE_PACKING
   s3_streamable::unpack_string(b);
#endif   
   // read size
   size_t n;
   b.copy_out(&n, sizeof(size_t));
   
   if ( ! inplace ) // alloc memory and swing pointer
   {
      // FIXME or CHECKME: Valgrind reports that this allocation is never deallocated
      t = new T[n];
   }
   // copy from packed data
   b.copy_out(t, sizeof(T)*n);
}

//
template<typename T>
void s3_streamable_helper_streamable<T>::pack(const T& t,
                     s3_pack_buffer &b)
{
#ifdef S3_VERBOSE_PACKING
   std::stringstream str;
   str << "s3_streamable (" << t.get_magic_string() << "):";
   s3_streamable::pack_string(str.str(), b);
#endif
   t.pack(b);
}

//
template<typename T>
void s3_streamable_helper_streamable<T>::unpack(T& t,
                  const s3_pack_buffer &b)
{
#ifdef S3_VERBOSE_PACKING
   s3_streamable::unpack_string(b);
#endif
   t.unpack(b);
}

// STL Container pack
template<typename T>
void s3_streamable_helper_stl<T>::pack(const T& t,
                   s3_pack_buffer& b)
{
   // t.size(), t.begin() and t.end() should be valid for T
   typename T::size_type s = t.size();
   s3_streamable::pack(s, b);
   if ( s != 0 )
   {
      for (typename T::const_iterator ptr = t.begin();
      ptr != t.end();
      ptr++ )
      {
    // recurse
    s3_streamable::pack(*ptr, b);
      }
   }
}

// STL Container unpack
template<typename T>
void s3_streamable_helper_stl<T>::unpack(T& t,
                const s3_pack_buffer& b)
{
   // t.size(), t.begin(), t.end(), t.clear() should be valid for T
   t.clear();
   typename T::size_type s;
   s3_streamable::unpack(s, b);
   if ( s != 0 )
   {
      unsigned int ecnt = s;
      while (ecnt--) 
      {
    typename T::value_type v;
    // recurse
    s3_streamable::unpack(v, b);
    t.insert(t.end(), v);
      }
   }
}

// pack
template<typename T>
void s3_streamable::pack(T const &t, s3_pack_buffer &b)
{
   s3_streamable_dispatcher<T>::pack(t, b);
}

// unpack
template<typename T>
void s3_streamable::unpack(T const &t, const s3_pack_buffer &b)
{
   s3_streamable_dispatcher<T>::unpack(const_cast<T&>(t), b);
}

// POD T* pack_array
template<typename T>
void s3_streamable::pack_array(T* const &t, s3_pack_buffer& b, size_t n)
{
   s3_streamable_dispatcher<T>::pack_array(t, b, n);
}

// POD T* unpack array
template<typename T>
void s3_streamable::unpack_array(T* const &t, 
             const s3_pack_buffer& b, 
             bool inplace)
{
   s3_streamable_dispatcher<T>::unpack_array(const_cast<T*&>(t), b, inplace);
}

// POD const T* pack_array 
template<typename T>
void s3_streamable::pack_array(const T* const &t, s3_pack_buffer& b, size_t n)
{
   s3_streamable_dispatcher<T>::pack_array(const_cast<T*>(t), b, n);
}

// POD const T* unpack array
template<typename T>
void s3_streamable::unpack_array(const T* const &t, 
             const s3_pack_buffer& b,
             bool inplace)
{
   s3_streamable_dispatcher<T>::unpack_array(const_cast<T*&>(t), b, inplace);
}

#endif

---

Send comments to: s3fc@stonethree.com