#ifndef IC__INDUSTRY__GARBAGE#define IC__INDUSTRY__GARBAGE#include <algorithm>#include <set>namespace industry{	namespace garbage	{		class collected_pool;		template < typename type_t > class collected_pointer;		class do_collect;		class do_destroy;		struct do_delete		{			template < typename value_t >			void operator()( value_t * pointer )			{				delete pointer;			}		};		class collected_object		{		private:			friend class collected_pool;			friend class do_collect;			template< class > friend class collected_pointer;			collected_pool & pool;		protected:			virtual void collect_children( void ) const {}		public:			collected_object( collected_pool & pool )				: pool( pool )			{			}			virtual ~collected_object( void )			{			}		};		template < typename type_t > class collected_pointer		{			type_t * pointer;		public:			collected_pointer( void )				: pointer( 0 )			{			}			collected_pointer( type_t * pointer )				: pointer( pointer )			{				if ( !pointer ) return;				pointer->pool.collect( pointer );			}			template < typename copy_t >			collected_pointer( const collected_pointer< copy_t > & c_pointer )				: pointer( static_cast< type_t * >( c_pointer.pointer ) ) //yehck!! :P			{				if ( !pointer ) return;				pointer->pool.collect( pointer );			}			collected_pointer< type_t > operator=( type_t * new_pointer )			{				pointer = new_pointer;				if ( !pointer ) return;				pointer->pool.collect( pointer );			}			template < typename copy_t >			collected_pointer< type_t > operator=( const collected_pointer< copy_t > & new_c_pointer )			{				pointer = new_c_pointer;				if ( !pointer ) return;				pointer->pool.collect( pointer );			}			type_t & operator* ( void ) const			{				return *pointer;			}			type_t * operator->( void ) const			{				return pointer;			}			type_t & get( void ) const			{				return pointer;			}		};		class collected_pool		{			std::set< collected_object * > roots;			std::set< collected_object * > allocated;			std::set< collected_object * > grey; //list to possibly free, for incremental GC		public:			void add_root( collected_object * object )			{				roots.insert( object );			}			template < typename type_t > type_t * create( void )			{				//WARNING: unless the return is made reachable from one of the roots,				//the returned value isn't reachable, and thus GC will attempt to clean it!!!				type_t * pointer = new type_t( *this );				allocated.insert( pointer );				return pointer;			}			void destroy( collected_object * pointer )			{				roots.erase( pointer ); //just in case				allocated.erase( pointer );				delete pointer;			}			void run_incremental_gc_loop( void );			void collect( collected_object * pointer )			{				grey.erase( pointer );				pointer->collect_children();			}			void collect( collected_object & object )			{				collect( &object );			}			~collected_pool( void )			{				std::for_each( allocated.begin() , allocated.end() , do_delete() );			}		};		class do_collect		{		public:			void operator()( collected_object * pointer )			{				pointer->pool.collect( pointer );			}		};		class do_destroy		{			collected_pool & pool;		public:			do_destroy( collected_pool & pool )				: pool( pool )			{			}			void operator()( collected_object * pointer )			{				pool.destroy( pointer );			}		};		void collected_pool::run_incremental_gc_loop( void )		{			//WARNING: should probably add a time-delay wait forced in here			//so that we don't end up doing two loops before a created object can be returned			//to be added to some reachable object's pointers.			grey = allocated;			//YET ANOTHER WARNING: I'm not sure if insertion can be run in parallel			//with setting one set to another - as long as all those not being			//inserted during this timeframe (and optionally any/all of those that are)			//we should be OK. (this is in relation to running GC in a seperate thread)			std::for_each( roots.begin() , roots.end() , do_collect() );			//greylist is now blacklist, delete at will:			std::for_each( grey.begin() , grey.end() , do_destroy( *this ) );		}	}}#endif //ndef IC__INDUSTRY__GARBAGE

#include <iostream>#include "garbage.hh"using namespace industry::garbage;using namespace std;struct my_object : public collected_object{	std::set< my_object * > children;	my_object( collected_pool & pool )		: collected_object( pool )	{	}protected:	virtual void collect_children( void ) const	{		for_each( children.begin() , children.end() , do_collect() );	}};int main ( int argc , char ** argv ){	collected_pool pool;	collected_pointer< my_object > ptr = pool.create< my_object >();	pool.run_incremental_gc_loop();	cout << "Ran to the end without crashing!!! Woohoo!!!" << endl;	string buffer;	getline( cin , buffer );}