placement-ref.hpp

Go to the documentation of this file.

/*
  PLACEMENT-REF.hpp  -  generic reference to an individual placement added to the session

   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 MOBJECT_PLACEMENT_REF_H
#define MOBJECT_PLACEMENT_REF_H

#include "lib/error.hpp"
#include "steam/mobject/placement.hpp"
#include "steam/mobject/explicitplacement.hpp"  
#include "steam/mobject/session/session-service-fetch.hpp"


namespace lumiera {
namespace error {
  LUMIERA_ERROR_DECLARE (INVALID_PLACEMENTREF);  
  LUMIERA_ERROR_DECLARE (BOTTOM_PLACEMENTREF);  
}}


namespace steam {
  namespace error = lumiera::error;
  
  namespace mobject {
  
  class MObject;
  
  
  
  template<class MX =MObject>
  class PlacementRef
    {
      typedef Placement<MX>      PlacementMX;
      typedef Placement<MObject>::ID     _ID;
      typedef Placement<MObject>::Id<MX> _Id;
      
      _Id id_;
      
    public:
      template<class Y>
      explicit
      PlacementRef (Y const& refID)
        : id_(recast (refID))
        {
          validate(id_);
        }
      
      PlacementRef ()
        : id_( bottomID() )
        {
          REQUIRE (!isValid(), "hash-ID clash with existing ID");
        }
      
      PlacementRef (PlacementRef const& r)    
        : id_(r.id_)
        {
          validate(id_);
        }
      
      template<class X>
      PlacementRef (PlacementRef<X> const& r) 
        : id_(recast(r))
        {
          validate(id_);
        }
      
      
      PlacementRef&
      operator= (PlacementRef const& r)
        {
          validate(r.id_);
          id_ = r.id_;
          return *this;
        }
      
      template<class X>
      PlacementRef&
      operator= (PlacementRef<X> const& r)
        {
          validate(recast (r));
          id_ = recast(r);
          return *this;
        }
      
      template<class Y>
      PlacementRef&
      operator= (Y const& refID)
        {
          validate (recast (refID));
          id_ = recast (refID);
          return *this;
        }
      
      void clear () { id_ = bottomID(); }
      
      
      
      /* == forwarding smart-ptr operations == */
      
      PlacementMX& operator*()  const { return access(id_); } 
      
      PlacementMX& operator->() const { return access(id_); } 
      
      operator string()         const { return access(id_).operator string(); }
      size_t use_count()        const { return access(id_).use_count(); }
      
      
      /* == accessing the embedded ID == */
      operator _Id const&()     const { return id_; }
      LumieraUid getLUID()      const { return id_.get(); }
      
      template<class O>
      bool operator== (PlacementRef<O> const& o)  const { return id_ == o; }
      template<class O>
      bool operator!= (PlacementRef<O> const& o)  const { return id_ != o; }
      
      
      
      
      
      /* == forwarding part of the Placement-API == */
      
      explicit
      operator bool()  const
        {
          return isValid();
        }
      
      bool isValid()  const
        {
          if (checkValidity())
            try
              {
                return access(id_).isValid();
              }
            catch (error::Invalid&) {}
            
          return false;
        }
      
      ExplicitPlacement
      resolve() const
        {
          return access(id_).resolve();
        }
      
      
      
    private:
      bool
      checkValidity ()  const
        {
          return session::SessionServiceFetch::isAccessible() // session interface opened?
              && session::SessionServiceFetch::isRegisteredID (this->id_);
        }
      
      static void
      validate (_Id const& rId)
        {
          access (rId); // may throw
        }
      
      static _Id const&
      recast (_ID const& someID)
        {
          return static_cast<_Id const&> (someID);
        }
      
      static _Id const&
      recast (const LumieraUid luid)
        {
          REQUIRE (luid);
          return reinterpret_cast<_Id const&> (*luid);
        }
      
      static _Id const&
      bottomID ()  
        {
          static lumiera_uid invalidLUID;
          return recast (&invalidLUID);
        }
      
      static PlacementMX&
      access (_Id const& placementID)
        {
          if (!placementID)
            throw error::Logic{"Attempt to access a NIL PlacementRef"
                              , LERR_(BOTTOM_PLACEMENTREF)};
          
          Placement<MObject> & genericPlacement (session::SessionServiceFetch::resolveID (placementID));  // may throw
          REQUIRE (genericPlacement.isValid());
          
          if (!(genericPlacement.template isCompatible<MX>()))
            throw error::Invalid{"actual type of the resolved placement is incompatible"
                                , LERR_(INVALID_PLACEMENTREF)};
          
          return static_cast<PlacementMX&> (genericPlacement);
        }
    };
  
  
  typedef PlacementRef<MObject> RefPlacement;
  
  
  
}} // namespace steam::mobject
#endif