object_packers.h

Go to the documentation of this file.

#ifndef OBJECT_PACKERS_CLASS
#define OBJECT_PACKERS_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : object_packers                                                    *
*  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 <basis/byte_array.h>
#include <basis/definitions.h>

namespace structures {

// the sizes in bytes of common objects.  if the compiler doesn't match these, there will
// probably be severe tire damage.
const int PACKED_SIZE_BYTE = 1;
const int PACKED_SIZE_INT16 = 2;
const int PACKED_SIZE_INT32 = 4;

// these functions pack and unpack popular data types.

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

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

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

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

int packed_size(double to_pack);
void attach(basis::byte_array &packed_form, double to_pack);
bool detach(basis::byte_array &packed_form, double &to_unpack);

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

void attach(basis::byte_array &packed_form, int to_attach);

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

void obscure_attach(basis::byte_array &packed_form, basis::un_int to_attach);

bool obscure_detach(basis::byte_array &packed_form, basis::un_int &to_detach);

/*
void attach(basis::byte_array &packed_form, long to_attach);
bool detach(basis::byte_array &packed_form, long &to_detach);
*/

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

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

/*
void attach(basis::byte_array &packed_form, basis::un_long to_attach);
bool detach(basis::byte_array &packed_form, basis::un_long &to_detach);
*/

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


// helpful template functions for packing.

template <class contents>
void pack_array(basis::byte_array &packed_form, const basis::array<contents> &to_pack) {
  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_array(basis::byte_array &packed_form, basis::array<contents> &to_unpack) {
  to_unpack.reset();
  basis::un_int len;
  if (!obscure_detach(packed_form, len)) return false;
  basis::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 < (int)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_array(const basis::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(basis::byte_array &packed_form, const basis::array<contents> &to_pack) {
  obscure_attach(packed_form, to_pack.length());
  for (int i = 0; i < to_pack.length(); i++)
    attach(packed_form, to_pack[i]);
}


template <class contents>
bool unpack_simple(basis::byte_array &packed_form, basis::array<contents> &to_unpack) {
  to_unpack.reset();
  basis::un_int len;
  if (!obscure_detach(packed_form, len)) return false;
  basis::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 (!detach(packed_form, swappy_array[i]))
      return false;
  }
  swappy_array.swap_contents(to_unpack);
  return true;
}

} // namespace

#endif