elementFormulaRCP.hh

Go to the documentation of this file.

 
#ifndef elementformulaRCP_hh
#define elementformulaRCP_hh
 
#if __cplusplus>=201103L
#include "elementFormulaRCP_std.hh"
 
#else
#include "elementFormulaRCP_boost.hh"
 
#endif
 
 
 
// #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:
//     /** Special constructor for a constant.
 
//         So, a constant can simply given to functions where a
//         RCP<ElementFormula<F> > is expected.
 
//         @see testsuite/testFormula.cc
//      */
//     explicit RCP(const F x) 
//       : boost::shared_ptr<const ElementFormula<F,G> >
//     (new const ConstFormula<F>(x)) {}
 
//     /// Default constructor, creates an RCP to a NULL-pointer
//     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
 
//     /** Constructor for a simple pointer to ElementFormula, which will
//         be deleted by the RCP.
 
//         It should be only called with pointer to dynamic variables, e.g.
//         <pre>RCP<const ElementFormula<Real> > p(new ConstFormula<Real>(4));</pre>
 
//         Do NOT use it with pointers to variables in the stack. Do not
//         <pre>ConstFormula<Real> i = 4; 
//         RCP<const ElementFormula<Real> > p(&i); // <-- DO NOT -- </pre>
 
//         Instead use the constructor for references (below) which makes a clone.
//      */
//     explicit RCP(const ElementFormula<F,G>* x) 
//       : boost::shared_ptr<const ElementFormula<F,G> >(x) {}
    
//     /// conversion constructor from boost::shared_ptr
//     RCP(boost::shared_ptr<const ElementFormula<F,G> >& x) 
//       : boost::shared_ptr<const ElementFormula<F,G> >(x) {}
 
//     /// conversion constructor from boost::shared_ptr<H>, where H can 
//     /// be converted into ElementFormula<F,G>
//     template<class H>
//     RCP(const boost::shared_ptr<H>& x) 
//       : boost::shared_ptr<const ElementFormula<F,G> >(x) {}
 
//     /// Constructor with any two parameters, I is a deleter function
//     template<class H, class I>
//     RCP(H x, I y) : boost::shared_ptr<const ElementFormula<F,G> >(x, y) {}
 
//     /// Constructor with a given reference, 
//     /// ElementFormula will be cloned.
//     ///
//     /// @BEWARE: this function is slightly inefficient (a copy is created),
//     //           but more importantly it is severely prone to errors.
//     /// @obsolete: try to write code which does NOT depend on this function,
//     //             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:
//     /** Special constructor for a constant.
 
//         So, a constant can simply given to functions where a
//         RCP<ElementFormula<F> > is expected.
 
//         @see testsuite/testFormula.cc
//      */
//     explicit RCP(const F x) 
//       : boost::shared_ptr<const Formula<F> >(new const ConstFormula<F>(x)) {}
 
//     /// Default constructor
//     RCP() : boost::shared_ptr<const Formula<F> >() {}
 
//     /** Constructor for a simple pointer to ElementFormula, which will
//         be deleted by the RCP.
 
//         It should be only called with pointer to dynamic variables, e.g.
//         <pre>RCP<const ElementFormula<Real> > p(new ConstFormula<Real>(4));</pre>
 
//         Do NOT use it with pointers to variables in the stack. Do not
//         <pre>ConstFormula<Real> i = 4; 
//         RCP<const ElementFormula<Real> > p(&i); // <-- DO NOT -- </pre>
 
//         Instead use the constructor for references (below) which makes a clone.
//      */
//     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) {}
 
//     /// Constructor with any two parameters
//     template<class H, class I>
//     RCP(H x, I y) : boost::shared_ptr<const Formula<F> >(x, y) {}
 
//     /// Constructor with a given reference, 
//     /// ElementFormula will be cloned.
//     ///
//     /// @BEWARE: this function is slightly inefficient (a copy is created),
//     //           but more importantly it is severely prone to errors.
//     /// @obsolete: try to write code which does NOT depend on this function,
//     //             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