entry-id.hpp

Go to the documentation of this file.

/*
  ENTRY-ID.hpp  -  plain symbolic and hash ID used for accounting

  Copyright (C)         Lumiera.org
    2010,               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_IDI_ENTRY_ID_H
#define LIB_IDI_ENTRY_ID_H


#include "lib/error.hpp"
#include "lib/hash-indexed.hpp"
#include "lib/idi/genfunc.hpp"
#include "lib/util.hpp"

#include <boost/functional/hash.hpp>
#include <boost/operators.hpp>
#include <string>


namespace lib {

namespace idi {
  
  namespace error = lumiera::error;
  
  using std::string;
  using std::ostream;
  
  using lib::idi::generateSymbolicID;
  using lib::idi::getTypeHash;
  using lib::idi::typeSymbol;
  using lib::hash::LuidH;
  using lib::HashVal;
  
  namespace {
    const size_t KNUTH_MAGIC = 2654435761;
    
    
    inline LuidH
    buildHash (string const& sym, HashVal seed =0)
    {
      size_t l = sym.length();
      if (l > 1) boost::hash_combine(seed, KNUTH_MAGIC * sym[l-1]);
      if (l > 2) boost::hash_combine(seed, KNUTH_MAGIC * sym[l-2]);
      if (l > 3) boost::hash_combine(seed, KNUTH_MAGIC * sym[l-3]);
      if (l > 4) boost::hash_combine(seed, KNUTH_MAGIC * sym[l-4]);       
      
      boost::hash_combine(seed, sym);
      lumiera_uid tmpLUID;
      lumiera_uid_set_ptr (&tmpLUID, reinterpret_cast<void*> (seed));
      return reinterpret_cast<LuidH&> (tmpLUID);
    }
  }
  
  
  
  template<class TY>
  struct EntryID;
  
  
  class BareEntryID
    : public boost::equality_comparable<BareEntryID>
    {
      
      string symbol_;
      LuidH hash_;
      
    protected:
      BareEntryID (string const& symbolID, HashVal seed)
        : symbol_(symbolID)
        , hash_(buildHash (symbol_, seed))
        { }
      
      explicit
      BareEntryID (string const& symbolID)
        : symbol_(symbolID)
        , hash_{} // random
        { }
      
    public:
      /* default copyable and assignable */
      
      
      bool
      isValid()  const
        {
          return bool(hash_);
        }
      
      string const&
      getSym()  const
        {
          return symbol_;
        }
      
      LuidH const&
      getHash()  const
        {
          return hash_;
        }
      
      operator string()  const;
      
      
      struct UseEmbeddedHash
        : public std::unary_function<BareEntryID, size_t>
        {
          size_t operator() (BareEntryID const& obj)  const { return obj.getHash(); }
        };
      
      
      template<typename TAR>
      EntryID<TAR> const& recast()  const;
      
    };
  
  
  template<class TY>
  struct EntryID
    : BareEntryID
    , boost::totally_ordered< EntryID<TY> >
    {
      
      EntryID()
        : BareEntryID (generateSymbolicID<TY>(), getTypeHash<TY>())
        { }
      
      explicit
      EntryID (string const& symbolID)
        : BareEntryID (util::sanitise(symbolID), getTypeHash<TY>())
        { }
      explicit
      EntryID (const char* symbolID)
        : BareEntryID (util::sanitise(symbolID), getTypeHash<TY>())
        { }
      
      explicit
      EntryID (Symbol const& internalSymbol)
        : BareEntryID (string(internalSymbol), getTypeHash<TY>())
        { }
      
      
      static bool
      canRecast (BareEntryID const& bID)
        {
          return bID.getHash() == buildHash (bID.getSym(), getTypeHash<TY>());
        }
      
      static EntryID const&
      recast (BareEntryID const& bID)
        {
          if (!canRecast(bID))
            throw error::Logic ("unable to recast EntryID: desired type "
                                "doesn't match original definition"
                               , error::LUMIERA_ERROR_WRONG_TYPE);
          return static_cast<EntryID const&> (bID);
        }
      
      explicit
      operator string()  const;
      
      friend bool operator<  (EntryID const& i1, EntryID const& i2) { return i1.getSym()  < i2.getSym(); }
    };
    
  
  inline bool
  operator== (BareEntryID const& i1, BareEntryID const& i2)
  {
    return i1.getHash() == i2.getHash();
  }
  
  
  
  
  struct RandID
    : BareEntryID
    {
      RandID (string const& symbolID)
        : BareEntryID{util::sanitise (symbolID)}
        { }
      RandID (const char* symbolID)
        : BareEntryID{util::sanitise (symbolID)}
        { }
      RandID (Symbol const& internalSymbol)
        : BareEntryID{string{internalSymbol}}
        { }
    };
  
  
  template<typename TAR>
  EntryID<TAR> const&
  BareEntryID::recast()  const
  {
    return EntryID<TAR>::recast(*this);
  }
  
  
  inline
  BareEntryID::operator string()  const
  {
    return "bID-"+lib::idi::format::instance_hex_format(symbol_, hash_);
  }
  
  template<class TY>
  inline
  EntryID<TY>::operator string()  const
  {
    return "ID<"+typeSymbol<TY>()+">-"+EntryID::getSym();
  }
  
  
  
}} // namespace lib::idi
#endif /*LIB_IDI_ENTRY_ID_H*/