---

streamable_map.hh

/*
*  Name:      streamable_map.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Map class extended with stream capabilities
*  Date:      $Date: 2003/04/14 00:18:31 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1999-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  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., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_IO_STREAMABLE_MAP__
#define _MPCL_IO_STREAMABLE_MAP__

#include "../util/collection/map.hh"
#include "streamable.hh"


namespace mpcl
{

  namespace io
  {

    using util::collection::TMap;

    template < typename TKey                                   ,
               typename TItem                                  ,
               typename TCompare       = std::less<TKey>       ,
               typename TItemAllocator = std::allocator<TItem> >
    class TStreamableMap                                 :
      public TMap<TKey, TItem, TCompare, TItemAllocator> ,
      public virtual IStreamable<>
    {

      public:

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::allocator_type
          allocator_type;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::const_iterator
          const_iterator;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::const_pointer
          const_pointer;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::const_reference
          const_reference;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::const_reverse_iterator
          const_reverse_iterator;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::difference_type
          difference_type;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::iterator
          iterator;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::key_compare
          key_compare;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::key_type
          key_type;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::mapped_type
          mapped_type;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::pointer
          pointer;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::reference
          reference;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::reverse_iterator
          reverse_iterator;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::size_type
          size_type;

        typedef
          typename std::map<TKey, TItem, TCompare, TItemAllocator>::value_type
          value_type;


      public:

        //
        //  C O N S T R U C T O R S
        //

        TStreamableMap (void)                            :
          TMap<TKey, TItem, TCompare, TItemAllocator> () ,
          IStreamable<>                               () {}

        explicit TStreamableMap (const TCompare& rktCOMPARE)       :
          TMap<TKey, TItem, TCompare, TItemAllocator> (rktCOMPARE) ,
          IStreamable<>                               ()           {}

        template <typename InputIterator>
        TStreamableMap (InputIterator tBEGIN, InputIterator tEND)    :
          TMap<TKey, TItem, TCompare, TItemAllocator> (tBEGIN, tEND) ,
          IStreamable<>                               ()             {}

        template <typename InputIterator>
        TStreamableMap ( InputIterator   tBEGIN     ,
                         InputIterator   tEND       ,
                         const TCompare& rktCOMPARE )                            :
          TMap<TKey, TItem, TCompare, TItemAllocator> (tBEGIN, tEND, rktCOMPARE) ,
          IStreamable<>                               ()                         {}

        TStreamableMap (const std::map<TKey, TItem, TCompare, TItemAllocator>& rktSOURCE_MAP) :
          TMap<TKey, TItem, TCompare, TItemAllocator> (rktSOURCE_MAP)                         ,
          IStreamable<>                               ()                                      {}

        TStreamableMap<TKey, TItem, TCompare, TItemAllocator>&
        operator = (const TStreamableMap<TKey, TItem, TCompare, TItemAllocator>& rktSOURCE_MAP)
        {
          TMap<TKey, TItem, TCompare, TItemAllocator>::operator = (rktSOURCE_MAP);
          return *this;
        }

        void write (std::basic_ostream<char_type, traits_type>& rtTARGET_OSTREAM) const
        {
          const_iterator   I     = begin();
          const_iterator   ktEnd = end();

          for (; ( I != ktEnd ) ;++I)
          {
            rtTARGET_OSTREAM << I->first;
            rtTARGET_OSTREAM << I->second;
          }
        }


      public:

        //
        //  S E L E C T O R S
        //

        void read (std::basic_istream<char_type, traits_type>& rtSOURCE_ISTREAM)
        {
          TKey    tInputKey;
          TItem   tInputItem;

          clear();
          while ( rtSOURCE_ISTREAM >> tInputKey )
          {
            if ( rtSOURCE_ISTREAM >> tInputItem )
            {
              insert (std::make_pair (tInputKey, tInputItem));
            }
          }
          if ( empty() )
          {
            rtSOURCE_ISTREAM.setstate (std::ios::failbit);
          }
          else
          {
            rtSOURCE_ISTREAM.clear();
          }
        }

    };  // class TStreamableMap

  }  // namespace io

}  // namespace mpcl


#endif  // not _MPCL_IO_STREAMABLE_MAP__

---