elementFormulaRCP_std.hh

Go to the documentation of this file.

 
#ifndef elementformulaRCP_std_hh
#define elementformulaRCP_std_hh
 
#include "toolbox/sharedPointer.hh"
#include "elementFormula.hh"
#include "formula.hh"
#include "constFormula.hh"
 
#define ElemFormRCPClone_D 0
#define ElemFormRCPValue_D 0
#define FormRCPClone_D 0
#define FormRCPValue_D 0
 
namespace concepts {
 
 
 // ***************************************** RCP<const ElementFormula<F,G> > **
  
  template<class F, typename G>
  class RCP<const ElementFormula<F,G> > 
    : public std::shared_ptr<const ElementFormula<F,G> >
  {
  public:
    explicit RCP(const F x) 
      : std::shared_ptr<const ElementFormula<F,G> >
    (new const ConstFormula<F>(x)) {}
 
    RCP() : std::shared_ptr<const ElementFormula<F,G> >() {}
 
    // this conversion operator is already implemented for shared_ptr
    #if 0
    // implicit conversion ops.
    template<class OldF, class OldG>
      RCP(RCP< const ElementFormula<OldF,OldG> > old) 
      : std::shared_ptr<const ElementFormula<F,G> >( old )
    {
    }
    #endif
 
    explicit RCP(const ElementFormula<F,G>* x) 
      : std::shared_ptr<const ElementFormula<F,G> >(x) {}
    
    RCP(std::shared_ptr<const ElementFormula<F,G> >& x) 
      : std::shared_ptr<const ElementFormula<F,G> >(x) {}
 
    template<class H>
    RCP(const std::shared_ptr<H>& x) 
      : std::shared_ptr<const ElementFormula<F,G> >(x) {}
 
    template<class H, class I>
    RCP(H x, I y) : std::shared_ptr<const ElementFormula<F,G> >(x, y) {}
 
    //           but more importantly it is severely prone to errors.
    //             this functions tells C++ to convert any const
    //             reference to ElementFormulas AUTOMATICALLY into
    //             RCP<ElementFormula>. In particular this strip of code
    //             equates EF-References with EF-SmartPointer, so it equates
    //             references with pointers. I do not know which side effects
    //             this strip of code can create, but expect severe ones! 
    //explicit RCP(const ElementFormula<F,G>& x) 
    RCP(const ElementFormula<F,G>& x) 
      : std::shared_ptr<const ElementFormula<F,G> >(x.clone())
    {
      DEBUGL(ElemFormRCPClone_D, "Cloned " << **this << " = *" << *this);
    }
    
    RCP<const ElementFormula<F,G> >& 
    operator=(const RCP<const ElementFormula<F,G> >& x)
    {
      RCP<const ElementFormula<F,G> >(x).swap(*this);
      return *this;
    }
 
    template<class H>
    RCP<const ElementFormula<F,G> >& 
    operator=(const RCP<H>& x)
    {
      RCP<const ElementFormula<F,G> >(x).swap(*this);
      return *this;
    }
 
#if ElemFormRCPValue_D
    // for debugging in case of zero pointers: output of pointer
    const ElementFormula<F,G>& operator* () const // never throws
    {
      DEBUGL(1, *this);
      return std::shared_ptr<const ElementFormula<F,G> >(*this).operator*();
    }
#endif
  };
 
 
 // ************************************************ RCP<const Formula<F,G> > **
 
  template<class F>
  class RCP<const Formula<F> > : public std::shared_ptr<const Formula<F> >
  {
  public:
    explicit RCP(const F x) 
      : std::shared_ptr<const Formula<F> >(new const ConstFormula<F>(x)) {}
 
    RCP() : std::shared_ptr<const Formula<F> >() {}
 
    explicit RCP(const Formula<F>* x) 
      : std::shared_ptr<const Formula<F> >(x) {}
    
    RCP(std::shared_ptr<const Formula<F> >& x) 
      : std::shared_ptr<const Formula<F> >(x) {}
 
    template<class H>
    RCP(const std::shared_ptr<H>& x) 
      : std::shared_ptr<const Formula<F> >(x) {}
 
    template<class H, class I>
    RCP(H x, I y) : std::shared_ptr<const Formula<F> >(x, y) {}
 
    //           but more importantly it is severely prone to errors.
    //             this functions tells C++ to convert any const
    //             reference to ElementFormulas AUTOMATICALLY into
    //             RCP<ElementFormula>. In particular this strip of code
    //             equates EF-References with EF-SmartPointer, so it equates
    //             references with pointers. I do not know which side effects
    //             this strip of code can create, but expect severe ones! 
    explicit RCP(const Formula<F>& x) : std::shared_ptr<const Formula<F> >(x.clone())
    {
      DEBUGL(FormRCPClone_D, "Cloned " << **this << " = *" << *this);
    }
    
    RCP<const Formula<F> >& 
    operator=(const RCP<const Formula<F> >& x)
    {
      RCP<const Formula<F> >(x).swap(*this);
      return *this;
    }
 
    template<class H>
    RCP<const Formula<F> >& 
    operator=(const RCP<H>& x)
    {
      RCP<const Formula<F> >(x).swap(*this);
      return *this;
    }
 
#if FormRCPValue_D
    // for debugging in case of zero pointers: output of pointer
    const Formula<F>& operator* () const // never throws
    {
      DEBUGL(1, *this);
      return std::shared_ptr<const Formula<F> >(*this).operator*();
    }
#endif
 
  };
 
 
} // namespace concepts
 
 
#endif // elementformulaRCP_std_hh