byte_array.h

Go to the documentation of this file.

#ifndef BYTE_ARRAY_CLASS
#define BYTE_ARRAY_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : byte_array                                                        *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1991-$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 "array.h"
#include "base_string.h"
#include "contracts.h"
#include "definitions.h"
 
#include <string.h>  // for memcmp.
 
namespace basis {
 
 
class byte_array : public array<abyte>, public virtual orderable
{
public:
  byte_array(int number = 0, const abyte *initial_contents = NULL_POINTER)
      : array<abyte>(number, initial_contents, SIMPLE_COPY | EXPONE) {}
 
  byte_array(const byte_array &to_copy)
      : root_object(), array<abyte>(to_copy) {}
 
  byte_array(const array<abyte> &to_copy) : array<abyte>(to_copy) {}
 
  virtual ~byte_array() {}
 
  DEFINE_CLASS_NAME("byte_array");
 
 
  static const byte_array &empty_array()
      { static byte_array g_empty; return g_empty; }
 
  // these implement the orderable and equalizable interfaces.
  virtual bool equal_to(const equalizable &s2) const {
    const byte_array *s2_cast = dynamic_cast<const byte_array *>(&s2);
    if (!s2_cast) throw "error: byte_array::==: unknown type";
    return comparator(*s2_cast) == 0;
  }
  virtual bool less_than(const orderable &s2) const {
    const byte_array *s2_cast = dynamic_cast<const byte_array *>(&s2);
    if (!s2_cast) throw "error: byte_array::<: unknown type";
    return comparator(*s2_cast) < 0;
  }
 
  int comparator(const byte_array &s2) const { 
    return memcmp(observe(), s2.observe(), length());
  }
};
 
 
 
class packable : public virtual root_object
{
public:
  virtual void pack(byte_array &packed_form) const = 0;
 
  virtual bool unpack(byte_array &packed_form) = 0;
 
  virtual int packed_size() const = 0;
};
 
 
// the two templates below can be used to add or remove objects from an array
// of bytes.  NOTE: the functions below will only work with objects that are
// already platform-independent.  it's better to make structures packable by
// using the attach and detach functions in the "packable" library.
 
template <class contents>
void attach_flat(byte_array &target, const contents &attachment)
{ target.concatenate(byte_array(sizeof(attachment), (abyte *)&attachment)); }
 
template <class contents>
bool detach_flat(byte_array &source, contents &detached)
{
  if (sizeof(detached) > source.length()) return false;
  detached = *(contents *)source.observe();
  source.zap(0, sizeof(detached) - 1);
  return true;
}
 
} // namespace.
 
#endif