buffer-local-tag.hpp

Go to the documentation of this file.

/*
  BUFFER-LOCAL-TAG.hpp  -  opaque data for BufferProvider implementation
 
   Copyright (C)
     2011,            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 STEAM_ENGINE_BUFFR_LOCAL_TAG_H
#define STEAM_ENGINE_BUFFR_LOCAL_TAG_H
 
 
#include "lib/error.hpp"
#include "lib/hash-value.h"
 
#include <boost/functional/hash.hpp>
 
 
namespace steam {
namespace engine {
  
  namespace metadata {
    class Key;
    class Entry;
  }
  class BufferMetadata;
  
  using lib::HashVal;
  
  
  
  class LocalTag
    {
      union OpaqueData
        {
          uint64_t _as_number;
          void*    _as_pointer;
        };
      
      OpaqueData privateID_;
      
    public:
      explicit
      LocalTag (uint64_t opaqueValue=0)
        {
          privateID_._as_number = opaqueValue;
        }
      
      LocalTag (void* impl_related_ptr)
        {
          privateID_._as_number  = 0;
          privateID_._as_pointer = impl_related_ptr;
        }
      
      LocalTag (LocalTag const&) = default;
      
      static const LocalTag UNKNOWN;
      
      operator uint64_t()  const
        {
          return privateID_._as_number;
        }
      
      operator void*()  const
        {
          return privateID_._as_pointer;
        }
      
      explicit
      operator bool()  const
        {
          return bool(privateID_._as_number);
        }
      
      friend size_t
      hash_value (LocalTag const& lkey)
      {
        boost::hash<uint64_t> hashFunction;
        return hashFunction(lkey.privateID_._as_number);
      }
      
      friend bool
      operator== (LocalTag const& left, LocalTag const& right)
      {
        return uint64_t(left) == uint64_t(right);
      }
      friend bool
      operator!= (LocalTag const& left, LocalTag const& right)
      {
        return uint64_t(left) != uint64_t(right);
      }
      
      
    private:
      LocalTag& operator= (LocalTag const& o)
        {
          privateID_ = o.privateID_;
          return *this;
        }
      
      friend class metadata::Key;
    };
  
  
}} // namespace steam::engine
#endif /*STEAM_ENGINE_BUFFR_LOCAL_TAG_H*/