gc.hpp

// Copyright (C) Calum Grant 2008

namespace dynamic
{
        namespace internal
        {
                DYNAMIC_API void * apartment_malloc(std::size_t bytes);

                DYNAMIC_API void apartment_free(void *p);

                DYNAMIC_API void apartment_defrag();
        }

        namespace gc
        {
                class gc_object;


                class garbage_collector
                {
                public:
                        virtual ~garbage_collector();

                        virtual gc_object * chain()=0;

                        virtual void mark_reachable(gc_object*)=0;

                        virtual void collect()=0;

                        virtual int object_count()=0;

                        virtual void on_add_object()=0;

                        virtual void try_idle_gc()=0;


                        virtual void disable()=0;

                        virtual void enable()=0;

                        virtual void set_min_objects(int)=0;


                        virtual void set_idle_gc_factor(int)=0;


                        virtual void set_gc_factor(int)=0;
                };



                DYNAMIC_API garbage_collector & global_gc();


                garbage_collector * create_gc();


                class DYNAMIC_API gc_object
                {
                        gc_object * next, *prev;

                        unsigned root_ref_count : 31;

                        bool marked : 1;
                        
                public:         

                        void link();

                        void link_to(gc_object*);

                        void unlink();

                        gc_object * next_gc_object() const 
                        { 
                                return next; 
                        }

                public:
                        void * operator new(std::size_t s) 
                        { 
                                return internal::apartment_malloc(s); 
                        }

                        void operator delete(void * p) 
                        { 
                                return internal::apartment_free(p); 
                        }

                        gc_object(const gc_object&) : root_ref_count(0)
                        {
                                link();
                        }

                        gc_object & operator=(const gc_object&)
                        {
                                return *this;
                        }

                        gc_object(int) : root_ref_count(1)
                        {
                                next = prev = this;
                        }

                        gc_object() : root_ref_count(0)
                        {
                                link();
                        }


                        virtual ~gc_object() 
                        { 
                                unlink(); 
                        }

                        virtual void finalize() { }
                        
                        virtual void mark() { marked = true; }

                        virtual void mark_children(garbage_collector &) =0;

                        bool is_marked() const 
                        { 
                                return marked; 
                        }

                        virtual void init_mark() 
                        { 
                                marked = root_ref_count!=0; 
                        }

                        void add_root_ref() 
                        { 
                                ++root_ref_count; 
                        }

                        void release_root_ref() { --root_ref_count; }
                };



                template<typename T>
                class root_ref
                {
                        T * object;
                public:
                        typedef T value_type;

                        root_ref(T * t) : object(t)
                        {
                                object->add_root_ref();
                        }

                        root_ref(const root_ref & other) : object(other.object)
                        {
                                object->add_root_ref();
                        }

                        ~root_ref()
                        {
                                object->release_root_ref();
                        }

                        root_ref & operator=(root_ref other)
                        {
                                swap(other);
                                return *this;
                        }

                        T * operator->() const 
                        { 
                                return object; 
                        }
                        
                        T & operator*() const 
                        { 
                                return *object; 
                        }
                        
                        T * get() const 
                        { 
                                return object; 
                        }

                        void swap(root_ref & other)
                        {
                                std::swap(object, other.object);
                        }
                };
        }
}

---