sarray.h

Go to the documentation of this file.

//    sampalib.org ESL library and tools
//    Copyright (C) 2007  Thierry Grellier
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License version 2 as
//    published by the Free Software Foundation.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with this program; if not, write to the Free Software Foundation, Inc.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//    contact: www.sampalib.org

#ifndef SAMPA_SARRAY_H
#  define SAMPA_SARRAY_H

#include "sampa/core/persistence.h"
#if SAMPA_CONFIG_COLD_RESTART == SAMPA_ENABLED
#  include "array.h"
#  include "sampa/core/triggerable.h"
#endif

namespace Sampa {

  template<typename Element>
  class SAMPA_PERSISTENT_CLASS(Array) {
  public:
#if SAMPA_CONFIG_COLD_RESTART == SAMPA_ENABLED
    Element& operator[](size_t idx)            
      { return m_elements->body()[idx]; }
    const Element& operator[](size_t idx) const           
      { return m_elements->body()[idx]; }
    Element* begin() { return m_elements->body(); }
#else
    Element& operator[](size_t idx)            
      { return m_elements[idx]; }
    const Element& operator[](size_t idx) const            
      { return m_elements[idx]; }
    Element* begin() { return m_elements; }
#endif
    Array(size_t capacity, const char* name = 0);
    ~Array();
  private:  
    // Disabled
    Array(const Array&);
    Array& operator=(const Array&);
#if SAMPA_CONFIG_COLD_RESTART == SAMPA_ENABLED
    array_of_scalar<Element>* m_elements;
#else
    Element* m_elements;
#endif
    SAMPA_PERSISTENT(Array);
  };  

  class SAMPA_PERSISTENT_CLASS(PtrQueueBase) {
  public:
    bool   is_empty() const { return m_size == 0; }
    size_t get_size() const { return m_size; }
    void   clear()          { m_size = 0;    }
    int increase_capacity(int begin, int old_size, int n);
  protected:
#if SAMPA_CONFIG_COLD_RESTART == SAMPA_ENABLED
    typedef object*  Element;
    typedef Element* Iterator;
    Iterator begin()        { return m_elements->body(); }
    Iterator end()          { return m_elements->body()+m_size; }
    Element operator[](size_t idx) const           
      { return m_elements->body()[idx]; }
    void set(int idx, const Element& e) { m_elements->body()[idx] = e; }
    void push_back(const Element& e) 
    { size_t capacity = m_elements->get_size(); 
      if (m_size == capacity)
        m_elements = reallocate(capacity);
      m_elements->body()[m_size++] = e;
    }
    ArrayOfObject* reallocate(size_t capacity);
    void push_back_no_check(const Element& e) 
    {
      m_elements->body()[m_size++] = e;
    }
#else
    typedef void*    Element;
    typedef Element* Iterator;
    Iterator begin()        { return m_elements; }
    Iterator end()          { return m_elements+m_size; }
    Element operator[](size_t idx) const           
      { return m_elements[idx]; } 
    void set(int idx, const Element& e) { m_elements[idx] = e; }
    void push_back(const Element& e) 
    {
      if (m_size == m_capacity) {
        m_capacity <<= 1;
        m_elements = (void**) realloc(m_elements, sizeof(Element)*m_capacity);
      }
      m_elements[m_size++] = e;
    }
    void push_back_no_check(const Element& e) 
    {
      m_elements[m_size++] = e;
    }
#endif
    PtrQueueBase(size_t capacity);
    PtrQueueBase(DefaultCtrTag);
    ~PtrQueueBase();
    void remove(const Element& r) {
      for(Iterator i = begin(), e = end(); i < e; i++) {
        if (*i == r) {
          *i = *(e-1); 
          m_size--;
          return;
        }
      }
    }
  private:  
    // Disabled
    PtrQueueBase(const PtrQueueBase&);
    PtrQueueBase& operator=(const PtrQueueBase&);
#if SAMPA_CONFIG_COLD_RESTART == SAMPA_ENABLED
    ArrayOfObject* m_elements;
    size_t         m_size;
#else
    Element*       m_elements;
    size_t         m_size;
    size_t         m_capacity;
#endif
    SAMPA_PERSISTENT(PtrQueueBase);
  };

  template<class T>
  class PtrQueue : public PtrQueueBase {
  public:
    typedef T*       Element;
    typedef Element* Iterator;
    Element operator[](size_t idx) const           
      { return static_cast<Element>(PtrQueueBase::operator[](idx)); }
    void set(int idx, const Element& e) { PtrQueueBase::set(idx, e); }
    Iterator begin() { return reinterpret_cast<Iterator>(PtrQueueBase::begin()); }
    Iterator end()   { return reinterpret_cast<Iterator>(PtrQueueBase::end()); }
    void push_back(const Element& e) { PtrQueueBase::push_back(e); }
    void push_back_no_check(const Element& e) { PtrQueueBase::push_back_no_check(e); }
    void remove(const Element& e) { PtrQueueBase::remove(e); }
    PtrQueue(size_t capacity) : PtrQueueBase(capacity) { }
  private:  
    PtrQueue(const PtrQueue&);
    PtrQueue& operator=(const PtrQueue&);
    SAMPA_PERSISTENT(PtrQueue);
  };

#if SAMPA_CONFIG_COLD_RESTART == SAMPA_ENABLED
  template<>
  class SAMPA_PERSISTENT_CLASS(PtrQueue<Triggerable>) {
  public:
    typedef Triggerable* Element;
    typedef Element*     Iterator;
    bool   is_empty() const { return m_size == 0; }
    size_t get_size() const { return m_size; }
    void   clear()          { m_size = 0;    }
    Iterator begin()        { return m_elements->body(); }
    Iterator end()          { return m_elements->body()+m_size; }
    Element operator[](size_t idx) const           
      { return m_elements->body()[idx]; }
    void push_back(const Element& e) 
    { size_t capacity = m_elements->get_size(); 
      if (m_size == capacity)
        m_elements = reallocate(capacity);
      m_elements->body()[m_size++] = e;
    }
    void push_back_no_check(const Element& e) 
    {
      m_elements->body()[m_size++] = e;
    }

    array_of_ptr<Triggerable>* reallocate(size_t);

    PtrQueue(size_t capacity);
    PtrQueue(DefaultCtrTag);
    ~PtrQueue();

    void remove(const Element& r) {
      for(Iterator i = begin(), e = end(); i < e; i++) {
        if (*i == r) {
          *i = *(e-1); 
          m_size--;
          return;
        }
      }
    }
  private:  
    PtrQueue(const PtrQueue&);
    PtrQueue& operator=(const PtrQueue&);
    array_of_ptr<Triggerable>* m_elements;
    size_t                     m_size;
    SAMPA_PERSISTENT(PtrQueue);
  };

#endif
  
}

#endif

---