chained.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_CHAINED_H
#define SAMPA_CHAINED_H

#include "sampa/core/persistence.h"

namespace Sampa {

  class SAMPA_PERSISTENT_CLASS(Chained) {
  public:
    class List;
    Chained(DefaultCtrTag);
    void detach();
    void set_prev(Chained* other);
    void set_next(Chained* other);
    Chained* get_next() const;
    Chained* get_prev() const;
    void reset();
    void merge(Chained*);
  protected:
    friend class List;
    Chained* m_next;
    Chained* m_prev;
    SAMPA_PERSISTENT(Chained);
  };

  class SAMPA_PERSISTENT_CLASS(Chained::List) {
  public:
    class Iterator {
    public:
      Iterator(DefaultCtrTag);
      Iterator(const Iterator&);
      Iterator& operator=(const Iterator&);
      Iterator& operator++();
      Chained* operator*() const;
      bool operator!=(const Iterator& other) const;
    protected:
      friend class List;
      Iterator(Chained* first); 
      Chained* m_curr;
      Chained* m_next;
    };
    Iterator begin();
    Iterator end(); 
    List(DefaultCtrTag);  
    List(Chained* chained);  
    void push_back (Chained* chained);
    void push_front(Chained* chained);
    Chained* pop_front();
    bool is_empty() const;
    Chained* get_front() const;
    Chained* get_back() const;
    void operator=(List& other);
    void reset();
  private:
    Chained m_list;
    SAMPA_PERSISTENT(List);
  };


inline
Chained::Chained(DefaultCtrTag)
  : m_next(this), 
    m_prev(this) 
{ 
}

inline
void Chained::reset()
{ 
  m_prev = m_next = this; 
}

inline
void Chained::detach()
{ 
  m_next->m_prev = m_prev;
  m_prev->m_next = m_next;
  m_prev = m_next = this; 
}

inline
void Chained::set_prev(Chained* other)
{ // detach other
  other->m_next->m_prev = other->m_prev;
  other->m_prev->m_next = other->m_next;
  // link
  m_prev->m_next        = other;
  other->m_prev         = m_prev;
  m_prev                = other;
  other->m_next         = this; 
}

inline
void Chained::set_next(Chained* other)
{ // detach other
  other->m_next->m_prev = other->m_prev;
  other->m_prev->m_next = other->m_next;
  // link
  m_next->m_prev        = other;
  other->m_next         = m_next;
  m_next                = other;
  other->m_prev         = this;
}

inline
Chained* Chained::get_next() const
{ 
  return m_next; 
}

inline
Chained* Chained::get_prev() const
{ 
  return m_prev; 
}

inline
void Chained::merge(Chained* other) 
{
  m_prev->m_next = other;
  other->m_prev->m_next = this;    
  Chained* prev = m_prev;
  m_prev = other->m_prev;
  other->m_prev = prev;
}

inline
Chained::List::Iterator& Chained::List::Iterator::operator++()
{ m_curr = m_next; m_next = m_curr->get_next(); return *this; }

inline
Chained* Chained::List::Iterator::operator*() const
{ return m_curr; }

inline
bool Chained::List::Iterator::operator!=(const Chained::List::Iterator& other) const
{ return other.m_curr != m_curr; }

inline
Chained::List::Iterator::Iterator(Chained* first)
: m_curr(first), m_next(first->get_next()) { } 

inline
Chained::List::Iterator::Iterator(const Chained::List::Iterator& other)
: m_curr(other.m_curr), m_next(other.m_next) { } 

inline
Chained::List::Iterator::Iterator(DefaultCtrTag)
: m_curr(0), m_next(0) { } 


inline
Chained::List::Iterator Chained::List::begin()
{ return Iterator(m_list.m_next); }

inline
Chained::List::Iterator Chained::List::end()
{ return Iterator(&m_list);   } 


inline
void Chained::List::reset()
{ 
  m_list.reset(); 
}

inline
Chained::List::List(DefaultCtrTag t) 
: m_list(t) {}  

inline
void Chained::List::push_back (Chained* chained) 
{ m_list.set_prev(chained); }

inline
Chained::List::List(Chained* chained)
: m_list(DEFAULT_CTR) { push_back(chained); }  

inline
void Chained::List::push_front(Chained* chained)
{ m_list.set_next(chained); }

inline
Chained* Chained::List::pop_front()
{ 
  Chained* front = get_front();
  front->detach();
  return front;
}

inline
bool Chained::List::is_empty() const
{ return m_list.m_next == &m_list; }

inline
Chained* Chained::List::get_front() const 
{ return m_list.m_next; }

inline
Chained* Chained::List::get_back() const 
{ return m_list.m_prev; }

inline
void Chained::List::operator=(Chained::List& other) 
{ // assert (!other.is_empty() && is_empty());
  m_list.m_next = other.m_list.m_next;
  m_list.m_next->m_prev = &m_list;
  m_list.m_prev = other.m_list.m_prev;
  m_list.m_prev->m_next = &m_list;
  // flush other list
  other.m_list.m_prev = other.m_list.m_next = &other.m_list; 
}

} // namespace Sampa


#endif

---