Loading...
Searching...
No Matches
EST_TIterator.h
/************************************************************************/
/* */
/* Centre for Speech Technology Research */
/* University of Edinburgh, UK */
/* Copyright (c) 1996,1997 */
/* All Rights Reserved. */
/* */
/* Permission is hereby granted, free of charge, to use and distribute */
/* this software and its documentation without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of this work, and to */
/* permit persons to whom this work is furnished to do so, subject to */
/* the following conditions: */
/* 1. The code must retain the above copyright notice, this list of */
/* conditions and the following disclaimer. */
/* 2. Any modifications must be clearly marked as such. */
/* 3. Original authors' names are not deleted. */
/* 4. The authors' names are not used to endorse or promote products */
/* derived from this software without specific prior written */
/* permission. */
/* */
/* THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK */
/* DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING */
/* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT */
/* SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE */
/* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES */
/* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN */
/* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, */
/* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF */
/* THIS SOFTWARE. */
/* */
/************************************************************************/
#ifndef __EST_TITERATOR_H__
#define __EST_TITERATOR_H__
/** Template class defining interface to an iterator, i.e an object
* which returns elements from a structure one at a time.
*
* This is template is usually hidden in the declaration of the
* container classes with a typedef for Entries providing a more
* convenient name for the iterator. However the interface is that
* defined here.
*
* We support two interfaces, a pointer like interface similar to
* specialised iteration code elsewhere in the speech tools library
* and to the iterators in the C++ standard template library and an
* interface similar to that of Enumerations in Java.
*
* <programlisting arch='c++'>
* MyContainer::Entries them;
*
* for(them.begin(container); them; them++)
* {
* MyContainer::Entry &it = *them;
* // Do Something With it
* }</programlisting>
*
* <programlisting arch='c++'>
* MyContainer::Entries them;
*
* them.begin(container);
* while (them.has_more_entries())
* {
* MyContainer::Entry &it = them.next_entry();
* // Do Something With it
* }</programlisting>
*
* @author Richard Caley <rjc@cstr.ed.ac.uk>
* @version $Id: EST_TIterator.h,v 1.7 2013/04/13 14:17:11 awb Exp $
*/
template <class Container, class IPointer, class Entry>
class EST_TStructIterator;
template <class Container, class IPointer, class Entry>
class EST_TRwIterator;
template <class Container, class IPointer, class Entry>
class EST_TRwStructIterator;
template <class Container, class IPointer, class Entry>
class EST_TIterator
{
protected:
/// The container we are looking at.
Container *cont;
/// Position in the structure. May or may not be useful.
unsigned int pos;
/** Structure defined by the container class which contains the
* current state of the iteration.
*/
IPointer pointer;
public:
/// Name for an iterator like this
typedef EST_TIterator<Container, IPointer, Entry> Iter;
/// Create an iterator not associated with any specific container.
EST_TIterator() {cont=NULL;}
/// Create an iterator ready to run over the given container.
EST_TIterator(const Container &over)
{ begin(over); }
/// Copy an iterator by assignment
Iter &operator = (const Iter &orig)
{ cont=orig.cont; pos=orig.pos; pointer=orig.pointer; return *this;}
/// Assigning a container to an iterator sets it ready to start.
Iter &operator = (const Container &over)
{ begin(over); return *this;}
/// Set the iterator ready to run over this container.
void begin(const Container &over)
{cont=((Container *)(void *)&over); beginning();}
/// Reset to the start of the container.
void beginning()
{if (cont) cont->point_to_first(pointer); pos=0;}
/**@name End Tests
*/
//@{
/// True if there are more elements to look at.
bool has_more_elements() const
{return cont && cont->points_to_something(pointer);}
/// True when there are no more.
bool at_end() const
{return !has_more_elements();}
/** Viewing the iterator as an integer (for instance in a test)
* sees a non-zero value iff there are elements still to look at.
*/
operator int() const
{return has_more_elements();}
//@}
/**@name Moving Forward
*/
//@{
/// Next moves to the next entry.
void next()
{cont->move_pointer_forwards(pointer); pos++;}
/// The increment operator does the same as next.
Iter &operator ++()
{next(); return *this;}
Iter operator ++(int dummy)
{
(void)dummy;
Iter old =*this;
next();
return old;
}
//@}
/**@name Access
*/
//@{
/// Return the element currently pointed to.
const Entry& current() const
{return cont->points_at(pointer);}
/// The * operator returns the current element.
const Entry &operator *() const
{return current();}
#if 0
// This only works for some Entry types.
const Entry *operator ->() const
{return &current();}
#endif
/// Return the current element and move the pointer forwards.
const Entry& next_element()
{
const Entry &it = cont->points_at(pointer);
cont->move_pointer_forwards(pointer);
return it;
}
/// Return the current position
unsigned int n() const { return pos; }
//@}
friend class EST_TStructIterator <Container, IPointer, Entry>;
friend class EST_TRwIterator <Container, IPointer, Entry>;
friend class EST_TRwStructIterator <Container, IPointer, Entry>;
};
template <class Container, class IPointer, class Entry>
class EST_TStructIterator
: public EST_TIterator<Container, IPointer, Entry>
{
public:
typedef EST_TIterator<Container, IPointer, Entry> Iter;
/// Create an iterator not associated with any specific container.
EST_TStructIterator() {this->cont=NULL;}
/// Copy an iterator by assignment
Iter &operator = (const Iter &orig)
{ this->cont=orig.cont; this->pos=orig.pos; this->pointer=orig.pointer; return *this;}
/// Create an iterator ready to run over the given container.
EST_TStructIterator(const Container &over)
{ this->begin(over); }
const Entry *operator ->() const
{return &this->current();}
};
template <class Container, class IPointer, class Entry>
class EST_TRwIterator
: public EST_TIterator<Container, IPointer, Entry>
{
private:
/// Can't access constant containers this way.
// EST_TRwIterator(const Container &over) { (void) over; }
/// Can't access constant containers this way.
// void begin(const Container &over) { (void) over; }
public:
typedef EST_TRwIterator<Container, IPointer, Entry> Iter;
/// Create an iterator not associated with any specific container.
EST_TRwIterator() {this->cont=NULL;}
/// Copy an iterator by assignment
Iter &operator = (const Iter &orig)
{ this->cont=orig.cont; this->pos=orig.pos; this->pointer=orig.pointer; return *this;}
/// Create an iterator ready to run over the given container.
EST_TRwIterator(Container &over)
{ begin(over); }
/// Set the iterator ready to run over this container.
void begin(Container &over)
{this->cont=&over; this->beginning();}
/**@name Access
*/
//@{
/// Return the element currently pointed to.
Entry& current() const
{return this->cont->points_at(this->pointer);}
/// The * operator returns the current element.
Entry &operator *() const
{return current();}
#if 0
Entry *operator ->() const
{return &current();}
#endif
/// Return the current element and move the pointer forwards.
Entry& next_element()
{
Entry &it = this->cont->points_at(this->pointer);
this->cont->move_pointer_forwards(this->pointer);
return it;
}
//@}
};
template <class Container, class IPointer, class Entry>
class EST_TRwStructIterator
: public EST_TRwIterator<Container, IPointer, Entry>
{
public:
typedef EST_TRwStructIterator<Container, IPointer, Entry> Iter;
/// Create an iterator not associated with any specific container.
EST_TRwStructIterator() {this->cont=NULL;}
/// Copy an iterator by assignment
Iter &operator = (const Iter &orig)
{ this->cont=orig.cont; this->pos=orig.pos; this->pointer=orig.pointer; return *this;}
/// Create an iterator ready to run over the given container.
EST_TRwStructIterator(Container &over)
{ this->begin(over); }
Entry *operator ->() const
{return &this->current();}
};
#endif
IPointer
EST_TIterator< EST_THash< K, V >, IPointer_k, K >::Iter
EST_TIterator< EST_THash< K, V >, IPointer_k, K > Iter
Definition EST_TIterator.h:97
EST_TIterator::current
const Entry & current() const
Return the element currently pointed to.
Definition EST_TIterator.h:163
EST_TIterator::n
unsigned int n() const
Return the current position.
Definition EST_TIterator.h:186
EST_TIterator::operator=
Iter & operator=(const Iter &orig)
Copy an iterator by assignment.
Definition EST_TIterator.h:107
EST_TIterator::begin
void begin(const Container &over)
Set the iterator ready to run over this container.
Definition EST_TIterator.h:115
EST_TIterator::has_more_elements
bool has_more_elements() const
True if there are more elements to look at.
Definition EST_TIterator.h:126
EST_TIterator::at_end
bool at_end() const
True when there are no more.
Definition EST_TIterator.h:130
EST_TIterator::next_element
const Entry & next_element()
Return the current element and move the pointer forwards.
Definition EST_TIterator.h:177
EST_TIterator::EST_TIterator
EST_TIterator(const Container &over)
Create an iterator ready to run over the given container.
Definition EST_TIterator.h:103
EST_TIterator< EST_THash< K, V >, IPointer_k, K >::pointer
IPointer_k pointer
Definition EST_TIterator.h:93
EST_TIterator::EST_TIterator
EST_TIterator()
Create an iterator not associated with any specific container.
Definition EST_TIterator.h:100
EST_TIterator::next
void next()
Next moves to the next entry.
Definition EST_TIterator.h:144
EST_TIterator::operator++
Iter & operator++()
The increment operator does the same as next.
Definition EST_TIterator.h:148
EST_TIterator< EST_THash< K, V >, IPointer_k, K >::cont
EST_THash< K, V > * cont
Definition EST_TIterator.h:85
EST_TIterator::operator*
const Entry & operator*() const
The * operator returns the current element.
Definition EST_TIterator.h:167
EST_TIterator::beginning
void beginning()
Reset to the start of the container.
Definition EST_TIterator.h:119
EST_TIterator< EST_THash< K, V >, IPointer_k, K >::pos
unsigned int pos
Definition EST_TIterator.h:88
EST_TRwIterator
Definition EST_TIterator.h:221
EST_TRwIterator< EST_THash< K, V >, IPointer_k, K >::Iter
EST_TRwIterator< EST_THash< K, V >, IPointer_k, K > Iter
Definition EST_TIterator.h:231
EST_TRwIterator::operator*
Entry & operator*() const
The * operator returns the current element.
Definition EST_TIterator.h:256
EST_TRwIterator::next_element
Entry & next_element()
Return the current element and move the pointer forwards.
Definition EST_TIterator.h:265
EST_TRwIterator::EST_TRwIterator
EST_TRwIterator(Container &over)
Create an iterator ready to run over the given container.
Definition EST_TIterator.h:241
EST_TRwIterator::EST_TRwIterator
EST_TRwIterator()
Create an iterator not associated with any specific container.
Definition EST_TIterator.h:234
EST_TRwIterator::operator=
Iter & operator=(const Iter &orig)
Copy an iterator by assignment.
Definition EST_TIterator.h:237
EST_TRwIterator::begin
void begin(Container &over)
Set the iterator ready to run over this container.
Definition EST_TIterator.h:245
EST_TRwIterator::current
Entry & current() const
Return the element currently pointed to.
Definition EST_TIterator.h:252
EST_TRwStructIterator
Definition EST_TIterator.h:278
EST_TRwStructIterator::EST_TRwStructIterator
EST_TRwStructIterator()
Create an iterator not associated with any specific container.
Definition EST_TIterator.h:284
EST_TRwStructIterator::operator=
Iter & operator=(const Iter &orig)
Copy an iterator by assignment.
Definition EST_TIterator.h:287
EST_TRwStructIterator::EST_TRwStructIterator
EST_TRwStructIterator(Container &over)
Create an iterator ready to run over the given container.
Definition EST_TIterator.h:291
EST_TStructIterator
Definition EST_TIterator.h:198
EST_TStructIterator::operator=
Iter & operator=(const Iter &orig)
Copy an iterator by assignment.
Definition EST_TIterator.h:207
EST_TStructIterator::EST_TStructIterator
EST_TStructIterator()
Create an iterator not associated with any specific container.
Definition EST_TIterator.h:204
EST_TStructIterator::EST_TStructIterator
EST_TStructIterator(const Container &over)
Create an iterator ready to run over the given container.
Definition EST_TIterator.h:211