common/p.hpp

Go to the documentation of this file.

/*
  P.hpp  -  customized shared_ptr with ordering and type relationships
 
  Copyright (C)         Lumiera.org
    2008,               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 LUMIERA_P_H
#define LUMIERA_P_H


#include <tr1/memory>


namespace lumiera
  {
  using std::tr1::shared_ptr;
  using std::tr1::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)  {}
      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::auto_ptr<Y> & ar)  : BASE(ar) {}      
    
      
      P& operator= (P const& r)                               { BASE::operator= (r);  return *this; }  
      template<class Y> P& operator=(shared_ptr<Y> const& sr) { BASE::operator= (sr); return *this; }
      template<class Y> P& operator=(std::auto_ptr<Y> & ar)   { BASE::operator= (ar); 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);}
      
    
    private: /* === friend operators injected into enclosing namespace for ADL === */
      template<typename _O_>
      friend inline bool
      operator== (P const& p, P<_O_> const& q) { return (p && q)? (*p == *q) : (!p && !q); }
  
      template<typename _O_>
      friend inline bool
      operator!= (P const& p, P<_O_> const& q) { return (p && q)? (*p != *q) : !(!p && !q); }
  
      template<typename _O_>
      friend inline bool
      operator<  (P const& p, P<_O_> const& q) { return (p && q) && (*p < *q); }
  
      template<typename _O_>
      friend inline bool
      operator>  (P const& p, P<_O_> const& q) { return (p && q) && (*q < *p); }

      template<typename _O_>
      friend inline bool
      operator<= (P const& p, P<_O_> const& q) { return (p && q)? (*p <= *q) : (!p && !q); }

      template<typename _O_>
      friend inline bool
      operator>= (P const& p, P<_O_> const& q) { return (p && q)? (*p >= *q) : (!p && !q); }
      
    };
   
    
} // namespace lumiera
#endif

---