synaps/base/shared_object.h

/********************************************************************
 *   This file is part of the source code of the SYNAPS library.
 *   Author(s): B. Mourrain, GALAAD, INRIA
 *   $Id: shared_object.h,v 1.1 2005/07/11 11:23:12 mourrain Exp $
 ********************************************************************/
#ifndef synaps_util_shared_object_H
#define synaps_util_shared_object_H
//--------------------------------------------------------------------
#include <synaps/init.h>
#include <cassert>
#include <memory>
#include <utility>
#include <iterator>
#include <algorithm>
#include <set>
#include <typeinfo>
#include <synaps/init.h>
//#include <synaps/base/const_ref_or_val.h>
/********************************************************************/
__BEGIN_NAMESPACE_SYNAPS
//--------------------------------------------------------------------

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) { }

    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);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()) { }
  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;
};

__END_NAMESPACE_SYNAPS
/********************************************************************/

#endif // synaps_util_shared_object_H