hash-indexed.hpp

Go to the documentation of this file.

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

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

  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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#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