gpa.h

Zobrazit dokumentaci tohoto souboru.

#ifndef GELIB_GPA_H
#define GELIB_GPA_H


namespace gelibspace {

template <class T> //template <class T, long s = 0, long ds = 1>
class GPA
{
  //  *************************
  //  /**   @name GENERAL   **/
  //  *************************
  //  @{
 protected:
  long  size;   // count of assigned (nonzero) pointers
  long asize;   // length of the allocated array
  long dsize;   // allocation increment
  T **values;   // array of pointers to particular objects
  
 public:
  GPA (void) { size = 0;  asize = 0;  dsize = 0;  values = NULL; }
  GPA (long s, long ds=1) { this->initialize(s, ds); }
  GPA (const GPA<T> *src) { values = NULL; this->be_copy_of(src); }
  ~GPA() { delete [] values; }
  // @}
  
  
  //  **********************************
  //  /**   @name RE/DE/ALLOCATION   **/
  //  **********************************
  //  @{
  void realloc_core (long new_asize) {
    T **newvals = new T* [new_asize];
    
    for (asize=0; asize<     size; asize++)  *newvals++ = *values++;
    for (       ; asize<new_asize; asize++)  *newvals++ = NULL;
    
    delete [] (values-size);
    values = newvals-new_asize;
  }
  void free_ptrs_core (long newsize) {
    memset (values+newsize, 0, (asize-newsize)*sizeof(T*));
  }
  
  void realloc (long new_asize)
  {
    if (new_asize == asize)  return;
    if (new_asize  > asize)  this->realloc_core   (new_asize);
    else                     this->free_ptrs_core (new_asize);
  }
  void reallocup (long new_asize)
  {
    if (new_asize == 0)  new_asize = asize + (dsize ? dsize : 0.1*asize+1);
    if (new_asize <= asize)
      errol;
    
    this->realloc_core(new_asize);
  }
  void reallocdown (long new_asize)
  {
    if (new_asize >= asize)  errol;
    this->free_ptrs_core(new_asize);
  }
  void reallocplus (long d)
  {
# ifdef DEBUG
    if (d<0) _errorr ("d<0");
# endif
    this->realloc_core(size+d);
  }
  
  void resize     (long newsize) { this->realloc    (newsize);  size = newsize; }
  void resizeup   (long newsize) { this->reallocup  (newsize);  size = newsize; }
  void resizedown (long newsize) { this->reallocdown(newsize);  size = newsize; }
  void resize_zero (void) { size = 0; }
  // @}
  
  
  //  **********************************
  //  /**   @name       SET          **/
  //  **********************************
  //  @{
  void free_ptrs (void)  { memset (values, 0, (asize)*sizeof(T*)); }
  void free_ptr (T *val) { for (long i=0; i<size; i++)  if (values[i] == val) values[i] = NULL; }
  void free_ptr (long i) {                                                    values[i] = NULL; }
  
  void delete_object (long i) {                              delete values[i];  values[i] = NULL; }
  void delete_objects (void)  {  for (long i=0; i<size; i++) delete values[i];  free_ptrs(); }
  
  void initialize (long s, long ds=0)
  {
    size = asize = s;
    dsize = ds;
    
    if (asize) { values = new T* [asize];  memset (values, 0, asize*sizeof(T*)); }
    else         values = NULL;
  }
  void be_copy_of (const GPA<T> *src)
  {
    size = asize = src->size;
    ;      dsize = src->dsize;
    delete [] values;
    values = new T* [asize];
    memcpy (values, src->values, size*sizeof(T*));
  }
  void reverse ()
  {
    T *val;
    int n = size/2;
    while (n--) {
      val              = values[n];
      values[n]        = values[size-1-n];
      values[size-1-n] = val;
    }
  }
  void assign (long i, T *val) {
# ifdef DEBUG
    if (i<0 || i>=size)
      _warningg ("i out of the range");
# endif
    values[i] = val;
  }
  T* add (T *val)
  {
    if (size == asize)  this->reallocup(0);
    values[size++] = val;
    return val;
  }
  T* wedge (long i, T *val)
  {
    if (i<0 || i>=size)  errol;
    
    if (size < asize) {
      for (long ii=size; ii>=i; ii--)
    values[ii] = values[ii-1];
      
      values[i] = val;
      size++;
    }
    else {
      T **newa = new T* [++size];
      
      for (asize=0; asize<i   ; asize++)  *newa++ = *values++;
      ;                         asize++;  *newa++ = val;
      for (       ; asize<size; asize++)  *newa++ = *values++;
      newa -= asize;
      
      delete [] (values-size+1);
      values = newa;
    }
    
    return val;
  }
  void add_unique (          T  *src) { if (! this->is_member(src))  this->add(src); }
  void add_unique (const GPA<T> &src);
  bool replace_member_by (T *oldv, T *newv)
  {
    for (long i=0; i<size; i++)
      if (values[i] == oldv) {
    values[i] = newv;
    return true;
      }
    return false;
  }
  // @}
  
  
  //  **********************************
  //  /**   @name       GET          **/
  //  **********************************
  //  @{
  const T** v (void) const { return const_cast<const T**>(values); }
  //
  T* operator[] (long i) const {
# ifdef DEBUG
    if (i<0 || i>=size)
      _warningg ("i out of the range");
# endif
    return values[i];
  }
  //
  T* first (void) const {
# ifdef DEBUG
    if (!size)  _errorr ("GPA has no members");
# endif
    return values[0];
  }
  T* last (void) const {
# ifdef DEBUG
    if (!size)  _errorr ("GPA has no members");
# endif
    return values[size-1];
  }
  //
  T* at_or_null (long i) const {
    return ( (i<0 || i>=size ) ? NULL : values[i]);
  }
  
  //*  *** GET SIZE ***
  long operator()(void) const { return size; }
  long give_size (void) const { return size; }
  long give_asize (void) const { return asize; }
  
  long give_num_nonNULL_ptrs () const {
    long i, sum = 0;
    for (i=0; i<size; i++)  if (values[i])  sum++;
    return sum;
  }
  long give_num_nonNULL_ptrs2 () const {
    long i, sum = 0;
    for (i=0; i<size; i++)  sum += values[i]->give_num_nonNULL_ptrs();
    return sum;
  }
  // @}
  
  
  
  
  //  **********************************
  //  /**   @name      OTHER         **/
  //  **********************************
  //  @{

  //*  *** SET VALUE ***
  
  //void delete_clear_unoptrs (void)
  //{
  //  if (values == NULL)  return;
  //  for (long i=0; i<size; i++)  delete values[i];
  //  delete [] values;  values = NULL;
  //  size = asize = 0;
  //}
  bool is_member (T *val) const { return is_member_of_array (val, size, values); }
  bool is_unique (void)   const { return members_are_unique (size, values);      }
  
  bool is_identical_with (const GPA<T> &one) const { if (size != one.size) return false; return ! (bool)arrays_arenot_identical (size, values, one.values); }
  bool has_same_members_as (const GPA<T> &one) const { return same_array_elements_asym(size, values, one.size, one.values, true); }
  bool has_these_members   (const GPA<T> &one) const { return has_these_members(one(), one.values); }
  bool has_these_members(long s, const T **one) const
  {
    if (size != s)  return false;
    
    long i,j;
    const T **vals = new T* [size];
    for (i=0; i<size; i++)  vals[i] = one[i];
    
    for (i=0; i<size; i++) {
      for (j=0; j<size; j++)
    if (vals[j] && values[i] == vals[j]) {
      vals[j] = NULL;
      break;
    }
      
      if (j == size)  break;
    }
    
    delete [] vals;
    
    return (i == size) ? true : false;
  }
  
  void shake_down (void);
  // @}
};

template<class T> void GPA<T> :: shake_down (void)
{
  long i, j;
  
  for (j=0; j<size; j++)
    if (values[j] == NULL) break;
  
  for (i=j+1; i<size; i++)
    if (values[i]) {
      values[j++] = values[i];
      values[i]   = NULL;
    }
  
  size = j;
}
template<class T> void GPA<T> :: add_unique (const GPA<T> &src)
{
  if (! src())  return;
  
  this->realloc(size+src());
  
  for (long i=0; i<src(); i++)
    if (! this->is_member (src[i]))
      values[size++] = src[i];
  
  if (asize-size>100 && asize>1.5*size)  errol;
}


} // namespace gelibspace

#endif // GELIB_GPA_H