formula/elementFormulaRCP.hh

Go to the documentation of this file.

#ifndef elementformulaRCP_hh
#define elementformulaRCP_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 boost::shared_ptr<const ElementFormula<F,G> >
  {
  public:
    explicit RCP(const F x) 
      : boost::shared_ptr<const ElementFormula<F,G> >
    (new const ConstFormula<F>(x)) {}

    RCP() : boost::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) 
      : boost::shared_ptr<const ElementFormula<F,G> >( old )
    {
    }
    #endif

    explicit RCP(const ElementFormula<F,G>* x) 
      : boost::shared_ptr<const ElementFormula<F,G> >(x) {}
    
    RCP(boost::shared_ptr<const ElementFormula<F,G> >& x) 
      : boost::shared_ptr<const ElementFormula<F,G> >(x) {}

    template<class H>
    RCP(const boost::shared_ptr<H>& x) 
      : boost::shared_ptr<const ElementFormula<F,G> >(x) {}

    template<class H, class I>
    RCP(H x, I y) : boost::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) 
      : boost::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 boost::shared_ptr<const ElementFormula<F,G> >(*this).operator*();
    }
#endif
  };


 // ************************************************ RCP<const Formula<F,G> > **

  template<class F>
  class RCP<const Formula<F> > : public boost::shared_ptr<const Formula<F> >
  {
  public:
    explicit RCP(const F x) 
      : boost::shared_ptr<const Formula<F> >(new const ConstFormula<F>(x)) {}

    RCP() : boost::shared_ptr<const Formula<F> >() {}

    explicit RCP(const Formula<F>* x) 
      : boost::shared_ptr<const Formula<F> >(x) {}
    
    RCP(boost::shared_ptr<const Formula<F> >& x) 
      : boost::shared_ptr<const Formula<F> >(x) {}

    template<class H>
    RCP(const boost::shared_ptr<H>& x) 
      : boost::shared_ptr<const Formula<F> >(x) {}

    template<class H, class I>
    RCP(H x, I y) : boost::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) : boost::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 boost::shared_ptr<const Formula<F> >(*this).operator*();
    }
#endif

  };


} // namespace concepts


#endif // elementformulaRCP_hh