---

mmap.h

/***************************************************************************
 *   This file is part of the MagiC++ library.                             *
 *                                                                         *
 *   Copyright (C) 1998-2001 Marko Grönroos <magi@iki.fi>                  *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  This library is free software; you can redistribute it and/or          *
 *  modify it under the terms of the GNU Library General Public            *
 *  License as published by the Free Software Foundation; either           *
 *  version 2 of the License, or (at your option) any later version.       *
 *                                                                         *
 *  This library 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      *
 *  Library General Public License for more details.                       *
 *                                                                         *
 *  You should have received a copy of the GNU Library General Public      *
 *  License along with this library; see the file COPYING.LIB.  If         *
 *  not, write to the Free Software Foundation, Inc., 59 Temple Place      *
 *  - Suite 330, Boston, MA 02111-1307, USA.                               *
 *                                                                         *
 ***************************************************************************/

#ifndef __MAP_H__
#define __MAP_H__

#include <iostream.h>
#include "magic/mobject.h"
#include "magic/mmagisupp.h"
#include "magic/mpararr.h"

// Externals
class DumpContext;

class MapPair;
class HashBucket;
class HashFunc;
class GenHash;
class GenHashIter;

class MapPair : public Object {
  public:
    const Comparable*   key;
    Object*             value;
    bool                isref;
                        MapPair     () {key=NULL; value=NULL; isref=0;}
                        ~MapPair    ();
    int                 match       (const Comparable& okey) const {return (*key) == okey;}
    DumpContext&        operator>>  (DumpContext& out) const;
    void                check       () const;

  private:
    decl_dynamic (MapPair);
};


class HashBucket : public Object {
  public:
    MapPair     pair;
    HashBucket* next;

                    HashBucket  ();
                    ~HashBucket ();
    DumpContext&    operator>>  (DumpContext& out) const;
    void            check       () const;

  private:
    decl_dynamic (HashBucket);
};

class HashFunc {
  public:
    virtual void    hashfunc    (int hashsize) const = 0;
};

EXCEPTIONCLASS (not_found);

class GenHash : public Object {
  public:

                    GenHash     (int hsize=64, int flags=0) {make (NULL, hsize, flags);}
                    GenHash     (HashFunc* hfunc, int hsize=16, int flags=0) {
                        make (hfunc, hsize, flags);
                    }
    void            make        (HashFunc* hashfunc, int hsize, int flags);
    
    void            set         (const Comparable* key, Object* value);
    const Object*   get         (const Comparable& key) const throw (not_found);
    DumpContext&    operator>>  (DumpContext& out) const;
    ostream&        operator>>  (ostream& out) const;
    void            empty       ();
    void            remove      (const Comparable& key);
    void            operator+=  (const GenHash& other);

    void            check       () const;
    
  protected:
    Array<HashBucket>   hash;
    int                 hashsize;
    HashFunc*           hashfunc;
    bool                isref;

  private:
    decl_dynamic (GenHash);
    friend GenHashIter;
};

class GenHashIter {
  public:

                        GenHashIter (const GenHash* hash);
    
    void                first       ();
    void                next        ();
    Comparable&         getkeyv     ();
    Object&             getvaluev   ();
    const Comparable&   getkey      () const;
    const Object&       getvalue    () const;
    int                 exhausted   () const {return exh;}

  protected:
    const GenHash*  hash;
    int             bucket;
    HashBucket*     currbucket;
    int             exh;
};

EXCEPTIONCLASS (map_item_not_found);

// Varsinainen käyttöliittymäluokka.
// Avainluokan on oltava Comparable-perillinen, mutta arvo voi olla mikä hyvänsä

template <class keyclass, class valueclass>
class Map : public Object {
  public:
                        Map         () {
                            hash = new GenHash ();
                            isref = 0;
                            mFailByThrow=false;
                            mFailByThrowOnce=false;
                            mFailByNullOnce=false;
                        }
                        Map         (int hashsize, int flags) {
                            hash = new GenHash (hashsize, flags);
                            isref = flags & MAP_REF;
                            mFailByThrow=false;
                            mFailByThrowOnce=false;
                            mFailByNullOnce=false;
                        }
                        Map (const Map& orig) {
                            hash = new GenHash ();
                            isref = 0;
                            mFailByThrow=false;
                            mFailByThrowOnce=false;
                            mFailByNullOnce=false;

                            // And copy
                            operator= (orig);
                        }
                        ~Map            () {delete hash;}

    void                set             (const keyclass& key, const valueclass& value) {
        keyclass* nkey = new keyclass (key);
        valueclass* nvalue = NULL;
        if (isref)
            nvalue = const_cast<valueclass*> (&value);
        else
            nvalue = new valueclass (value);
        hash->set (nkey, nvalue);
    }

    void                set             (const keyclass& key, const valueclass* value) {
        hash->set (new keyclass (key), const_cast<valueclass*> (value));
    }

    void                remove          (const keyclass& key) {
        hash->remove (key);
    }

    bool                hasKey          (const keyclass& key) const {
        return int(hash->get (key));
    }
    
    const valueclass&   operator[]      (const keyclass& key) const {
        return get (key);
    }

    valueclass& operator[]              (const keyclass& key) {
        return const_cast<valueclass&> (get (key));
    }

    const valueclass&   get             (const keyclass& key) const {
        const valueclass& result = (valueclass&) *hash->get (key);
        if ((mFailByThrow || mFailByThrowOnce) && !mFailByNullOnce) {
            mFailByThrowOnce = false;
            if (isnull(result)) {
                try {
                    const keyclass* dummy = &dynamic_cast<const keyclass&> (key);
                    dummy=NULL; // Have to do this to avoid a silly warning
                } catch (...) {
                    throw map_item_not_found ("Map item not found");
                }
                throw map_item_not_found (format("Map item '%s' not found", (CONSTR) key));
            }
        }
        mFailByNullOnce = false;
        return result;
    }

    valueclass&         getv            (const keyclass& key) {
        return const_cast<valueclass&> (get (key));
    }

    const valueclass&   getOr           (const keyclass& key, const valueclass& def) const {
        valueclass* tmp = (valueclass*) hash->get (key);
        return tmp? *tmp : def;
    }

    const valueclass*   getp            (const keyclass& key) const {
        return (valueclass*) hash->get (key);
    }

    valueclass*         getvp           (const keyclass& key) {
        return (valueclass*) hash->get (key);
    }

    // Miscellaneous operators

    virtual DumpContext&            operator>>  (DumpContext& out) const {
        hash->operator>> (out);
        return out;
    }

    virtual ostream&            operator>>      (ostream& out) const {
        hash->operator>> (out);
        return out;
    }

    Map<keyclass,valueclass>&   operator+=  (const Map<keyclass,valueclass>& other) {
        hash->operator+= (*other.hash);
        return *this;
    }

    Map<keyclass,valueclass>&   operator=   (const Map<keyclass,valueclass>& other) {
        hash->empty ();
        hash->operator+= (*other.hash);
        isref = other.isref;
        mFailByThrow=other.mFailByThrow;
        mFailByThrowOnce=other.mFailByThrowOnce;
        mFailByNullOnce=other.mFailByNullOnce;
        return *this;
    }

    void                empty           () {
        hash->empty ();
    }

    const GenHash*      gethash         () const {return hash;}

    void                check           () const {hash->check();}

    void failByThrow (bool bythrow=true) {mFailByThrow=bythrow;}

    void                failByThrowOnce (bool bythrow=true) const {mFailByThrowOnce=bythrow;}

    void                failByNullOnce  (bool bynull=true) const {mFailByNullOnce=bynull;}
    
  private:
    GenHash*        hash;
    bool            isref;
    bool            mFailByThrow;
    mutable bool    mFailByThrowOnce, mFailByNullOnce;
};

enum mapdefs {MAP_NONE=0, MAP_REF=1};

#define CMap Map

#define getOrDefault(map,key,def)\
    (isnull(map[key])? def : map[key])



//                    |   |            ---                                  //
//                    |\ /|  ___   --   |   |   ___                         //
//                    | V |  ___| |  )  |  -+- /   ) |/\                    //
//                    | | | (   | |--   |   |  |---  |                      //
//                    |   |  \__| |    _|_   \  \__  |                      //

template <class keyclass, class valueclass>
class MapIter {
  public:
    MapIter (const Map<keyclass,valueclass>& map) : iter (map.gethash()) {;}

    void                first       () {iter.first();}

    void                next        () {iter.next();}

    const keyclass&     key         () const {return (const keyclass&) iter.getkey();}

    keyclass&           key         () {return (keyclass&) iter.getkeyv();}

    const valueclass&   value       () const {return (const valueclass&) iter.getvalue();}

    valueclass&         value       () {return (valueclass&) iter.getvaluev();}

    int                 exhausted   () const {return iter.exhausted();}

  protected:
    GenHashIter iter;
};

#define forMap(keytype,valuetype,mapname,varname) \
    for (MapIter<keytype,valuetype> varname (mapname); !varname.exhausted(); varname.next())



//                ----         o             |   |                          //
//               (      |          _         |\ /|  ___   --                //
//                ---  -+- |/\ | |/ \   ___  | V |  ___| |  )               //
//                   )  |  |   | |   | (   \ | | | (   | |--                //
//               ___/    \ |   | |   |  ---/ |   |  \__| |                  //
//                                      __/                                 //

// StringMap is just an alias
typedef Map<String,String> StringMap;

// Reads String Map from file. Throws exception file_not_found if
// opening fails.
StringMap readStringMap (const String& filename);

// Reads String Map from stream
StringMap readStringMap (istream& in, const char* path=NULL);

void writeStringMap (const Map<String,String>& map, ostream& out);

String toString (const StringMap& map);

void splitpairs (StringMap& trg, const String& source, char psep='=', char rsep='&');

String joinpairs (const StringMap& src, char psep='=', char rsep='&');


#define forStringMap(mapname,varname) \
    for (MapIter<String,String> varname (mapname); !varname.exhausted(); varname.next())

#endif

---