pghandle.h

Go to the documentation of this file.

// include guard
#ifndef TF_PGHANDLE_H_VERSION

#define TF_PGHANDLE_H_VERSION \
  "TF_PGHANDLE_H   V1.0   "
#define TF_PGHANDLE_H_CVSID \
  "$Id$"

namespace pgplot {


  template<class X>
    class HandleOfConst {
      public:
        template<class Y> friend class HandleOfConst;

        typedef X Tvalue;
        typedef X* Tpointer;
        typedef X& Treference;
        typedef const X* Tpointer_to_const;
        typedef const X& Treference_to_const;
        typedef HandleOfConst<Tvalue> Tcontainer;
        typedef Tcontainer Tcontainer_of_const;
        typedef Tcontainer_of_const Tcoc;

        HandleOfConst():
          Mpointer(new Tvalue()), Mpcount(new int(1)) { }

        HandleOfConst(Treference_to_const x):
          Mpointer(new Tvalue(x)), Mpcount(new int(1)) { }

        template<class Y>
          HandleOfConst<X>(const HandleOfConst<Y>& h): 
          Mpointer(h.Mpointer), Mpcount(h.Mpcount) 
          { (*Mpcount)++; }

        ~HandleOfConst() 
        { if (--(*Mpcount)==0) { delete Mpointer; delete Mpcount; } }


        Tpointer_to_const operator->() const { return Mpointer; }

        Treference_to_const operator*() const { return *Mpointer; }

        template<class Y>
          Tcontainer& operator=(const HandleOfConst<Y>& h)
          {
            if (Mpointer == h.Mpointer) return *this;
            if (--(*Mpcount) == 0) { delete Mpointer; delete Mpcount; }
            Mpointer=h.Mpointer;
            Mpcount=h.Mpcount;
            (*Mpcount)++;
            return *this;
          }

      protected:

        Tpointer pointer() const { return Mpointer;}

        Treference reference() const { return *Mpointer;}

      private:
        Tpointer Mpointer;
        int* Mpcount;
    }; // template class HandleOfConst

  /*----------------------------------------------------------------------*/

  template<class X>
    class Handle: public HandleOfConst<X> {
      public:
        typedef X Tvalue;
        typedef X* Tpointer;
        typedef X& Treference;
        typedef const X* Tpointer_to_const;
        typedef const X& Treference_to_const;
        typedef HandleOfConst<Tvalue> Tbase;
        typedef Handle<Tvalue> Tcontainer;
        typedef Tbase Tcontainer_of_const;
        typedef Tcontainer_of_const Tcoc;
        Handle(): Tbase() { }

        Handle(Treference_to_const x): 
          Tbase(x) { }

        template<class Y>
          Handle(const Handle<Y>& h): Tbase(h) { }


        Tpointer operator->() const { return Tbase::pointer(); }

        Treference operator*() const { return Tbase::reference(); }

        template<class Y>
          Tcontainer& operator=(const Handle<Y>& h)
          { 
            Tbase::operator=(h);
            return *this;
          }

    }; // template class Handle

} // namespace pgplot

#endif // TF_PGHANDLE_H_VERSION (includeguard)

/* ----- END OF pghandle.h ----- */