p.hpp

Go to the documentation of this file.

/*
  P.hpp  -  customised shared_ptr with ordering and type relationships
 
   Copyright (C)
     2008,            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_P_H
#define LIB_P_H
 
 
#include "lib/error.hpp"
#include "lib/meta/util.hpp"
 
#include <memory>
 
 
namespace lib {
  
  using std::shared_ptr;
  using std::weak_ptr;
  
  template<class TAR, class BASE =shared_ptr<TAR>>
  class P
    : public BASE
    {
    public:
                                 P ( )                      : BASE() {}
      template<class Y> explicit P (Y* p)                   : BASE(p) {}
      template<class Y, class D> P (Y* p, D d)              : BASE(p,d){}
      
                                 P (P const& r)             : BASE(r)  {}
                                 P (P const&& rr)           : BASE(rr) {}
      template<class Y>          P (shared_ptr<Y> const& r) : BASE(r)  {}
      template<class Y> explicit P (weak_ptr<Y> const& wr)  : BASE(wr) {}
      template<class Y> explicit P (std::unique_ptr<Y>&& u) : BASE(u.release()) {}
      
      
      P& operator= (P const& r)                               { BASE::operator= (r);  return *this; }
      P& operator= (P const&& rr)                             { BASE::operator= (rr); return *this; }
      template<class Y> P& operator=(shared_ptr<Y> const& sr) { BASE::operator= (sr); return *this; }
      
      TAR* get() const        { return dynamic_cast<TAR*> (BASE::get()); }
      TAR& operator*() const  { return *get(); }
      TAR* operator->() const { return get();  }
      
      void swap(P& b)         { BASE::swap (b);}
      
      operator std::string()  const noexcept;
      
      
    private: /* === friend operators injected into enclosing namespace for ADL === */
      template<typename _O_,typename B>
      friend inline bool
      operator== (P const& p, P<_O_, B> const& q) { return (p and q)? (*p == *q) : (!p and !q); }
      template<typename _O_,typename B>
      friend inline bool
      operator!= (P const& p, P<_O_, B> const& q) { return (p and q)? (*p != *q) : !(!p and !q); }
      
      template<typename _O_,typename B>
      friend inline bool
      operator<  (P const& p, P<_O_, B> const& q) { REQUIRE (p and q); return *p < *q; }   
      
      template<typename _O_,typename B>
      friend inline bool
      operator>  (P const& p, P<_O_, B> const& q) { REQUIRE (p and q); return *q < *p; }
      
      template<typename _O_,typename B>
      friend inline bool
      operator<= (P const& p, P<_O_, B> const& q) { REQUIRE (p and q); return *p <= *q;}
      
      template<typename _O_,typename B>
      friend inline bool
      operator>= (P const& p, P<_O_, B> const& q) { REQUIRE (p and q); return *p >= *q;}
      
    };
  
  
  
  
  template<typename X, typename...ARGS>
  inline P<X>
  makeP (ARGS&&... ctorArgs)
  {
    return P<X>{new X {std::forward<ARGS>(ctorArgs)...}};
  }
  
  
  
  template<class TAR, class BASE>
  inline
  P<TAR,BASE>::operator std::string()  const noexcept
  try {
    if (BASE::get())
      return util::StringConv<TAR>::invoke (this->operator*());
    else
      return "⟂ P<"+meta::typeStr<TAR>()+">";
  }
  catch(...)
  { return meta::FAILURE_INDICATOR; }
  
  
  
} // namespace lib
#endif