diff options
Diffstat (limited to 'libxsd/xsd/cxx/tree/std-ostream-map.txx')
| -rw-r--r-- | libxsd/xsd/cxx/tree/std-ostream-map.txx | 279 |
1 files changed, 279 insertions, 0 deletions
diff --git a/libxsd/xsd/cxx/tree/std-ostream-map.txx b/libxsd/xsd/cxx/tree/std-ostream-map.txx new file mode 100644 index 0000000..c1187ef --- /dev/null +++ b/libxsd/xsd/cxx/tree/std-ostream-map.txx @@ -0,0 +1,279 @@ +// file : xsd/cxx/tree/std-ostream-map.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include <xsd/cxx/tree/types.hxx> +#include <xsd/cxx/tree/std-ostream-operators.hxx> + +namespace xsd +{ + namespace cxx + { + namespace tree + { + // std_ostream_map + // + template <typename C> + std_ostream_map<C>:: + std_ostream_map () + { + // anyType and anySimpleType. + // + register_type ( + typeid (type), + &inserter_impl<type>, + false); + + typedef simple_type<type> simple_type; + register_type ( + typeid (simple_type), + &inserter_impl<simple_type>, + false); + + + // Strings + // + typedef string<C, simple_type> string; + register_type ( + typeid (string), + &inserter_impl<string>, + false); + + typedef normalized_string<C, string> normalized_string; + register_type ( + typeid (normalized_string), + &inserter_impl<normalized_string>, + false); + + typedef token<C, normalized_string> token; + register_type ( + typeid (token), + &inserter_impl<token>, + false); + + typedef name<C, token> name; + register_type ( + typeid (name), + &inserter_impl<name>, + false); + + typedef nmtoken<C, token> nmtoken; + register_type ( + typeid (nmtoken), + &inserter_impl<nmtoken>, + false); + + typedef nmtokens<C, simple_type, nmtoken> nmtokens; + register_type ( + typeid (nmtokens), + &inserter_impl<nmtokens>, + false); + + typedef ncname<C, name> ncname; + register_type ( + typeid (ncname), + &inserter_impl<ncname>, + false); + + typedef language<C, token> language; + register_type ( + typeid (language), + &inserter_impl<language>, + false); + + + // ID/IDREF. + // + typedef id<C, ncname> id; + register_type ( + typeid (id), + &inserter_impl<id>, + false); + + typedef idref<type, C, ncname> idref; + register_type ( + typeid (idref), + &inserter_impl<idref>, + false); + + typedef idrefs<C, simple_type, idref> idrefs; + register_type ( + typeid (idrefs), + &inserter_impl<idrefs>, + false); + + + // URI. + // + typedef uri<C, simple_type> uri; + register_type ( + typeid (uri), + &inserter_impl<uri>, + false); + + + // Qualified name. + // + typedef qname<C, simple_type, uri, ncname> qname; + register_type ( + typeid (qname), + &inserter_impl<qname>, + false); + + + // Binary. + // + typedef base64_binary<C, simple_type> base64_binary; + register_type ( + typeid (base64_binary), + &inserter_impl<base64_binary>, + false); + + typedef hex_binary<C, simple_type> hex_binary; + register_type ( + typeid (hex_binary), + &inserter_impl<hex_binary>, + false); + + + // Date/time. + // + typedef gday<C, simple_type> gday; + register_type ( + typeid (gday), + &inserter_impl<gday>, + false); + + typedef gmonth<C, simple_type> gmonth; + register_type ( + typeid (gmonth), + &inserter_impl<gmonth>, + false); + + typedef gyear<C, simple_type> gyear; + register_type ( + typeid (gyear), + &inserter_impl<gyear>, + false); + + typedef gmonth_day<C, simple_type> gmonth_day; + register_type ( + typeid (gmonth_day), + &inserter_impl<gmonth_day>, + false); + + typedef gyear_month<C, simple_type> gyear_month; + register_type ( + typeid (gyear_month), + &inserter_impl<gyear_month>, + false); + + typedef date<C, simple_type> date; + register_type ( + typeid (date), + &inserter_impl<date>, + false); + + typedef time<C, simple_type> time; + register_type ( + typeid (time), + &inserter_impl<time>, + false); + + typedef date_time<C, simple_type> date_time; + register_type ( + typeid (date_time), + &inserter_impl<date_time>, + false); + + typedef duration<C, simple_type> duration; + register_type ( + typeid (duration), + &inserter_impl<duration>, + false); + + + // Entity. + // + typedef entity<C, ncname> entity; + register_type ( + typeid (entity), + &inserter_impl<entity>, + false); + + typedef entities<C, simple_type, entity> entities; + register_type ( + typeid (entities), + &inserter_impl<entities>, + false); + } + + template <typename C> + void std_ostream_map<C>:: + register_type (const type_id& tid, inserter i, bool override) + { + if (override || type_map_.find (&tid) == type_map_.end ()) + type_map_[&tid] = i; + } + + template <typename C> + void std_ostream_map<C>:: + insert (std::ostream& os, const type& x) + { + if (inserter i = find (typeid (x))) + i (os, x); + else + throw no_type_info<C> (std::basic_string<C> (), + std::basic_string<C> ()); // @@ TODO + } + + template <typename C> + typename std_ostream_map<C>::inserter std_ostream_map<C>:: + find (const type_id& tid) const + { + typename type_map::const_iterator i (type_map_.find (&tid)); + return i == type_map_.end () ? 0 : i->second; + } + + // std_ostream_plate + // + template<unsigned long id, typename C> + std_ostream_plate<id, C>:: + std_ostream_plate () + { + if (count == 0) + map = new std_ostream_map<C>; + + ++count; + } + + template<unsigned long id, typename C> + std_ostream_plate<id, C>:: + ~std_ostream_plate () + { + if (--count == 0) + delete map; + } + + // + // + template<typename T> + void + inserter_impl (std::ostream& os, const type& x) + { + os << static_cast<const T&> (x); + } + + // std_ostream_initializer + // + template<unsigned long id, typename C, typename T> + std_ostream_initializer<id, C, T>:: + std_ostream_initializer () + { + std_ostream_map_instance<id, C> ().register_type ( + typeid (T), &inserter_impl<T>); + } + } + } +} |