[Boost-commit] svn:boost r54370 - in sandbox/monotonic: boost/object_model boost/object_model/generic boost/object_model/type libs/object_model/test

Subject: [Boost-commit] svn:boost r54370 - in sandbox/monotonic: boost/object_model boost/object_model/generic boost/object_model/type libs/object_model/test
From: christian.schladetsch_at_[hidden]
Date: 2009-06-26 03:07:25

Author: cschladetsch
Date: 2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
New Revision: 54370
URL: http://svn.boost.org/trac/boost/changeset/54370

Log:
added system_traits<>

Added:
   sandbox/monotonic/boost/object_model/string_stream.hpp   (contents, props changed)
   sandbox/monotonic/boost/object_model/system_traits.hpp   (contents, props changed)
Text files modified: 
   sandbox/monotonic/boost/object_model/builder.hpp              |    16 +++--                                   
   sandbox/monotonic/boost/object_model/class.hpp                |    60 ++++++++++++++++---                     
   sandbox/monotonic/boost/object_model/dereference.hpp          |    17 -----                                   
   sandbox/monotonic/boost/object_model/dictionary.hpp           |    14 +++-                                    
   sandbox/monotonic/boost/object_model/forward_declarations.hpp |    28 +++++++--                               
   sandbox/monotonic/boost/object_model/generic/class.hpp        |    19 ++----                                  
   sandbox/monotonic/boost/object_model/generic/object.hpp       |    35 +++++++----                             
   sandbox/monotonic/boost/object_model/generic/registry.hpp     |     6 +                                       
   sandbox/monotonic/boost/object_model/generic/storage.hpp      |    19 ++++-                                   
   sandbox/monotonic/boost/object_model/label.hpp                |    41 +++++++++++--                           
   sandbox/monotonic/boost/object_model/object.hpp               |    16 ++++-                                   
   sandbox/monotonic/boost/object_model/registry.hpp             |   118 +++++++++++++++++++++++++++++++++------ 
   sandbox/monotonic/boost/object_model/storage.hpp              |    28 +++++----                               
   sandbox/monotonic/boost/object_model/string.hpp               |    24 +++++++                                 
   sandbox/monotonic/boost/object_model/type/specifier.hpp       |    21 ++++++-                                 
   sandbox/monotonic/libs/object_model/test/basic_tests.cpp      |    56 ++++++++++++++++--                      
   16 files changed, 388 insertions(+), 130 deletions(-)

Modified: sandbox/monotonic/boost/object_model/builder.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/builder.hpp	(original)
+++ sandbox/monotonic/boost/object_model/builder.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -14,16 +14,18 @@
 
 BOOST_OM_BEGIN
 
-template <class T, class Allocator>
+template <class T, class Reg>
 struct builder
 {
-	typedef type::traits<T> traits;
+	typedef Reg registry_type;
+	typedef typename Reg::traits_type system_traits;
+	typedef type::traits<T> type_traits;
 
 private:
-	klass<T, Allocator> *my_klass;
+	typename registry_type::rebind_klass<T>::type *my_klass;
 
 public:
-	builder(registry<Allocator> &reg)
+	builder(registry_type &reg)
         {
                 my_klass = reg.register_class<T>();
         }
@@ -47,10 +49,10 @@
         } methods;
 };
 
-template <class T, class Al>
-builder<T,Al> class_builder(registry<Al> &reg)
+template <class T, class Registry>
+builder<T,Registry> class_builder(Registry &reg)
 {
-	return builder<T,Al>(reg);
+	return builder<T,Registry>(reg);
 }
 
 BOOST_OM_END

Modified: sandbox/monotonic/boost/object_model/class.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/class.hpp	(original)
+++ sandbox/monotonic/boost/object_model/class.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -12,33 +12,71 @@
 #include <boost/object_model/detail/prefix.hpp>
 #include <boost/object_model/detail/allocator.hpp>
 #include <boost/object_model/generic/class.hpp>
+//#include <boost/object_model/system_traits.hpp>
 
 BOOST_OM_BEGIN
 
-template <class T, class Alloc>
-struct klass : generic::klass
+template <class Traits>
+struct klass_base : generic::klass
 {
-	typedef typename detail::rebind<Alloc,object_model::storage<T> >::type allocator_type;
+	typedef typename Traits::label_type Label;
+
+	typedef std::map<Label, generic::property const *> properties_type;
+	typedef std::map<Label, generic::method const *> methods_type;
+
+private:
+	const char *name;
+	type::number type_number;
+
+	properties_type properties;
+	methods_type methods;
+
+public:
+	klass_base(const char *ident, type::number num)
+		: generic::klass(num), name(ident)
+	{
+	}
+
+	bool has_method(Label const &name) const
+	{
+		return methods.find(name) != methods.end();
+	}
+
+	bool has_field(Label const &name) const
+	{
+		return properties.find(name) != properties.end();
+	}
+};
+
+	
+template <class T, class Registry>
+struct klass : klass_base<typename Registry::traits_type>
+{
+	typedef typename Registry::traits_type system_traits;
+	typedef klass_base<system_traits> klass_base_type;
+	typedef typename system_traits::label_type label_type;
+	typedef typename Registry::rebind_storage<T>::type storage_type;
+	typedef typename system_traits::rebind_allocator<storage_type>::type allocator_type;
         typedef type::traits<T> traits;
 
-	registry<Alloc> &reg;
+	Registry &reg;
         mutable allocator_type allocator;
 
-	klass(registry<Alloc> &factory)
-		: generic::klass(traits::name, traits::type_number), reg(factory), allocator(reg.get_allocator()) { }
+	klass(Registry &factory)
+		: klass_base_type(traits::name, traits::type_number), reg(factory), allocator(reg.get_allocator()) { }
 
-	generic::storage &create(handle h) const
+	generic::object &create(handle h) const
         {
-		storage<T> *store = allocator.allocate(1);
+		storage_type *store = allocator.allocate(1);
                 //allocator.construct(store);
-		new (store) storage<T>();
+		new (store) storage_type();
                 store->construct(reg, *this, h);
                 return *store;
         }
 
-	void destroy(generic::storage &obj) const
+	void destroy(generic::object &obj) const
         {
-		storage<T> *store = &static_cast<storage<T> &>(obj);
+		storage_type *store = &static_cast<storage_type &>(obj);
                 allocator.destroy(store);
                 allocator.deallocate(store, 1);
         }

Modified: sandbox/monotonic/boost/object_model/dereference.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/dereference.hpp	(original)
+++ sandbox/monotonic/boost/object_model/dereference.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -15,23 +15,6 @@
 
 BOOST_OM_BEGIN
 
-template <class T>
-typename type::traits<T>::reference_type deref(generic::object &object)
-{
-	if (!object.is_type<T>())
-		throw type_mismatch();
-	if (object.is_const())
-		throw const_error();
-	return static_cast<storage<T> &>(object.get_storage()).get_reference();
-}
-
-template <class T>
-typename type::traits<T>::const_reference_type const_deref(generic::object const &object)
-{
-	if (!object.is_type<T>())
-		throw type_mismatch();
-	return static_cast<const const_storage<T> &>(object.get_storage()).get_const_reference();
-}
 
 BOOST_OM_END
 

Modified: sandbox/monotonic/boost/object_model/dictionary.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/dictionary.hpp	(original)
+++ sandbox/monotonic/boost/object_model/dictionary.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -12,26 +12,34 @@
 #include <map>
 #include <boost/object_model/detail/prefix.hpp>
 #include <boost/object_model/label.hpp>
+#include <boost/object_model/generic/object.hpp>
 
 BOOST_OM_BEGIN
 
+template <class Tr>
 struct dictionary
 {
-	typedef std::map<label, generic::object> contents_type;
+	typedef typename Tr::label_type label_type;
+	typedef std::map<label_type, generic::object, std::less<label_type>, typename Tr::allocator_type> contents_type;
 
         contents_type contents;
 
-	void set(label const &name, generic::object const &obj)
+	void set(label_type const &name, generic::object const &obj)
         {
                 contents[name] = obj;
         }
-	generic::object get(label const &name) const
+
+	generic::object get(label_type const &name) const
         {
                 contents_type::const_iterator iter = contents.find(name);
                 if (iter == contents.end())
                         return null_object;
                 return iter->second;
         }
+	bool has(label_type const &name) const
+	{
+		return contents.find(name) != contents.end();
+	}
 };
 
 BOOST_OM_END

Modified: sandbox/monotonic/boost/object_model/forward_declarations.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/forward_declarations.hpp	(original)
+++ sandbox/monotonic/boost/object_model/forward_declarations.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -28,9 +28,11 @@
 struct handle;
 
 /// a name for an object
+template <class Text>
 struct label;
 
 /// a mapping of label to object
+template <class Label>
 struct dictionary;
 
 /// generic bases for type-specific derived types
@@ -47,9 +49,11 @@
         struct object;
 
         /// common for all const storage for an instance
+	template <class Traits>
         struct const_storage;
 
         /// common for all storage for an instance
+	template <class Traits>
         struct storage;
 
         /// common for types that have a `self` pointer
@@ -62,8 +66,10 @@
         struct property;
 
         /// common for all classes
+	//template <class Label>
         struct klass;
 
+	//template <class Label>
         struct registry;
 }
 
@@ -95,12 +101,22 @@
 struct reference;
 
 /// storage for a specific type
-template <class T>
+template <class T, class Traits>
 struct storage;
 
+/// const storage for a specific type
+template <class T, class Traits>
+struct const_storage;
+
 template <class T>
 struct reflected;
 
+template <class Al = default_allocator, class Ch = char, class Tr = std::char_traits<Ch> >
+struct string;
+
+template <class Str = string<> >
+struct label;
+
 /// a specific method of class type, with given signature
 template <class T, class Signature>
 struct method;
@@ -110,15 +126,15 @@
 struct property;
 
 /// class of a given type
-template <class T, class Al = default_allocator>
+template <class T, class Traits>
 struct klass;
 
-template <class T, class Al = default_allocator>
+template <class T, class Traits>
 struct builder;
 
-/// an object registry (factory)
-template <class Al = default_allocator >
-struct registry;
+///// an object registry (factory)
+//template <class Al, class Traits>
+//struct registry;
 
 /// a sequence of executable objects
 struct continuation;

Modified: sandbox/monotonic/boost/object_model/generic/class.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/generic/class.hpp	(original)
+++ sandbox/monotonic/boost/object_model/generic/class.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -20,28 +20,21 @@
 
 namespace generic
 {
+	//template <class Label>
         struct klass : base
         {
-		typedef std::map<label, property const *> properties_type;
-		typedef std::map<label, method const *> methods_type;
-
         private:
-		label name;
                 type::number type_number;
 
-		properties_type properties;
-		methods_type methods;
-
         public:
-		klass(const label&, type::number);
+		klass(type::number num)
+			: type_number(num) { }
 
                 type::number get_type_number() const { return type_number; }
+		
 
-		bool has_method(label const &) const;
-		bool has_field(label const &) const;
-
-		virtual storage &create(handle) const = 0;
-		virtual void destroy(storage &) const = 0;
+		virtual object &create(handle) const = 0;
+		virtual void destroy(object &) const = 0;
 
                 //virtual const_object get_property(const label&, const_object &owner) const = 0;
                 //virtual object get_property(const label&, object &owner) const = 0;

Modified: sandbox/monotonic/boost/object_model/generic/object.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/generic/object.hpp	(original)
+++ sandbox/monotonic/boost/object_model/generic/object.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -14,6 +14,7 @@
 #include <boost/object_model/handle.hpp>
 #include <boost/object_model/type/traits.hpp>
 #include <boost/object_model/generic/base.hpp>
+#include <boost/object_model/generic/registry.hpp>
 
 BOOST_OM_BEGIN
 
@@ -28,12 +29,11 @@
 
                 object_base();
                 object_base(const object_base&);
-		object_base(const const_storage&);
 
-		template <class T, class Al> friend struct object_model::klass;
+		template <class T, class Tr> friend struct object_model::klass;
 
                 void construct(registry &, klass const &, handle);
-		storage &get_storage();
+		object_base &get_storage();
 
         public:
                 klass const &get_class() const;
@@ -41,7 +41,7 @@
                 registry &get_registry() const;
                 handle get_handle() const;
 
-		const storage &get_storage() const;
+		const object_base &get_storage() const;
                 bool exists() const;
 
                 template <class T>
@@ -50,8 +50,17 @@
                         return get_type_number() == type::traits<T>::type_number;
                 }
 
-		void set(label const &name, object const &obj);
-		object get(label const &name) const;
+		//template <class Label>
+		//void set(Label const &name, object const &obj)
+		//{
+		//	set_fun(*this, name, obj);
+		//}
+
+		//template <class Label>
+		//object_base get(Label const &name) const
+		//{
+		//	return set_fun(*this, name);
+		//}
         };
 
         struct const_object : object_base
@@ -79,24 +88,26 @@
                 object(const const_object&);
                 object(const mutable_object&);
 //		object(const object&);
-		object(const storage &);
-		object(const const_storage &);
+//		object(const storage &);
+//		object(const const_storage &);
 
                 object &operator=(const const_object&);
                 object &operator=(const mutable_object&);
 //		object &operator=(const object&);
 
                 bool is_const() const { return konst; }
-		storage &get_storage();
+		object_base &get_storage();
+		const object_base &get_storage() const;
         };
 
         struct mutable_object : const_object
         {
-		mutable_object();
-		mutable_object(storage &);
+		mutable_object() { }
+		mutable_object(const mutable_object &obj) : const_object(obj) { }
+		//mutable_object(const object_base &obj) : const_object(obj) { }
                 mutable_object(const object &obj) : const_object(obj) { }
 
-		storage &get_storage();
+		object_base &get_storage();
         };
 
 }

Modified: sandbox/monotonic/boost/object_model/generic/registry.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/generic/registry.hpp	(original)
+++ sandbox/monotonic/boost/object_model/generic/registry.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -12,7 +12,7 @@
 #include <boost/object_model/detail/prefix.hpp>
 #include <boost/object_model/forward_declarations.hpp>
 #include <boost/object_model/handle.hpp>
-#include <boost/object_model/storage.hpp>
+//#include <boost/object_model/storage.hpp>
 
 BOOST_OM_BEGIN
 
@@ -22,8 +22,10 @@
         {
         public:
 
+		virtual klass const *get_class(type::number) const = 0;
                 virtual bool exists(handle) const = 0;
-		virtual storage &get_storage(handle) const = 0;
+
+		virtual object_base &get_storage(handle) const = 0;
 
         };
 }

Modified: sandbox/monotonic/boost/object_model/generic/storage.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/generic/storage.hpp	(original)
+++ sandbox/monotonic/boost/object_model/generic/storage.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -16,23 +16,32 @@
 
 namespace generic
 {
-	struct const_storage : const_object
+	template <class Traits>
+	struct const_storage : object
         {
+		typedef dictionary<Traits> dictionary_type;
+		typedef typename dictionary_type::label_type label_type;
+
         protected:
-		dictionary dict;
+		dictionary_type dict;
 
         public:
-		void set(label const &name, generic::object const &obj)
+		void set(label_type const &name, generic::object const &obj)
                 {
                         dict.set(name, obj);
                 }
-		generic::object get(label const &name) const
+		generic::object get(label_type const &name) const
                 {
                         return dict.get(name);
                 }
+		bool has(label_type const &name) const
+		{
+			return dict.has(name);
+		}
         };
 
-	struct storage : const_storage
+	template <class Traits>
+	struct storage : const_storage<Traits>
         {
 
         };

Modified: sandbox/monotonic/boost/object_model/label.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/label.hpp	(original)
+++ sandbox/monotonic/boost/object_model/label.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -11,21 +11,34 @@
 
 #include <string>
 #include <boost/object_model/detail/prefix.hpp>
+#include <boost/object_model/forward_declarations.hpp>
+#include <boost/object_model/string.hpp>
+#include <boost/object_model/string_stream.hpp>
 
 BOOST_OM_BEGIN
 
+template <class String>
 struct label
 {
-	typedef std::string string_type;
-	typedef string_type::value_type char_type;
+//	BOOST_STATIC_ASSERT((boost::is_same<String, string<> >::value));
+
+	typedef String string_type;
+	typedef typename String::allocator_type allocator_type;
+	typedef typename string_type::value_type char_type;
 
 private:
         string_type value;
 
 public:
         label() { }
-	label(const char_type *);
-	label(const string_type &);
+	label(const char_type *text)
+	{
+		from_string(text);
+	}
+	label(const string_type &text)
+	{
+		from_string(text);
+	}
 
         const string_type &to_string() const { return value; }
 
@@ -33,18 +46,30 @@
         friend bool operator<(label const &a, label const &b) { return a.value < b.value; }
 
 private:
-	void from_string(const string_type &);
-	void from_string(const char_type *);
+	void from_string(const string_type &text)
+	{
+		from_string(text.c_str());
+	}
+	void from_string(const char_type *text)
+	{
+		value = text;
+	}
 };
 
+template <class Al, class Ch, class Tr, class String>
+string_stream<Al,Ch,Tr> &operator<<(string_stream<Al,Ch,Tr> &stream, const label<String> &val)
+{
+	return stream << val.to_string();
+}
+
 BOOST_OM_END
 
 BOOST_BEGIN
 
 template <>
-struct hash<BOOST_OBJECT_MODEL_NAMESPACE(label)>
+struct hash<BOOST_OBJECT_MODEL_NAMESPACE(label<BOOST_OBJECT_MODEL_NAMESPACE(string<>) >)>
 {
-	size_t operator()(BOOST_OBJECT_MODEL_NAMESPACE(label) ident) const
+	size_t operator()(const BOOST_OBJECT_MODEL_NAMESPACE(label<BOOST_OBJECT_MODEL_NAMESPACE(string<>) >) &ident) const
         {
                 return 42;// TODO: hash on ident.to_string().c_str()
         }

Modified: sandbox/monotonic/boost/object_model/object.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/object.hpp	(original)
+++ sandbox/monotonic/boost/object_model/object.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -21,20 +21,28 @@
 {
         typedef type::traits<T> traits;
 
+	typedef typename traits::reference_type (*deref_fun)(generic::object &);
+	typedef typename traits::const_reference_type (*const_deref_fun)(const generic::object &);
+
+private:
+	deref_fun deref;
+	const_deref_fun const_deref;
+
+public:
         object() {}
 
-	object(const generic::object &obj) : generic::object(obj)
+	object(const generic::object &obj, deref_fun d, const_deref_fun c) : generic::object(obj), deref(d), const_deref(c)
         {
         }
 
-	typename traits::reference_type reference()
+	typename traits::reference_type get_reference()
         {
-		return deref<T>(*this);
+		return deref(*this);
         }
 
         typename traits::reference_type operator*()
         {
-		return reference();
+		return get_reference();
         }
 };
 

Modified: sandbox/monotonic/boost/object_model/registry.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/registry.hpp	(original)
+++ sandbox/monotonic/boost/object_model/registry.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -16,18 +16,90 @@
 #include <boost/object_model/detail/prefix.hpp>
 #include <boost/object_model/generic/registry.hpp>
 #include <boost/object_model/type/number.hpp>
+#include <boost/object_model/class.hpp>
+#include <boost/object_model/exceptions.hpp>
+#include <boost/object_model/system_traits.hpp>
+#include <boost/object_model/object.hpp>
 
 BOOST_OM_BEGIN
 
 /// an object type factory, and registery of instances
-template <class Allocator>
+template <class Tr = system_traits<char, default_allocator> >
+struct registry;
+
+/// an object type factory, and registery of instances
+template <class Tr>
 struct registry : generic::registry
 {
-	typedef Allocator allocator_type;
-	//typedef boost::unordered_map<handle, generic::storage *, hash<handle>, std::less<handle>, Allocator> instances_type;
-	//typedef boost::unordered_map<type::number, generic::klass const *, hash<type::number>, std::less<type::number>, Allocator> classes_type;
-	typedef std::map<handle, generic::storage *, std::less<handle>, allocator_type> instances_type;
-	typedef std::map<type::number, generic::klass const *, std::less<type::number>, allocator_type> classes_type;
+	typedef Tr traits, traits_type;
+	typedef typename traits::allocator_type allocator_type;
+	typedef typename traits::char_traits char_traits;
+	typedef typename traits::char_type char_type;
+	typedef typename traits::string_type string_type;
+	typedef typename traits::label_type label_type;
+
+	typedef registry<Tr> This, this_type;
+
+	template <class T>
+	struct rebind_klass
+	{
+		typedef klass<T, this_type> type;
+	};
+	template <class T>
+	struct rebind_storage
+	{
+		typedef storage<T, traits_type> type;
+	};
+
+	typedef std::map<
+		handle
+		, generic::storage<traits> *
+		, std::less<handle>
+		, allocator_type
+	> instances_type;
+
+	typedef std::map<
+		type::number
+		, klass_base<traits_type> const *
+		, std::less<type::number>
+		, allocator_type
+	> classes_type;
+
+	template <class T>
+	static typename type::traits<T>::reference_type deref(generic::object &object)
+	{
+		if (!object.is_type<T>())
+			throw type_mismatch();
+		if (object.is_const())
+			throw const_error();
+		return static_cast<typename rebind_storage<T>::type &>(object.get_storage()).get_reference();
+	}
+
+	template <class T>
+	static typename type::traits<T>::const_reference_type const_deref(generic::object const &object)
+	{
+		if (!object.is_type<T>())
+			throw type_mismatch();
+		throw;
+		//return static_cast<typename rebind_storage<T>::type const &>(object.get_storage()).get_const_reference();
+	}
+
+	void set(generic::object &parent, typename traits::label_type const &label, generic::object &child)
+	{
+		generic::storage<traits> &p = get_storage(parent.get_handle());
+		generic::storage<traits> &q = get_storage(child.get_handle());
+		p.set(label, q);
+	}
+	generic::object get(generic::object &parent, typename traits::label_type const &label)
+	{
+		generic::storage<traits> &p = get_storage(parent.get_handle());
+		return p.get(label);
+	}
+	bool has(generic::object &parent, typename traits::label_type const &label)
+	{
+		generic::storage<traits> &p = get_storage(parent.get_handle());
+		return p.has(label);
+	}
 
 protected:
         allocator_type allocator;
@@ -47,7 +119,7 @@
         {
                 BOOST_FOREACH(typename instances_type::value_type &val, instances)
                 {
-			generic::storage &obj = *val.second;
+			generic::object &obj = *val.second;
                         obj.get_class().destroy(obj);
                 }
                 instances.clear();
@@ -57,7 +129,7 @@
                 clear();
                 BOOST_FOREACH(typename classes_type::value_type &val, classes)
                 {
-			allocator_destroy(const_cast<generic::klass *>(val.second));
+			allocator_destroy(const_cast<klass_base<traits_type> *>(val.second));
                 }
                 classes.clear();
         }
@@ -73,7 +145,7 @@
                 instances.erase(val);
         }
 
-	generic::storage &get_storage(handle h) const
+	generic::storage<traits> &get_storage(handle h) const
         {
                 instances_type::const_iterator iter = instances.find(h);
                 if (iter == instances.end())
@@ -105,25 +177,33 @@
         }
 
         template <class T>
-	klass<T> *register_class()
+	typename rebind_klass<T>::type *register_class()
         {
                 BOOST_ASSERT(!has_class<T>());
-		klass<T> *new_class = allocator_create<klass<T> >(*this);
+		typedef typename rebind_klass<T>::type class_type;
+		class_type *new_class = allocator_create<class_type >(*this);
                 classes[new_class->get_type_number()] = new_class;
                 BOOST_ASSERT(classes.find(new_class->get_type_number()) != classes.end());
                 return new_class;
         }
 
+	generic::klass const *get_class(type::number number) const
+	{
+		classes_type::const_iterator iter = classes.find(number);
+		return iter == classes.end() ? 0 : iter->second;
+	}
+
         template <class T>
-	storage<T> &create()
+	object<T> create()
         {
-		klass<T> const *k = get_class<T>();
+		typename rebind_klass<T>::type const *k = get_class<T>();
                 if (k == 0)
                         throw unknown_type();
                 handle h = ++next_handle;
-		storage<T> &obj = static_cast<storage<T> &>(k->create(h));
+		typedef typename rebind_storage<T>::type storage_type;
+		storage_type &obj = static_cast<storage_type &>(k->create(h));
                 instances[h] = &obj;
-		return obj;
+		return object<T>(obj, &this_type::deref<T>, &this_type::const_deref<T>);
         }
 
         template <class T>
@@ -133,12 +213,12 @@
         }
         
         template <class T>
-	klass<T> const *get_class() const
+	typename rebind_klass<T>::type const *get_class() const
         {
                 classes_type::const_iterator iter = classes.find(type::traits<T>::type_number);
                 if (iter == classes.end())
                         return 0;
-		return static_cast<klass<T> const *>(iter->second);
+		return static_cast<typename rebind_klass<T>::type const *>(iter->second);
         }
 
 private:
@@ -155,14 +235,14 @@
         template <class T>
         void allocator_destroy(T *ptr)
         {
-		typename Allocator::template rebind<T>::other alloc(allocator);
+		typename allocator_type::template rebind<T>::other alloc(allocator);
                 alloc.destroy(ptr);
                 alloc.deallocate(ptr,1);
         }
         template <class T, class U>
         T *allocator_create(U &init)
         {
-		typename Allocator::template rebind<T>::other alloc(allocator);
+		typename allocator_type::template rebind<T>::other alloc(allocator);
                 T *ptr = alloc.allocate(1);
                 //alloc.construct(ptr, init);
                 new (ptr) T(init);

Modified: sandbox/monotonic/boost/object_model/storage.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/storage.hpp	(original)
+++ sandbox/monotonic/boost/object_model/storage.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -14,35 +14,37 @@
 
 BOOST_OM_BEGIN
 
-template <class T>
-struct const_storage : generic::const_storage
+template <class T, class Traits>
+struct const_storage : generic::const_storage<Traits>
 {
-	typedef type::traits<T> traits;
-	const typename traits::storage_type value;
+	typedef Traits system_traits;
+	typedef type::traits<T> type_traits;
+	typename type_traits::storage_type value;
 
         const_storage() {} 
-	const_storage(typename traits::const_reference_type init) : value(init) { }
-	typename traits::const_reference_type get_const_reference()
+	const_storage(typename type_traits::const_reference_type init) : value(init) { }
+	typename type_traits::const_reference_type get_const_reference()
         {
                 return value;
         }
 };
 
-template <class T>
-struct storage : generic::storage
+template <class T, class Traits>
+struct storage : generic::storage<Traits>
 {
-	typedef type::traits<T> traits;
-	typename traits::storage_type value;
+	typedef Traits system_traits;
+	typedef type::traits<T> type_traits;
+	typename type_traits::storage_type value;
         mutable bool dirty;
 
         storage() : dirty(true) {} 
-	storage(typename traits::const_reference_type init) : value(init), dirty(false) { }
+	storage(typename type_traits::const_reference_type init) : value(init), dirty(false) { }
 
-	typename traits::const_reference_type get_const_reference()
+	typename type_traits::const_reference_type get_const_reference()
         {
                 return value;
         }
-	typename traits::reference_type get_reference()
+	typename type_traits::reference_type get_reference()
         {
                 dirty = true;
                 return value;

Modified: sandbox/monotonic/boost/object_model/string.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/string.hpp	(original)
+++ sandbox/monotonic/boost/object_model/string.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -9,23 +9,45 @@
 #ifndef BOOST_OBJECT_MODEL_STRING_HPP
 #define BOOST_OBJECT_MODEL_STRING_HPP
 
+#include <string>
 #include <boost/object_model/detail/prefix.hpp>
 
 BOOST_OM_BEGIN
 
-template <class Alloc = default_allocator, class Ch = char, class Tr = std::char_traits<Ch> >
+template <class Alloc, class Ch, class Tr>
 struct string
 {
         typedef std::basic_string<Ch, Tr, Alloc> implementation;
         typedef typename implementation::value_type value_type;
         typedef typename implementation::iterator iterator;
         typedef typename implementation::const_iterator const_iterator;
+	typedef Alloc allocator_type;
 
 private:
         implementation impl;
 
 public:
 
+	string() { }
+	string(const value_type *text) : impl(text) { }
+	string &operator=(const value_type *text)
+	{
+		impl = text;
+		return *this;
+	}
+	const value_type *c_str() const
+	{
+		return impl.c_str();
+	}
+
+	friend bool operator==(string const &a, string const &b)
+	{
+		return a.impl == b.impl;
+	}
+	friend bool operator<(string const &a, string const &b)
+	{
+		return a.impl < b.impl;
+	}
 };
 
 BOOST_OM_END

Added: sandbox/monotonic/boost/object_model/string_stream.hpp
==============================================================================
--- (empty file)
+++ sandbox/monotonic/boost/object_model/string_stream.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -0,0 +1,45 @@
+// (C) 2009 Christian Schladetsch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// documentation at https://svn.boost.org/svn/boost/sandbox/monotonic/libs/object_model/doc/index.html
+// sandbox at https://svn.boost.org/svn/boost/sandbox/monotonic/object_model/
+
+#ifndef BOOST_OBJECT_MODEL_STRING_STREAM_HPP
+#define BOOST_OBJECT_MODEL_STRING_STREAM_HPP
+
+#include <boost/object_model/detail/prefix.hpp>
+#include <boost/object_model/string.hpp>
+
+BOOST_OM_BEGIN
+
+template <class Alloc = default_allocator, class Ch = char, class Tr = std::char_traits<Ch> >
+struct string_stream
+{
+	typedef string<Alloc,Ch,Tr> string_type;
+	typedef std::basic_stringstream<Ch, Tr, Alloc> string_stream_type;
+
+private:
+	string_stream_type stream;
+
+public:
+	string_type str() const
+	{
+		return stream.str();
+	}
+};
+
+template <class Al, class Ch, class Tr, class Ty>
+string_stream<Al,Ch,Tr> &operator<<(string_stream<Al,Ch,Tr> &stream, const Ty &val)
+{
+	return stream << val;
+}
+
+BOOST_OM_END
+
+#include <boost/object_model/detail/postfix.hpp>
+
+#endif // BOOST_OBJECT_MODEL_STRING_STREAM_HPP
+
+//EOF

Added: sandbox/monotonic/boost/object_model/system_traits.hpp
==============================================================================
--- (empty file)
+++ sandbox/monotonic/boost/object_model/system_traits.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -0,0 +1,46 @@
+// (C) 2009 Christian Schladetsch
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// documentation at https://svn.boost.org/svn/boost/sandbox/monotonic/libs/object_model/doc/index.html
+// sandbox at https://svn.boost.org/svn/boost/sandbox/monotonic/object_model/
+
+#ifndef BOOST_OBJECT_MODEL_SYSTEM_TRAITS_HPP
+#define BOOST_OBJECT_MODEL_SYSTEM_TRAITS_HPP
+
+#include <boost/object_model/detail/prefix.hpp>
+#include <boost/object_model/string.hpp>
+#include <boost/object_model/label.hpp>
+
+BOOST_OM_BEGIN
+
+template <class Ch = char, class Al = std::allocator<Ch> >
+struct system_traits
+{
+	typedef Ch char_type;
+	typedef std::char_traits<char_type> char_traits;
+	typedef Al allocator_type;
+	typedef string<allocator_type, char_type, char_traits> string_type;
+	typedef label<string_type> label_type;
+	typedef system_traits<Ch,Al> this_type;
+
+	template <class T>
+	struct rebind_class
+	{
+		typedef klass<T, this_type> type;
+	};
+	template <class T>
+	struct rebind_allocator
+	{
+		typedef typename allocator_type::template rebind<T>::other type;
+	};
+};
+
+BOOST_OM_END
+
+#include <boost/object_model/detail/postfix.hpp>
+
+#endif // BOOST_OBJECT_MODEL_SYSTEM_TRAITS_HPP
+
+//EOF

Modified: sandbox/monotonic/boost/object_model/type/specifier.hpp
==============================================================================
--- sandbox/monotonic/boost/object_model/type/specifier.hpp	(original)
+++ sandbox/monotonic/boost/object_model/type/specifier.hpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -11,6 +11,8 @@
 
 #include <boost/object_model/detail/prefix.hpp>
 #include <boost/object_model/string.hpp>
+#include <boost/object_model/string_stream.hpp>
+#include <boost/object_model/type/number.hpp>
 #include <boost/object_model/type/modifiers.hpp>
 
 BOOST_OM_BEGIN
@@ -25,8 +27,21 @@
 
                 number get_number() const { return type_number; }
 
-		//template <class Alloc, template <class Al = Alloc, class Ch = char, class Tr = std::char_traits<Ch> > String = string>
-		//bool to_string(const registry<Alloc> &, string<Alloc> ) const;
+		template <class Alloc>
+		string<Alloc> to_string(const registry<Alloc> &reg) const
+		{
+			string_stream<Alloc> stream;
+			generic::klass const *k = reg.get_class(type_number);
+			if (k  == 0)
+				stream << "[type_number: " << type_number.value << "]";
+			else
+				stream << k->get_name();
+			if (is_const())
+				stream << " const";
+			if (is_reference())
+				stream << " &";
+			return stream.str();
+		}
         };
 
         template <class T>
@@ -44,7 +59,7 @@
                 modifiers mods;
                 mods.set_const(is_const<T>::value);	// what is wrong with boost::is_const<T> ??
                 mods.set_reference(boost::is_reference<T>::value);
-		return specifier(traits<typename base_type<T>::Type>::type_number, mods);
+		return specifier();//(traits<typename base_type<T>::Type>::type_number, mods);
         };
 
 } // namespace type

Modified: sandbox/monotonic/libs/object_model/test/basic_tests.cpp
==============================================================================
--- sandbox/monotonic/libs/object_model/test/basic_tests.cpp	(original)
+++ sandbox/monotonic/libs/object_model/test/basic_tests.cpp	2009-06-26 03:07:23 EDT (Fri, 26 Jun 2009)
@@ -14,6 +14,7 @@
 
 #include <string>
 #include <boost/object_model/object.hpp>
+#include <boost/object_model/dictionary.hpp>
 #include <boost/object_model/registry.hpp>
 #include <boost/object_model/type/builtins.hpp>
 #include <boost/object_model/builder.hpp>
@@ -21,6 +22,7 @@
 #include <boost/object_model/dereference.hpp>
 #include <boost/object_model/type/specifier.hpp>
 #include <boost/object_model/string.hpp>
+#include <boost/object_model/registry.hpp>
 
 using namespace std;
 using namespace boost;
@@ -32,7 +34,8 @@
         reg.register_class<void>();
         reg.register_class<int>();
 
-	//om::string<> text = type::make_specifier<int>().to_string(reg);
+	om::string<> text;//
+	//text = om::type::make_specifier<int>().to_string(reg);
 }
 
 BOOST_AUTO_TEST_CASE(test_type_traits)
@@ -76,7 +79,48 @@
         
         *num = 42;
         
-	BOOST_ASSERT(om::deref<int>(num) == 42);
+	BOOST_ASSERT((reg.deref<int>(num) == 42));
+}
+
+struct custom_traits
+{
+	typedef char char_type;
+	typedef std::char_traits<char_type> char_traits;
+	typedef std::allocator<char> allocator_type;
+	typedef om::string<allocator_type, char_type, char_traits> string_type;
+	typedef int label_type;
+	typedef custom_traits this_type;
+
+	template <class T>
+	struct rebind_class
+	{
+		typedef om::klass<T, this_type> type;
+	};
+	template <class T>
+	struct rebind_allocator
+	{
+		typedef typename allocator_type::template rebind<T>::other type;
+	};
+};
+
+BOOST_AUTO_TEST_CASE(test_int_labels)
+{
+	om::registry<custom_traits> r;
+	r.register_class<void>();
+	om::object<void> parent = r.create<void>();
+	om::object<void> child = r.create<void>();
+	r.set(parent, 42, child);
+	BOOST_ASSERT(r.has(parent, 42));
+}
+
+BOOST_AUTO_TEST_CASE(test_string_labels)
+{
+	om::registry<> r;
+	r.register_class<void>();
+	om::object<void> parent = reg.create<void>();
+	om::object<void> child = reg.create<void>();
+	r.set(parent, "child", child);
+	BOOST_ASSERT(r.has(parent, "child"));
 }
 
 struct Foo
@@ -110,10 +154,10 @@
         BOOST_ASSERT(foo.exists());
         BOOST_ASSERT(foo.is_type<Foo>());
 
-	BOOST_ASSERT(foo.get_class().has_method("bar"));
-	BOOST_ASSERT(foo.get_class().has_method("spam"));
-	BOOST_ASSERT(foo.get_class().has_field("num"));
-	BOOST_ASSERT(foo.get_class().has_field("str"));
+	//BOOST_ASSERT(foo.get_class().has_method("bar"));
+	//BOOST_ASSERT(foo.get_class().has_method("spam"));
+	//BOOST_ASSERT(foo.get_class().has_field("num"));
+	//BOOST_ASSERT(foo.get_class().has_field("str"));
 }
 
 //EOF