set.h

Go to the documentation of this file.

#ifndef SET_CLASS
#define SET_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : set                                                               *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1996-$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 "packable.h"
#include "string_array.h"
//hmmm: seems like we need a string_set file to get rid of these
//      extra includes that sets themselves don't need.

namespace basis {


template <class contents>
class set : public array<contents>
{
public:

  inline set(int num = 0, const contents *init = NIL,
      u_short flags = array<contents>::EXPONE)
  : array<contents>(num, init, flags) {}

  inline ~set() {}  

  inline int elements() const { return this->length(); }

  inline bool empty() const { return this->elements() == 0; }
  inline bool non_empty() const { return this->elements() != 0; }

  inline void clear() { this->reset(); }  

  bool member(const contents &to_test) const;
  
  bool add(const contents &to_add);

  inline set &operator += (const contents &to_add)
      { this->add(to_add); return *this; }
  inline set &operator += (const set &to_add)
      { this->unionize(to_add); return *this; }

  bool remove(const contents &to_remove);

  inline set &operator -= (const contents &to_zap)
      { this->remove(to_zap); return *this; }
  inline set &operator -= (const set &to_zap)
      { this->differentiate(to_zap); return *this; }

  set set_union(const set &union_with) const;

  void unionize(const set &union_with);

  inline set operator + (const set &uw) const { return this->set_union(uw); }

  set intersection(const set &intersect_with) const;

  inline set operator * (const set &iw) const { return this->intersection(iw); }

  set difference(const set &differ_with) const;

  void differentiate(const set &differ_with);

  inline set operator - (const set &dw) const { return this->difference(dw); }

  int find(const contents &to_find) const;



  inline bool remove_index(int index)
      { return this->zap(index, index) == common::OKAY; }
};


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

template <class contents>
bool unpack(byte_array &packed_form, basis::set<contents> &to_unpack)
{
  to_unpack.clear();
  int len;
  if (!basis::obscure_detach(packed_form, len)) return false;
  contents to_fill;
  for (int i = 0; i < len; i++) {
    if (!to_fill.unpack(packed_form)) return false;
    to_unpack.add(to_fill);
  }
  return true;
}

} // namespace.


#include "object_base.h"

class int_set : public basis::set<int>, public virtual object_base
{
public:
  inline int_set() {}
  inline int_set(const basis::set<int> &to_copy) : basis::set<int>(to_copy) {}

  IMPLEMENT_CLASS_NAME("int_set");
};

class string_set : public basis::set<istring>, public packable,
    public virtual object_base
{
public:
  inline string_set() {}
  inline string_set(const basis::set<istring> &to_copy)
      : basis::set<istring>(to_copy) {}
  inline string_set(const string_array &to_copy) {
    for (int i = 0; i < to_copy.length(); i++)
      add(to_copy[i]);
  }

  IMPLEMENT_CLASS_NAME("string_set");

  inline bool operator == (const string_set &compare) const {
    for (int i = 0; i < elements(); i++)
      if (get(i) != compare.get(i)) return false;
    return true;
  }

  inline operator string_array() const {
    string_array to_return;
    for (int i = 0; i < length(); i++)
      to_return += get(i);
    return to_return;
  }

  inline virtual void pack(byte_array &packed_form) const
      { basis::pack(packed_form, *this); }
  inline virtual bool unpack(byte_array &packed_form)
      { return basis::unpack(packed_form, *this); }
  inline virtual int packed_size() const {
    int to_return = sizeof(int) * 2;  // length packed in, using obscure.
    for (int i = 0; i < length(); i++)
      to_return += get(i).length() + 1;
    return to_return;
  }
};

class pointer_set : public basis::set<void *>
{
public:
  inline pointer_set() {}
  inline pointer_set(const basis::set<void *> &to_copy) : basis::set<void *>(to_copy)
      {}
};

#endif

---