TokenList.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef COLLECTIONBASE_TOKENLIST_H
#define COLLECTIONBASE_TOKENLIST_H
 
#include <string>
#include <vector>
#include <map>
#include <iosfwd>
 
 
class Token;
 
namespace pool {
 
   class TokenList
   {
  public:
     TokenList();
 
     TokenList( const std::vector<std::string>& specification );
 
     TokenList( const TokenList& rhs );
 
     ~TokenList();
 
     TokenList& operator=( const TokenList& rhs );
 
     bool operator==( const TokenList& rhs ) const;
 
     bool operator!=( const TokenList& rhs ) const;
 
     void extend( const std::string& name );
 
 
     size_t size() const;
 
     void   clear();
 
     Token& operator[]( const std::string& name );
 
     const Token& operator[]( const std::string& name ) const;
 
     Token& operator[]( unsigned int index );
 
     const Token& operator[]( unsigned int index ) const;
 
     std::ostream& toOutputStream( std::ostream& os ) const;
 
     class iterator_base 
     {
    public:
       bool operator==( const iterator_base& rhs ) const {
      return m_list == rhs.m_list && m_index == rhs.m_index;
       }
       bool operator!=( const iterator_base& rhs ) const { return !(*this==rhs); }
       void operator++() { ++m_index; }
       bool next() { return ++m_index < m_list->size(); }
       const std::string& tokenName() const { return m_list->m_tokenNames[ m_index ]; }
    protected:
       iterator_base( const TokenList* list, size_t idx = 0 ) 
         : m_list( list ), m_index( idx ) {}
       // default copy ctor and assignment.
       virtual ~iterator_base() {}
 
       const TokenList* m_list;
       size_t       m_index;
     };
 
     class iterator : public iterator_base
     {
      public:
        friend class TokenList;
         ~iterator() {};
         iterator( const iterator_base& rhs ) : iterator_base( rhs ) {}
         iterator& operator=( const iterator_base& rhs ) { 
        iterator_base::operator=( rhs );
        return *this; 
         }
      private:
         iterator( TokenList* list, size_t idx = 0 ) : iterator_base( list, idx ) {}
      public:
         Token* operator->() { return m_list->m_tokenVector[ m_index ]; }
         Token& operator*()  { return *operator->(); }
         iterator& operator++() { iterator_base::operator++(); return *this; }
     };
 
     iterator begin();
 
     iterator end();
 
     class const_iterator : public iterator_base
     {
      public:
      friend class TokenList;
        ~const_iterator() {};
         const_iterator( const iterator_base& rhs ): iterator_base( rhs ) {}
         const_iterator& operator=( const iterator_base& rhs )       { 
        iterator_base::operator=( rhs ); 
        return *this; 
         }
      private:
         const_iterator( const TokenList* list, size_t idx = 0 ) : iterator_base( list, idx ) {}
      public:
         const Token* operator->() const { return m_list->m_tokenVector[ m_index ]; }
         const Token& operator*() const  { return *operator->(); }
         const_iterator& operator++() { iterator_base::operator++(); return *this; }
     };
 
     const_iterator begin() const;
 
     const_iterator end() const;
 
  protected:
     // implementation of the constructor
     void createFromSpec( const std::vector<std::string>& specification );
     
  private:
     std::vector< std::string > m_tokenNames;
 
     std::vector< Token* > m_tokenVector;
 
     std::map< std::string, Token* > m_tokenMap;
   };
}
 
 
// Inline methods.
inline size_t
pool::TokenList::size() const
{
   return m_tokenVector.size();
}
 
inline bool
pool::TokenList::operator!=( const pool::TokenList& rhs ) const
{
   return !( *this == rhs );
}
 
inline pool::TokenList::iterator
pool::TokenList::begin()
{
   return pool::TokenList::iterator( this );
}
 
inline pool::TokenList::iterator
pool::TokenList::end()
{
   return pool::TokenList::iterator( this, size() );
}
 
inline pool::TokenList::const_iterator
pool::TokenList::begin() const
{
   return pool::TokenList::const_iterator( this );
}
 
inline pool::TokenList::const_iterator
pool::TokenList::end() const
{
   return pool::TokenList::const_iterator( this, size() );
}
 
#endif