Converting your code to NoPtr library

If you have code that uses raw pointers that you would like to convert to use NoPtr, the following steps should be a good start:

1. Do only one change at a time since any compiler error message are likely to be fairly verbose; recompile and retest often;
2. "Free" owned DAO's (i.e. not in STL containers):
   • Replace "Obj* obj = new Obj(...);" with "DynObj<Obj> obj( new Obj(...) );" and class member declarations like "Obj* obj;" by "DynObj<Obj> obj;";
   • Replace expressions like "obj->member" by "obj().member", and leave those like "*obj" unchanged;
   • If a function returns a DAO without giving up ownership of it, just replace "return obj;" by "return obj.getPtr();";
   • If the function is also relinquishing ownership of the DAO to the caller, replace "return obj;" by "return obj.moveToTmp();", the declaration "Obj* fun();" by "DynTmp<Obj> fun();", and the call "Obj* obj = fun();" by "Obj* obj = fun().release();";
   • Replace expressions like "obj = newPtr;" by "obj.acquire(newPtr)" if obj is being changed to represent "newPtr" instead, and will own newPtr; if obj should not take ownership of newPtr, you have a design flaw (you're mixing ownership with non-ownership); in this case decide whether obj should really be a DynObj or an RRef; if the latter, see RRef;
     
     E.g. the traditionally written

         Obj* fun() {
             Obj* obj = new Obj(123);
             obj->method();
             if (*obj == Obj()) {delete obj; obj=NULL;}
             return obj;
         }
     

     becomes

         DynTmp<Obj> fun() {
             DynObj<Obj> obj( new Obj(123) );
             obj().method();
             if (*obj != Obj()) obj.reset();
             return obj.moveToTmp();
         }
     

     
     
3. Pure access of DAO (free or in containers), no ownership:
   • Replace expressions like "Obj* obj = rhs;", where rhs is a DynObj, or an Obj* owned by some other object or scope, by "Obj* obj(rhs);";
   • Replace expressions like "obj = rhs;", where rhs is an Obj* owned by some other object or scope, by "obj.reset(rhs)";
   • Replace declarations like "std::list<Obj*> list" by "std::list<RRef<Obj> >", assuming the list does not own the DAO's;
   • If you have to create a "std::list<RRef<Obj> >" from a "std::list<DynObj<Obj>::InValueContainer>" you have to loop over the latter and pushing back items on the former;
     
     E.g. the traditionally written

         Obj* fun(Obj* newObj) {
             Obj* obj = newObj;
             ...
             obj->method();
             ...
             return obj;
         }
     

     becomes

         RRef<Obj> fun(const RRef<Obj>& newObj) {
             RRef<Obj> obj( newObj );
             ...
             obj().method();
             ...
             return obj;
         }
     

     
     
4. DynObj inside STL containers
   • Replace declarations like "typedef std::list<Obj*> List;" by "typedef std::list<DynObj<Obj>::InValueContainer> List;"
   • Replace expressions like "(*iter)->method();" by "(**iter).method();" (note double star), where "iter" is defined e.g. "List::iterator iter = list.begin();";
   • Replace expressions like "list.push_back(new Obj(...))" by "list.push_back( makeDynObj(new Obj(...)) )"
   • Replace expressions like "list.push_back(ptr)" by "list.push_back( obj.giveAway() )", taking note that obj is null after the call (it was moved onto the list);
     
     E.g. the traditionally written

         class Foo {
             typedef std::list<Obj*> List;
             Foo() { 
                 list.push_back(new Bar(1)); 
                 list.push_back(new Bar(2)); 
                 (*list.begin())->method();
                 list.front()->method();
                 
                 Bar* bar = new Bar(3);
                 ... // hope no throw otherwise leak occurs!
                 list.push_back(bar);
             }
             ~Foo() { /* loop over each item of list and call delete on it */ }
             List list;
         };
     

     becomes

         class Foo {
             typedef std::list<DynObj<Obj>::InValueContainer> List;
             Foo() { 
                 list.push_back( makeDynObj(new Bar(1)) ); 
                 list.push_back( makeDynObj(new Bar(2)) ); 
                 (**list.begin()).method();
                 (*list.front()).method();
                 
                 DynObj<Bar> bar(new Bar(3));
                 ... // exception safe
                 list.push_back(bar.giveAway());
             }
             ~Foo() {}
             List list;
         };
     

---