aboutsummaryrefslogtreecommitdiff
path: root/libxsd/xsd/cxx/tree/types.txx
diff options
context:
space:
mode:
Diffstat (limited to 'libxsd/xsd/cxx/tree/types.txx')
-rw-r--r--libxsd/xsd/cxx/tree/types.txx610
1 files changed, 610 insertions, 0 deletions
diff --git a/libxsd/xsd/cxx/tree/types.txx b/libxsd/xsd/cxx/tree/types.txx
new file mode 100644
index 0000000..799c5fa
--- /dev/null
+++ b/libxsd/xsd/cxx/tree/types.txx
@@ -0,0 +1,610 @@
+// file : xsd/cxx/tree/types.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 <xercesc/util/Base64.hpp>
+#include <xercesc/util/XMLString.hpp>
+#include <xercesc/util/XercesVersion.hpp>
+
+#include <xsd/cxx/auto-array.hxx>
+
+#include <xsd/cxx/xml/std-memory-manager.hxx>
+
+namespace xsd
+{
+ namespace cxx
+ {
+ namespace tree
+ {
+
+ // string
+ //
+ template <typename C, typename B>
+ string<C, B>* string<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new string (*this, f, c);
+ }
+
+
+ // normalized_string
+ //
+ template <typename C, typename B>
+ normalized_string<C, B>* normalized_string<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new normalized_string (*this, f, c);
+ }
+
+
+ // token
+ //
+ template <typename C, typename B>
+ token<C, B>* token<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new token (*this, f, c);
+ }
+
+
+ // nmtoken
+ //
+ template <typename C, typename B>
+ nmtoken<C, B>* nmtoken<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new nmtoken (*this, f, c);
+ }
+
+
+ // nmtokens
+ //
+ template <typename C, typename B, typename nmtoken>
+ nmtokens<C, B, nmtoken>* nmtokens<C, B, nmtoken>::
+ _clone (flags f, container* c) const
+ {
+ return new nmtokens (*this, f, c);
+ }
+
+
+ // name
+ //
+ template <typename C, typename B>
+ name<C, B>* name<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new name (*this, f, c);
+ }
+
+
+ // ncname
+ //
+ template <typename C, typename B>
+ ncname<C, B>* ncname<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new ncname (*this, f, c);
+ }
+
+
+ // language
+ //
+ template <typename C, typename B>
+ language<C, B>* language<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new language (*this, f, c);
+ }
+
+
+ // identity_impl
+ //
+ template <typename C, typename ncname>
+ bool identity_impl<C, ncname>::
+ before (const identity& y) const
+ {
+ return id_ < static_cast<const identity_impl&> (y).id_;
+ }
+
+ template <typename C, typename ncname>
+ void identity_impl<C, ncname>::
+ throw_duplicate_id () const
+ {
+ throw duplicate_id<C> (id_);
+ }
+
+
+ // id
+ //
+ template <typename C, typename B>
+ id<C, B>* id<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new id (*this, f, c);
+ }
+
+ template <typename C, typename B>
+ id<C, B>& id<C, B>::
+ operator= (C c)
+ {
+ unregister_id ();
+ base () = c;
+ register_id ();
+
+ return *this;
+ }
+
+ template <typename C, typename B>
+ id<C, B>& id<C, B>::
+ operator= (const C* s)
+ {
+ unregister_id ();
+ base () = s;
+ register_id ();
+
+ return *this;
+ }
+
+ template <typename C, typename B>
+ id<C, B>& id<C, B>::
+ operator= (const std::basic_string<C>& s)
+ {
+ unregister_id ();
+ base () = s;
+ register_id ();
+
+ return *this;
+ }
+
+ template <typename C, typename B>
+ id<C, B>& id<C, B>::
+ operator= (const id& x)
+ {
+ unregister_id ();
+ base () = x;
+ register_id ();
+
+ return *this;
+ }
+
+ // It would have been cleaner to mention empty and _container
+ // with the using-declaration but HP aCC3 can't handle it in
+ // some non-trivial to track down cases. So we are going to use
+ // the old-n-ugly this-> techniques.
+ //
+ template <typename C, typename B>
+ void id<C, B>::
+ _container (container* c)
+ {
+ B::_container (c);
+ register_id ();
+ }
+
+ template <typename C, typename B>
+ void id<C, B>::
+ register_id ()
+ {
+ container* c (this->_container ());
+
+ if (c != 0 && !this->empty ())
+ {
+ //std::cerr << "registering " << c
+ // << " as '" << *this
+ // << "' on " << c << std::endl;
+
+ c->_register_id (identity_, c);
+ }
+ }
+
+ template <typename C, typename B>
+ void id<C, B>::
+ unregister_id ()
+ {
+ container* c (this->_container ());
+
+ if (c != 0 && !this->empty ())
+ {
+ //std::cerr << "un-registering " << c
+ // << " as '" << *this
+ // << "' on " << c << std::endl;
+
+ c->_unregister_id (identity_);
+ }
+ }
+
+
+ // idref
+ //
+ template <typename T, typename C, typename B>
+ idref<T, C, B>* idref<T, C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new idref (*this, f, c);
+ }
+
+ // It would have been cleaner to mention empty, _root, etc. with
+ // the using-declaration but HP aCC3 can't handle it in some
+ // non-trivial to track down cases. So we are going to use the
+ // old-n-ugly this-> techniques.
+ //
+ template <typename T, typename C, typename B>
+ const _type* idref<T, C, B>::
+ get_ () const
+ {
+ if (!this->empty () && this->_container () != 0)
+ {
+ return this->_root ()->_lookup_id (identity_);
+ }
+ else
+ return 0;
+ }
+
+ template <typename T, typename C, typename B>
+ _type* idref<T, C, B>::
+ get_ ()
+ {
+ if (!this->empty () && this->_container () != 0)
+ {
+ return this->_root ()->_lookup_id (identity_);
+ }
+ else
+ return 0;
+ }
+
+ template <typename T, typename C, typename B>
+ void idref<T, C, B>::
+ true_ ()
+ {
+ }
+
+
+ // idrefs
+ //
+ template <typename C, typename B, typename idref>
+ idrefs<C, B, idref>* idrefs<C, B, idref>::
+ _clone (flags f, container* c) const
+ {
+ return new idrefs (*this, f, c);
+ }
+
+
+ // uri
+ //
+ template <typename C, typename B>
+ uri<C, B>* uri<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new uri (*this, f, c);
+ }
+
+
+ // qname
+ //
+ template <typename C, typename B, typename uri, typename ncname>
+ qname<C, B, uri, ncname>* qname<C, B, uri, ncname>::
+ _clone (flags f, container* c) const
+ {
+ return new qname (*this, f, c);
+ }
+
+
+ // base64_binary
+ //
+ template <typename C, typename B>
+ base64_binary<C, B>::
+ base64_binary (size_t size)
+ : buffer<C> (size)
+ {
+ }
+
+ template <typename C, typename B>
+ base64_binary<C, B>::
+ base64_binary (size_t size, size_t capacity)
+ : buffer<C> (size, capacity)
+ {
+ }
+
+ template <typename C, typename B>
+ base64_binary<C, B>::
+ base64_binary (const void* data, size_t size)
+ : buffer<C> (data, size)
+ {
+ }
+
+ template <typename C, typename B>
+ base64_binary<C, B>::
+ base64_binary (const void* data, size_t size, size_t capacity)
+ : buffer<C> (data, size, capacity)
+ {
+ }
+
+ template <typename C, typename B>
+ base64_binary<C, B>::
+ base64_binary (void* data, size_t size, size_t capacity, bool own)
+ : buffer<C> (data, size, capacity, own)
+ {
+ }
+
+ template <typename C, typename B>
+ base64_binary<C, B>* base64_binary<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new base64_binary (*this, f, c);
+ }
+
+ // It would have been cleaner to mention size, and data with the
+ // using-declaration but HP aCC3 can't handle it in some non-
+ // trivial to track down cases. So we are going to use the
+ // old-n- ugly this-> techniques.
+ //
+ template <typename C, typename B>
+ std::basic_string<C> base64_binary<C, B>::
+ encode () const
+ {
+ // HP aCC3 cannot handle using namespace xercesc;
+ //
+ using xercesc::Base64;
+ std::basic_string<C> str;
+
+#if _XERCES_VERSION >= 30000
+ XMLSize_t n;
+
+ xml::std_memory_manager mm;
+ auto_array<XMLByte, xml::std_memory_manager> r (
+ Base64::encode (
+ reinterpret_cast<const XMLByte*> (this->data ()),
+ static_cast<XMLSize_t> (this->size ()),
+ &n,
+ &mm),
+ mm);
+
+ if (r)
+ {
+ str.reserve (n + 1);
+ str.resize (n);
+
+ for (XMLSize_t i (0); i < n; ++i)
+ str[i] = C (r[i]);
+ }
+ else
+ {
+ //@@ throw
+ }
+#else
+ unsigned int n;
+
+ xml::std_memory_manager mm;
+ auto_array<XMLByte, xml::std_memory_manager> r (
+ Base64::encode (
+ reinterpret_cast<const XMLByte*> (this->data ()),
+ static_cast<unsigned int> (this->size ()),
+ &n,
+ &mm),
+ mm);
+
+ if (r)
+ {
+ str.reserve (n + 1);
+ str.resize (n);
+
+ for (unsigned int i (0); i < n; ++i)
+ str[i] = C (r[i]);
+ }
+ else
+ {
+ //@@ throw
+ }
+#endif
+
+ return str;
+ }
+
+ template <typename C, typename B>
+ void base64_binary<C, B>::
+ decode (const XMLCh* src)
+ {
+ // HP aCC3 cannot handle using namespace xercesc;
+ //
+ using xercesc::Base64;
+
+ xml::std_memory_manager mm;
+
+ // Xerces 2.6.0 and earlier do not have decodeToXMLByte which
+ // makes my life harder and your code slower.
+ //
+#if _XERCES_VERSION >= 20700
+
+#if _XERCES_VERSION >= 30000
+ XMLSize_t size;
+ auto_array<XMLByte, xml::std_memory_manager> data (
+ Base64::decodeToXMLByte (src, &size, &mm, Base64::Conf_RFC2045),
+ mm);
+#else
+ unsigned int size;
+ auto_array<XMLByte, xml::std_memory_manager> data (
+ Base64::decodeToXMLByte (src, &size, &mm, Base64::Conf_RFC2045),
+ mm);
+#endif // _XERCES_VERSION >= 30000
+
+ if (data)
+ {
+ buffer<C> tmp (data.get (), size, size, true);
+ data.release ();
+ this->swap (tmp); // g++ 4.1 likes it qualified, not sure why.
+ }
+ else
+ {
+ //@@ throw
+ }
+#else
+ unsigned int size;
+
+#if _XERCES_VERSION >= 20600 // Xerces 2.5.0 does not have Conf_RFC2045.
+ auto_array<XMLCh, xml::std_memory_manager> data (
+ Base64::decode (src, &size, &mm, Base64::Conf_RFC2045),
+ mm);
+#else
+ auto_array<XMLCh, xml::std_memory_manager> data (
+ Base64::decode (src, &size, &mm), mm);
+#endif // _XERCES_VERSION >= 20600
+
+ if (data)
+ {
+ buffer<C> tmp (size);
+ for (unsigned int i (0); i < size; ++i)
+ tmp.data ()[i] = static_cast<char> (data[i]);
+ this->swap (tmp); // g++ 4.1 likes it qualified, not sure why.
+ }
+ else
+ {
+ //@@ throw
+ }
+#endif //_XERCES_VERSION >= 20700
+ }
+
+
+ // hex_binary
+ //
+ template <typename C, typename B>
+ hex_binary<C, B>::
+ hex_binary (size_t size)
+ : buffer<C> (size)
+ {
+ }
+
+ template <typename C, typename B>
+ hex_binary<C, B>::
+ hex_binary (size_t size, size_t capacity)
+ : buffer<C> (size, capacity)
+ {
+ }
+
+ template <typename C, typename B>
+ hex_binary<C, B>::
+ hex_binary (const void* data, size_t size)
+ : buffer<C> (data, size)
+ {
+ }
+
+ template <typename C, typename B>
+ hex_binary<C, B>::
+ hex_binary (const void* data, size_t size, size_t capacity)
+ : buffer<C> (data, size, capacity)
+ {
+ }
+
+ template <typename C, typename B>
+ hex_binary<C, B>::
+ hex_binary (void* data, size_t size, size_t capacity, bool own)
+ : buffer<C> (data, size, capacity, own)
+ {
+ }
+
+ template <typename C, typename B>
+ hex_binary<C, B>* hex_binary<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new hex_binary (*this, f, c);
+ }
+
+ // It would have been cleaner to mention size, and data with the
+ // using-declaration but HP aCC3 can't handle it in some non-
+ // trivial to track down cases. So we are going to use the
+ // old-n-ugly this-> techniques.
+ //
+ template <typename C, typename B>
+ std::basic_string<C> hex_binary<C, B>::
+ encode () const
+ {
+ std::basic_string<C> str;
+
+ const char tab[] = "0123456789ABCDEF";
+
+ if (size_t n = this->size ())
+ {
+ str.reserve (2 * n + 1);
+ str.resize (2 * n);
+
+ for (size_t i (0); i < n; ++i)
+ {
+ unsigned char byte (
+ static_cast<unsigned char> (*(this->data () + i)));
+ unsigned char h (byte >> 4);
+ unsigned char l (byte & 0x0F);
+
+ str[2 * i] = C (tab[h]);
+ str[2 * i + 1] = C (tab[l]);
+ }
+ }
+
+ return str;
+ }
+
+ namespace bits
+ {
+ inline unsigned char
+ hex_decode (XMLCh c)
+ {
+ unsigned char r (0xFF);
+
+ if (c >= '0' && c <= '9')
+ r = static_cast<unsigned char> (c - '0');
+ else if (c >= 'A' && c <= 'F')
+ r = static_cast<unsigned char> (10 + (c - 'A'));
+ else if (c >= 'a' && c <= 'f')
+ r = static_cast<unsigned char> (10 + (c - 'a'));
+
+ return r;
+ }
+ }
+
+ template <typename C, typename B>
+ void hex_binary<C, B>::
+ decode (const XMLCh* src)
+ {
+ size_t src_n (xercesc::XMLString::stringLen (src));
+
+ if (src_n % 2 != 0)
+ return; // @@ throw
+
+ size_t n (src_n / 2);
+
+ buffer<C> tmp (n);
+
+ for (size_t i (0); i < n; ++i)
+ {
+ unsigned char h (bits::hex_decode (src[2 * i]));
+ unsigned char l (bits::hex_decode (src[2 * i + 1]));
+
+ if (h == 0xFF || l == 0xFF)
+ return; //@@ throw
+
+ tmp.data()[i] = (h << 4) | l;
+ }
+
+ this->swap (tmp); // g++ 4.1 likes it qualified, not sure why.
+ }
+
+
+ // entity
+ //
+ template <typename C, typename B>
+ entity<C, B>* entity<C, B>::
+ _clone (flags f, container* c) const
+ {
+ return new entity (*this, f, c);
+ }
+
+
+ // entities
+ //
+ template <typename C, typename B, typename entity>
+ entities<C, B, entity>* entities<C, B, entity>::
+ _clone (flags f, container* c) const
+ {
+ return new entities (*this, f, c);
+ }
+ }
+ }
+}