Portable thread-based garbage collection library, for C++

#ifndef LIBGC_BASICPTR_HPP
#define LIBGC_BASICPTR_HPP


#include "libgc/garbage_collector.hpp"
#include "libgc/object.hpp"


namespace libgc {


/** base class for all pointer classes.
 */
class basic_ptr : public gc_ptr {
protected:    
    /** the default constructor.
     */ 
    basic_ptr() {
    }
    
    /** constructor from value.
        @param val initial value
     */ 
    basic_ptr(void *val) : gc_ptr(val) {
    }
    
    /** the copy constructor.
        @param obj source object.
     */
    basic_ptr(const basic_ptr &obj) : gc_ptr(obj) {
    }     
    
    /** the destructor.
     */
    ~basic_ptr() {
    }   
    
    /** the assignment operator.
        @param obj source object.
        @return reference to this.
     */  
    basic_ptr &operator = (const basic_ptr &obj) {
        gc_ptr::operator = (obj);
        return *this;
    }     
    
    /** pushes a root pointer to the garbage collector.
        @param ptr pointer to push to the collector.
     */
    static void collector_push_ptr(basic_ptr &ptr) {
        garbage_collector::get_garbage_collector().push_ptr(ptr);
    }
    
    /** pops a root pointer from the garbage collector.
     */
    static void collector_pop_ptr() {
        garbage_collector::get_garbage_collector().pop_ptr();
    }    
    
    /** pushes a weak root pointer to the garbage collector.
        @param ptr pointer to push to the collector.
     */
    static void collector_push_weak_ptr(basic_ptr &ptr) {
        garbage_collector::get_garbage_collector().push_weak_ptr(ptr);
    }
    
    /** pops a weak root pointer from the garbage collector.
     */
    static void collector_pop_weak_ptr() {
        garbage_collector::get_garbage_collector().pop_weak_ptr();
    }    
    
    /** adds a member pointer to the given object.
        @param obj object to add the pointer to.
        @param ptr pointer to add.
     */
    static void add_member_ptr(object *obj, basic_ptr &ptr) {
        object::add_member_ptr(obj, ptr);
    }
    
    /** adds a weak member pointer to the given object.
        @param obj object to add the pointer to.
        @param ptr pointer to add.
     */
    static void add_weak_member_ptr(object *obj, basic_ptr &ptr) {
        object::add_weak_member_ptr(obj, ptr);
    }
}; 


} //namespace libgc


#endif //LIBGC_BASICPTR_HPP