hash-indexed.hpp

Go to the documentation of this file.

/*
  HASH-INDEXED.hpp  -  generic hash based and typed ID

   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** 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. See the file COPYING for further details.

*/


#ifndef LIB_HASH_INDEXED_H
#define LIB_HASH_INDEXED_H

#include "lib/hash-value.h"
#include "lib/hash-standard.hpp"
#include "lib/error.hpp"

extern "C" {
#include "lib/luid.h"
}

#include <functional>


namespace lib {
  
  namespace hash {
    
    class Plain
      {
        const HashVal hash_;
        
      public:
        Plain (HashVal val)
          : hash_(val)
          { }
        
        template<typename TY>
        Plain (TY const& something)
          : hash_(hash_value (something))  // ADL
          { }
        
        operator HashVal()  const { return hash_; }
      };
    
    class LuidH 
      {
        lumiera_uid luid_;
        
      public:
        LuidH ()
          {
            lumiera_uid_gen (&luid_);
            ENSURE (0 < lumiera_uid_hash(&luid_));
          }
        
        operator HashVal()                const { return lumiera_uid_hash (get()); }
        bool operator== (LuidH const& o)  const { return lumiera_uid_eq (get(), o.get()); }
        bool operator!= (LuidH const& o)  const { return not operator== (o); }
        
        LUID get()                        const { return const_cast<LUID> (&luid_);}
      };
    
    
    /* === for use within unordered_map === */
    inline HashVal hash_value (Plain const& plainHash)  { return plainHash; }
    inline HashVal hash_value (LuidH const& luid_Hash)  { return luid_Hash; }
    
  } // namespace "hash"
  
  
  
  /********************************************************/
  template<class BA, class IMP>
  struct HashIndexed
    {
      
      struct ID : IMP
        {
          ID ()              : IMP ()            {}
          ID (BA const& ref) : IMP (ref.getID()) {}   // note: automatic conversion (e.g. from PlacementMO&)
          ID (IMP const& ir) : IMP (ir)          {}
        };
      
      template<typename T>
      struct Id : ID
        {
          Id ()             : ID ()    {}
          Id (T const& ref) : ID (ref) {}
        };
      
      
      struct UseEmbeddedHash
        : public std::unary_function<BA, HashVal>
        {
          HashVal operator() (BA const& obj)  const { return obj.getID(); }
        };
      
      struct UseHashID
        : public std::unary_function<ID, HashVal>
        {
          HashVal operator() (ID const& id)  const { return id; }
        };
      
      
      ID const&
      getID ()  const
        { 
          return id_; 
        }
      
      template<typename T>
      Id<T> const&
      recastID ()  const
        {
          return reinterpret_cast<Id<T> const&> (getID());
        }
      
      void
      assignID (HashIndexed const& ref)
        { 
          this->id_ = ref.getID();
        }
      
      friend bool operator== (HashIndexed const& hal, HashIndexed const& har) { return hal.id_==har.id_; }
      friend bool operator!= (HashIndexed const& hal, HashIndexed const& har) { return hal.id_!=har.id_; }
      
      
    protected:
      HashIndexed ()                : id_()     {}
      HashIndexed (IMP const& iref) : id_(iref) {}
      
    private:
      ID id_;
    };
  
  
  
  
  
} // namespace lib
#endif