---

mmap.h

Go to the documentation of this file.

#ifndef __MAGIC_MMAP_H__
#define __MAGIC_MMAP_H__

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

BEGIN_NAMESPACE (MagiC);


// Externals
class DataOStream;

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


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

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;}
    DataOStream&        operator>>  (DataOStream& out) const;
    void                check       () const;

  private:
    decl_dynamic (MapPair);
};


//                                                                          //
//                  ----             |   |             |                    //
//                 |      ___    _   |   |  ___   ____ | _                  //
//                 | --- /   ) |/ \  |---|  ___| (     |/ |                 //
//                 |   \ |---  |   | |   | (   |  \__  |  |                 //
//                 |___/  \__  |   | |   |  \__| ____) |  |                 //
//                                                                          //

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

                    HashBucket  ();
                    ~HashBucket ();
    DataOStream&    operator>>  (DataOStream& 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);
    DataOStream&    operator>>	(DataOStream& out) const;
    TextOStream&    operator>>	(TextOStream& 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 class 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);

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

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* pResult = (valueclass*) hash->get (key);
        if ((mFailByThrow || mFailByThrowOnce) && !mFailByNullOnce) {
            if (pResult == NULL) {
                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));
            }
        }
        mFailByThrowOnce = false;
        mFailByNullOnce  = false;
        return *pResult;
    }

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

    /***************************************************************************
     *  Returns a const reference to object associated to the key, OR
     *  if the key is not found from the map, returns the 'def'
     *  reference back to the caller.
     *
     *  For information about error handling and exceptions, see @ref
     *  failByThrowOnce().
     *
     *  @see get
     ***************************************************************************/
    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 DataOStream&            operator>>	(DataOStream& out) const {
        hash->operator>> (out);
        return out;
    }

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

    virtual TextOStream&        operator>>		(TextOStream& 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)\
    (map.getp(key)? *map.getp(key):def)



//                    |   |            ---                                  //
//                    |\ /|  ___   --   |   |   ___                         //
//                    | 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 (TextIStream& in, const char* path=NULL);

void writeStringMap (const Map<String,String>& map, TextOStream& 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())

END_NAMESPACE;

#endif

---