include/realroot/shared_object.hpp

Go to the documentation of this file.

/********************************************************************
 *   This file is part of the source code of the realroot library.
 *   Author(s): B. Mourrain, GALAAD, INRIA
 *   $Id: shared_object.hpp,v 1.1 2005/07/11 11:23:12 mourrain Exp $
 ********************************************************************/
#ifndef mmx_shared_object_hpp
#define mmx_shared_object_hpp
//--------------------------------------------------------------------
#include <cassert>
#include <memory>
//#include <utility>
//#include <iterator>
//#include <algorithm>
//#include <set>
//#include <typeinfo>
//======================================================================
namespace mmx {

//template<typename C> inline void
//std__swap (C& x, C& y) {
//C temp= x;
//x= y;
//y= temp;
//}

#define define_operator_rrr(parm0,parm1,parm2,opname,function)  \
inline parm0                                                    \
opname(const parm1& x, const parm2& y) {                        \
  parm0 r; function(r.rep(),x.rep(),y.rep()); return r;         \
}

#define define_operator_rr_(parm0,parm1,parm2,opname,function)  \
inline                                                          \
parm0 opname(const parm1& x, const parm2& y) {                  \
  parm0 r; function(r.rep(),x.rep(),y); return r;               \
}
#define define_operator_r_r(parm0,parm1,parm2,opname,function)  \
inline                                                          \
parm0 opname(const parm1& x, const parm2& y) {                  \
  parm0 r; function(r.rep(),x,y.rep()); return r;               \
}

#define define_operator__r_(parm0,parm1,parm2,opname,function)  \
inline                                                          \
parm0 opname(const parm1& x, const parm2& y) {                  \
  parm0 r; function(r,x.rep(),y); return r;                     \
}


#define define_function_from_inplace(parm0,parm1,parm2,function)             \
inline                                                          \
void function(parm0& r, const parm1& x, const parm2& y) {       \
  r=x;function(r,y);                                            \
}

#ifndef assert
#define assert(expr,msg) if (!(expr)) assert (msg);
#endif

//======================================================================
struct AsSize {};
//--------------------------------------------------------------------
template <class R>
class shared_object {

public:
  typedef R element_type;
  //  typedef typename FUNC_ARG(element_type) func_arg;

protected:
  struct rep
  //    : generic_rep
  {
    int refc;
    R obj;

    template<class P0>
    rep(P0 a) : refc(1), obj(a) {};

    template<class P0, class P1>
    rep(P0 a, P1 b ) : refc(1), obj(a,b) {};

    template<class P0, class P1, class P2>
    rep(P0 a, P1 b, P2 c ) : refc(1), obj(a,b,c) {};
    
    template<class P0, class P1, class P2, class P3 >
    rep(P0 a, P1 b, P2 c, P3 d) : refc(1), obj(a,b,c,d) {};

    rep() : refc(1) {//std::cout<<"build data "<< refc<<std::endl;
    }

    rep(const rep& o) : refc(1), obj(o.obj)  { }
    ~rep() {}
    void*   operator new(size_t s)
      {return std::allocator<R>().allocate(s); }
    void  operator delete(void* p)
    {std::allocator<R>().deallocate((R*)p,sizeof(rep)); }

//     static const int TYPE=3000;
//     int Type() {return TYPE;}
  };

public:
   rep *body;

   void leave()
  {assert(body->refc>0);
    //std::cout<<"Leave  "<<body<<" "<<body->refc<<std::endl;
    if (! --body->refc) delete body;}
   void divorce()
    {assert(body->refc>1); --body->refc; body= new rep(*body);}

  typedef R object_type;
  typedef R* iterator;
  typedef const R* const_iterator;

  template<class P0>
  shared_object(P0 a) : body(new rep(a)){};
  template<class P0, class P1>
  shared_object(P0 a, P1 b) : body(new rep(a,b)){};
  template<class P0, class P1, class P2>
  shared_object(P0 a, P1 b, P2 c) : body(new rep(a,b,c)){};
  template<class P0, class P1, class P2, class P3>
  shared_object(P0 a, P1 b, P2 c, P3 d) : body(new rep(a,b,c,d)){};
  shared_object() : body(new rep())  {
    //std::cout<<"body   "<<body<<" "<<body->refc<<std::endl; 
  }
  shared_object(const R& obj_arg) : body(new rep(obj_arg)) {}
  shared_object(const shared_object& s) : body(s.body) {++body->refc;}
  shared_object(rep * s) : body(s) {++body->refc;}
  ~shared_object() {leave(); }

  shared_object& operator= (const shared_object& s)
    {
      if (this!=&s) {s.body->refc++; leave(); body=s.body;}
      return *this;
    }

  //  void swap(shared_object& s2) { std__swap(body,s2.body); }

  iterator operator-> () { if (body->refc > 1) divorce(); return &body->obj; }
  R&  operator*  () { if (body->refc > 1) divorce(); return  body->obj; }

  const_iterator operator-> () const { return &body->obj; }
  const R&  operator*  () const { return  body->obj; }

  int ref() const   {return body->refc;}
  int ref()         {return body->refc;}

};

// template<typename R> inline
// R view_as (generic g)
// {
//   typedef  typename R::rep_type REP;
//   if (gentype(g) != shared_object<REP>::rep::TYPE)
//     std::cerr<<"generic  of type "<<gentype(g)
//           <<"is not an obj of required type "
//      << shared_object<REP>::rep::TYPE<<std::endl;
//   shared_object<REP> x((typename shared_object<REP>::rep*)g.rep);
//   return  R(x);//(REP*)g.rep);
// }
template< class R>
  struct rep_view
  {
#define NOREFCOUNT
#ifdef  NOREFCOUNT
    R data;
    R &       rep()       {return data;}
    const R & rep() const {return data;}
#else
    shared_object<R> data;
    R &       rep()       {return *data;}
    const R & rep() const {return *data;}
#endif
  };
//----------------------------------------------------------------------
template<class R>
inline       R & rep(R & r)       {return r;}

template<class R>
inline const R & rep(const R & r) {return r;}

template<class R>
inline       R & rep(shared_object<R> & r)       {return *r;}

template<class R>
inline const R & rep(const shared_object<R> & r) {return *r;}


template<class T>
struct ReferTo
{
  typedef T value_type;
};


template<class T>
struct ReferTo<shared_object<T> >
{
  typedef T value_type;
};


//======================================================================
} //namespace mmx
//======================================================================
#endif // mmx_shared_object_hpp

---