S3FC project page

S3FC home page

---

               

---

s3_streamable.cc

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.
 */


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

// dflt and init ctor - init with size (can and may be 0)
s3_pack_buffer::s3_pack_buffer(size_t n_capacity) :
   capacity(n_capacity),
   pos(0),
   buf(0),
   own_storage(true)
{
   if ( capacity )
   {
      buf = new unsigned char[capacity];
   }
}

// init ctor - init from _existing_ array
s3_pack_buffer::s3_pack_buffer(void* n_buf,
                size_t n_size) :
   capacity(n_size),
   pos(0),
   buf(static_cast<unsigned char*>(n_buf)),
   own_storage(false)
{
}

// dtor - dealloc buffer if we own it
s3_pack_buffer::~s3_pack_buffer()
{
   // _only_ blow storage if it's _our_ problem
   if ( own_storage )
   {
      delete[] buf;
   }
}

// reset position
void s3_pack_buffer::reset()
{
   pos = 0;
}

// const operator+=
const s3_pack_buffer& s3_pack_buffer::operator+=(int n) const
{
   CONST_OVERRIDE_THIS(s3_pack_buffer) operator+=(n);
   return *this;
}

// increment the current position by n
s3_pack_buffer& s3_pack_buffer::operator+=(int n)
{
   // reallocate and retain data if we're going to spill
   if ( (n+pos) > capacity )
   {
      enlarge(n+pos);
   }
   pos += n;
   return *this;
}

// const get_address
const void* s3_pack_buffer::get_buffer() const
{
   return CONST_OVERRIDE_THIS(s3_pack_buffer) get_buffer();
}

// return addresss of first element
void* s3_pack_buffer::get_buffer()
{
   return buf;
}

// const get_current
const void* s3_pack_buffer::get_current() const
{
   return CONST_OVERRIDE_THIS(s3_pack_buffer) get_current();
}

// return address of current element
void* s3_pack_buffer::get_current()
{
   return buf + pos;
}

// set the capacity to specified value
void s3_pack_buffer::set_capacity(size_t n)
{
   // only realloc if necessary
   if ( capacity != n )
   {
      if ( own_storage )
      {
    delete[] buf;
    buf = new unsigned char[n];
    capacity = n;
      }
      else
      {
    std::cerr << "s3_pack_buffer::set_capacity(size_t n) "
         << "invoked with own_storage = false"
         << " (aborting)..."
         << std::endl << std::endl << std::flush;
    abort();
      }
   }
   pos = 0;
}

// return size
size_t s3_pack_buffer::get_size() const
{
   return pos;
}

// copy n bytes from src to current pos and increment pos
void s3_pack_buffer::copy_in(const void* src, size_t n) 
{
   // reallocate and retain data if we're going to spill
   if ( (n+pos) > capacity )
   {
      enlarge(n+pos);
   }
   memcpy(get_current(), src, n);
   pos += n;
}

// copy n bytes from current pos to dst and increment pos
void s3_pack_buffer::copy_out(void* dst, size_t n) const
{
   // this is WAY wrong
   if ( (n+pos) > capacity )
   {
      std::cerr << "s3_pack_buffer::copy_out(void* dst, size_t n) "
      << "n+pos > capacity" 
      << " (aborting)..."
      << std::endl << std::endl << std::flush;
      abort();
   }
   memcpy(dst, get_current(), n);
   CONST_OVERRIDE_THIS(s3_pack_buffer) pos += n;
}

// new - memcpy - delete
void s3_pack_buffer::enlarge(size_t n)
{
   if ( ! own_storage ) // should NEVER happen !
   {
      std::cerr << "s3_pack_buffer::enlarge(size_t n) "
      << "invoked with own_storage = false"
      << " (aborting)..."
      << std::endl << std::endl << std::flush;
      abort();
   }
   
   unsigned char* old_buf = buf;
   buf = new unsigned char[n];
   memcpy(buf, old_buf, pos);
   capacity = n;
   delete[] old_buf;
}

// 
void s3_streamable_helper_other<std::string>::pack(const std::string& s, 
                     s3_pack_buffer& b)
{
#ifdef S3_VERBOSE_PACKING
   std::stringstream str;
   str << "string:";
   s3_streamable::pack_string(str.str(), b);
#endif
   std::string::size_type i = s.length();
   s3_streamable::pack(i, b);
   b.copy_in(s.c_str(), 
        sizeof(*s.c_str()) * s.length());
}

// 
void s3_streamable_helper_other<std::string>::unpack(std::string& s, 
                       const s3_pack_buffer& b)
{
#ifdef S3_VERBOSE_PACKING
   s3_streamable::unpack_string(b);
#endif
   std::string::size_type i;
   s3_streamable::unpack(i, b);
   // clear old string
   s.erase();
   s.append(static_cast<std::string::const_pointer>(b.get_current()), i);
   b += i;
}

#ifdef S3_VERBOSE_PACKING
//
void s3_streamable::pack_string(const std::string& s,
            s3_pack_buffer& b)
{
   std::string::size_type n = s.length();
   b.copy_in(&n, sizeof(n));
   b.copy_in(s.c_str(), 
        sizeof(*s.c_str()) * s.length());
}

// 
std::string s3_streamable::unpack_string(const s3_pack_buffer& b)
{
   std::string::size_type n;
   b.copy_out(&n, sizeof(n));
   // construct string from first i chars
   std::string s(static_cast<std::string::const_pointer>(b.get_current()), n);
   b += n;
   return s;
}
#endif

            

---

Send comments to: s3fc@stonethree.com