diff options
author | Boris Kolpackov <boris@codesynthesis.com> | 2009-09-17 07:15:29 +0200 |
---|---|---|
committer | Boris Kolpackov <boris@codesynthesis.com> | 2009-09-17 07:15:29 +0200 |
commit | f0510d2f90467de8e8f260b47d79a9baaf9bef17 (patch) | |
tree | 0b9929946f06a9cbe9b9e8f2a7600dae4e048f79 /libxsd/xsd/cxx/tree/comparison-map.txx |
Start tracking XSD with git
Diffstat (limited to 'libxsd/xsd/cxx/tree/comparison-map.txx')
-rw-r--r-- | libxsd/xsd/cxx/tree/comparison-map.txx | 287 |
1 files changed, 287 insertions, 0 deletions
diff --git a/libxsd/xsd/cxx/tree/comparison-map.txx b/libxsd/xsd/cxx/tree/comparison-map.txx new file mode 100644 index 0000000..38f215f --- /dev/null +++ b/libxsd/xsd/cxx/tree/comparison-map.txx @@ -0,0 +1,287 @@ +// file : xsd/cxx/tree/comparison-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> + +namespace xsd +{ + namespace cxx + { + namespace tree + { + // comparison_map + // + template <typename C> + comparison_map<C>:: + comparison_map () + { + // anyType and anySimpleType. + // + + //register_type ( + // typeid (type), + // &comparator_impl<type>, + // false); + + typedef simple_type<type> simple_type; + + //register_type ( + // typeid (simple_type), + // &comparator_impl<simple_type>, + // false); + + + // Strings + // + typedef string<C, simple_type> string; + register_type ( + typeid (string), + &comparator_impl<string>, + false); + + typedef normalized_string<C, string> normalized_string; + register_type ( + typeid (normalized_string), + &comparator_impl<normalized_string>, + false); + + typedef token<C, normalized_string> token; + register_type ( + typeid (token), + &comparator_impl<token>, + false); + + typedef name<C, token> name; + register_type ( + typeid (name), + &comparator_impl<name>, + false); + + typedef nmtoken<C, token> nmtoken; + register_type ( + typeid (nmtoken), + &comparator_impl<nmtoken>, + false); + + typedef nmtokens<C, simple_type, nmtoken> nmtokens; + register_type ( + typeid (nmtokens), + &comparator_impl<nmtokens>, + false); + + typedef ncname<C, name> ncname; + register_type ( + typeid (ncname), + &comparator_impl<ncname>, + false); + + typedef language<C, token> language; + register_type ( + typeid (language), + &comparator_impl<language>, + false); + + + // ID/IDREF. + // + typedef id<C, ncname> id; + register_type ( + typeid (id), + &comparator_impl<id>, + false); + + typedef idref<type, C, ncname> idref; + register_type ( + typeid (idref), + &comparator_impl<idref>, + false); + + typedef idrefs<C, simple_type, idref> idrefs; + register_type ( + typeid (idrefs), + &comparator_impl<idrefs>, + false); + + + // URI. + // + typedef uri<C, simple_type> uri; + register_type ( + typeid (uri), + &comparator_impl<uri>, + false); + + + // Qualified name. + // + typedef qname<C, simple_type, uri, ncname> qname; + register_type ( + typeid (qname), + &comparator_impl<qname>, + false); + + + // Binary. + // + typedef base64_binary<C, simple_type> base64_binary; + register_type ( + typeid (base64_binary), + &comparator_impl<base64_binary>, + false); + + typedef hex_binary<C, simple_type> hex_binary; + register_type ( + typeid (hex_binary), + &comparator_impl<hex_binary>, + false); + + + // Date/time. + // + typedef gday<C, simple_type> gday; + register_type ( + typeid (gday), + &comparator_impl<gday>, + false); + + typedef gmonth<C, simple_type> gmonth; + register_type ( + typeid (gmonth), + &comparator_impl<gmonth>, + false); + + typedef gyear<C, simple_type> gyear; + register_type ( + typeid (gyear), + &comparator_impl<gyear>, + false); + + typedef gmonth_day<C, simple_type> gmonth_day; + register_type ( + typeid (gmonth_day), + &comparator_impl<gmonth_day>, + false); + + typedef gyear_month<C, simple_type> gyear_month; + register_type ( + typeid (gyear_month), + &comparator_impl<gyear_month>, + false); + + typedef date<C, simple_type> date; + register_type ( + typeid (date), + &comparator_impl<date>, + false); + + typedef time<C, simple_type> time; + register_type ( + typeid (time), + &comparator_impl<time>, + false); + + typedef date_time<C, simple_type> date_time; + register_type ( + typeid (date_time), + &comparator_impl<date_time>, + false); + + typedef duration<C, simple_type> duration; + register_type ( + typeid (duration), + &comparator_impl<duration>, + false); + + + // Entity. + // + typedef entity<C, ncname> entity; + register_type ( + typeid (entity), + &comparator_impl<entity>, + false); + + typedef entities<C, simple_type, entity> entities; + register_type ( + typeid (entities), + &comparator_impl<entities>, + false); + } + + template <typename C> + void comparison_map<C>:: + register_type (const type_id& tid, comparator c, bool override) + { + if (override || type_map_.find (&tid) == type_map_.end ()) + type_map_[&tid] = c; + } + + template <typename C> + bool comparison_map<C>:: + compare (const type& x, const type& y) + { + const type_id& xi (typeid (x)); + + if (xi != typeid (y)) + return false; + + if (comparator c = find (xi)) + return c (x, y); + else + throw no_type_info<C> (std::basic_string<C> (), + std::basic_string<C> ()); // @@ TODO + } + + template <typename C> + typename comparison_map<C>::comparator + comparison_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; + } + + + // comparison_plate + // + template<unsigned long id, typename C> + comparison_plate<id, C>:: + comparison_plate () + { + if (count == 0) + map = new comparison_map<C>; + + ++count; + } + + template<unsigned long id, typename C> + comparison_plate<id, C>:: + ~comparison_plate () + { + if (--count == 0) + delete map; + } + + // + // + template<typename T> + bool + comparator_impl (const type& x, const type& y) + { + return static_cast<const T&> (x) == static_cast<const T&> (y); + } + + // comparison_initializer + // + template<unsigned long id, typename C, typename T> + comparison_initializer<id, C, T>:: + comparison_initializer () + { + comparison_map_instance<id, C> ().register_type ( + typeid (T), &comparator_impl<T>); + } + } + } +} |