packable.h

Go to the documentation of this file.

#ifndef PACKABLE_CLASS
#define PACKABLE_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : packable                                                          *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1995-$now By Author.  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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "byte_array.h"


class packable
{
public:
  virtual ~packable();

  virtual void pack(byte_array &packed_form) const = 0;

  virtual bool unpack(byte_array &packed_form) = 0;

  virtual int packed_size() const;
};


namespace basis {
  // added to the general basis namespace rather than something more specific.

// these functions pack and unpack popular data types.

void attach(byte_array &packed_form, bool to_attach);
bool detach(byte_array &packed_form, bool &to_detach);

void attach(byte_array &packed_form, byte to_attach);
bool detach(byte_array &packed_form, byte &to_detach);

int packed_size(byte_array &packed_form);
void attach(byte_array &packed_form, const byte_array &to_attach);
bool detach(byte_array &packed_form, byte_array &to_detach);

void attach(byte_array &packed_form, char to_attach);
bool detach(byte_array &packed_form, char &to_detach);

void attach(byte_array &packed_form, const char *to_attach);
bool detach(byte_array &packed_form, istring &to_detach);

void attach(byte_array &packed_form, double to_pack);
bool detach(byte_array &packed_form, double &to_unpack);

void attach(byte_array &packed_form, float to_pack);
bool detach(byte_array &packed_form, float &to_unpack);

void attach(byte_array &packed_form, int to_attach);

bool detach(byte_array &packed_form, int &to_detach);

void obscure_attach(byte_array &packed_form, int to_attach);

bool obscure_detach(byte_array &packed_form, int &to_detach);

void attach(byte_array &packed_form, long to_attach);
bool detach(byte_array &packed_form, long &to_detach);

void attach(byte_array &packed_form, short to_attach);
bool detach(byte_array &packed_form, short &to_detach);

void attach(byte_array &packed_form, u_int to_attach);
bool detach(byte_array &packed_form, u_int &to_detach);

void attach(byte_array &packed_form, u_long to_attach);
bool detach(byte_array &packed_form, u_long &to_detach);

void attach(byte_array &packed_form, u_short to_attach);
bool detach(byte_array &packed_form, u_short &to_detach);


// helpful template functions for packing.

template <class contents>
void pack(byte_array &packed_form, const array<contents> &to_pack)
{
  basis::obscure_attach(packed_form, to_pack.length());
  for (int i = 0; i < to_pack.length(); i++) to_pack[i].pack(packed_form);
}

template <class contents>
bool unpack(byte_array &packed_form, array<contents> &to_unpack)
{
  to_unpack.reset();
  int len;
  if (!basis::obscure_detach(packed_form, len)) return false;
  array<contents> swappy_array(len, NIL, to_unpack.flags());
    // we create an array of the specified length to see if it's tenable.
  if (!swappy_array.observe()) return false;  // failed to allocate.
  for (int i = 0; i < len; i++) {
    if (!swappy_array[i].unpack(packed_form))
      return false;
  }
  // now that we've got exactly what we want, plunk it into the result array.
  swappy_array.swap_contents(to_unpack);
  return true;
}

template <class contents>
int packed_size(const array<contents> &to_pack)
{
  int to_return = sizeof(int) * 2;  // obscure version uses double int size.
  for (int i = 0; i < to_pack.length(); i++)
    to_return += to_pack[i].packed_size();
  return to_return;
}


template <class contents>
void pack_simple(byte_array &packed_form, const array<contents> &to_pack)
{
  basis::obscure_attach(packed_form, to_pack.length());
  for (int i = 0; i < to_pack.length(); i++)
    basis::attach(packed_form, to_pack[i]);
}


template <class contents>
bool unpack_simple(byte_array &packed_form, array<contents> &to_unpack)
{
  to_unpack.reset();
  int len;
  if (!basis::obscure_detach(packed_form, len)) return false;
  array<contents> swappy_array(len, NIL, to_unpack.flags());
  if (!swappy_array.observe()) return false;  // failed to allocate.
  for (int i = 0; i < len; i++) {
    if (!basis::detach(packed_form, swappy_array[i]))
      return false;
  }
  swappy_array.swap_contents(to_unpack);
  return true;
}

} // namespace

#endif

---