From 2615896faa646e5830abf2c269150e1165c66515 Mon Sep 17 00:00:00 2001 From: Karen Arutyunov Date: Fri, 18 Dec 2020 18:48:46 +0300 Subject: Switch to build2 --- libxsd/libxsd/cxx/tree/exceptions.hxx | 1032 +++++++++++++++++++++++++++++++++ 1 file changed, 1032 insertions(+) create mode 100644 libxsd/libxsd/cxx/tree/exceptions.hxx (limited to 'libxsd/libxsd/cxx/tree/exceptions.hxx') diff --git a/libxsd/libxsd/cxx/tree/exceptions.hxx b/libxsd/libxsd/cxx/tree/exceptions.hxx new file mode 100644 index 0000000..6e8bedd --- /dev/null +++ b/libxsd/libxsd/cxx/tree/exceptions.hxx @@ -0,0 +1,1032 @@ +// file : libxsd/cxx/tree/exceptions.hxx +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +/** + * @file + * + * @brief Contains exception definitions for the C++/Tree mapping. + * + * This is an internal header and is included by the generated code. + * You normally should not include it directly. + * + */ + +#ifndef LIBXSD_CXX_TREE_EXCEPTIONS_HXX +#define LIBXSD_CXX_TREE_EXCEPTIONS_HXX + +#include +#include +#include + +#include // xsd::cxx::exception + +namespace xsd +{ + namespace cxx + { + /** + * @brief C++/Tree mapping runtime namespace. + * + * This is an internal namespace and normally should not be referenced + * directly. Instead you should use the aliases for types in this + * namespaces that are created in the generated code. + * + */ + namespace tree + { + /** + * @brief Root of the C++/Tree %exception hierarchy. + * + * You can catch this %exception in order to handle all C++/Tree + * errors. + * + * @nosubgrouping + */ + template + class exception: public xsd::cxx::exception + { + public: + /** + * @brief Stream insertion operator for %exception. + */ + friend + std::basic_ostream& + operator<< (std::basic_ostream& os, const exception& e) + { + e.print (os); + return os; + } + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const = 0; + + //@endcond + }; + + + /** + * @brief Error %severity. + * + * @nosubgrouping + */ + class severity + { + public: + /** + * @brief Underlying enum type. + */ + enum value + { + /** + * @brief Indicates the warning condition. + */ + warning, + + /** + * @brief Indicates the %error condition. + */ + error + }; + + /** + * @brief Initialize an instance with the underlying enum value. + * + * @param v An underlying enum value. + */ + severity (value v) : v_ (v) {} + + /** + * @brief Implicitly convert the instance to the underlying enum + * value. + * + * @return The underlying enum value. + */ + operator value () const { return v_; } + + private: + value v_; + }; + + /** + * @brief Error condition. + * + * @nosubgrouping + */ + template + class error + { + public: + /** + * @brief Initialize an instance with %error description. + * + * @param s An %error %severity. + * @param res_id A resource %id where the %error occurred. + * @param line A line number where the %error occurred. + * @param column A column number where the %error occurred. + * @param message A message describing the %error. + */ + error (tree::severity s, + const std::basic_string& res_id, + unsigned long line, + unsigned long column, + const std::basic_string& message); + + /** + * @brief Get %error %severity. + * + * @return The %severity of this %error. + */ + tree::severity + severity () const + { + return severity_; + } + + /** + * @brief Get resource %id. + * + * @return The %id of the resource where this %error occurred. + */ + const std::basic_string& + id () const + { + return id_; + } + + /** + * @brief Get %error line. + * + * @return The line number where this %error occurred. + */ + unsigned long + line () const + { + return line_; + } + + /** + * @brief Get %error column. + * + * @return The column number where this %error occurred. + */ + unsigned long + column () const + { + return column_; + } + + /** + * @brief Get %error message. + * + * @return The message for this %error. + */ + const std::basic_string& + message () const + { + return message_; + } + + //@cond + + // Default c-tor that shouldn't be. Needed when we completely + // instantiate std::vector in diagnostics below. + // + error (); + + //@endcond + + + private: + tree::severity severity_; + std::basic_string id_; + unsigned long line_; + unsigned long column_; + std::basic_string message_; + }; + + // See exceptions.ixx for operator<< (error). + + + /** + * @brief List of %error conditions. + * + * @nosubgrouping + */ + template + class diagnostics: public std::vector > + { + }; + + // See exceptions.ixx for operator<< (diagnostics). + + /** + * @brief Exception indicating a %parsing failure. + * + * @nosubgrouping + */ + template + class parsing: public exception + { + public: + virtual + ~parsing () throw (); + + /** + * @brief Default constructor. + */ + parsing (); + + /** + * @brief Initialize an instance with a %list of %error conditions. + * + * @param d A %list of %error conditions. + */ + parsing (const tree::diagnostics& d); + + public: + /** + * @brief Get the %list of %error conditions. + * + * @return The %list of %error conditions. + */ + const tree::diagnostics& + diagnostics () const + { + return diagnostics_; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + tree::diagnostics diagnostics_; + }; + + + /** + * @brief Exception indicating that an expected element was not + * encountered. + * + * @nosubgrouping + */ + template + class expected_element: public exception + { + public: + virtual + ~expected_element () throw (); + + /** + * @brief Initialize an instance with the expected element + * description. + * + * @param name A name of the expected element. + * @param ns A namespace of the expected element. + */ + expected_element (const std::basic_string& name, + const std::basic_string& ns); + + + public: + /** + * @brief Get the name of the expected element. + * + * @return The name of the expected element. + */ + const std::basic_string& + name () const + { + return name_; + } + + /** + * @brief Get the namespace of the expected element. + * + * @return The namespace of the expected element. + */ + const std::basic_string& + namespace_ () const + { + return namespace__; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + std::basic_string name_; + std::basic_string namespace__; + }; + + + /** + * @brief Exception indicating that an unexpected element was + * encountered. + * + * @nosubgrouping + */ + template + class unexpected_element: public exception + { + public: + virtual + ~unexpected_element () throw (); + + /** + * @brief Initialize an instance with the encountered and expected + * element descriptions. + * + * @param encountered_name A name of the encountered element. + * @param encountered_ns A namespace of the encountered element. + * @param expected_name A name of the expected element. + * @param expected_ns A namespace of the expected element. + */ + unexpected_element (const std::basic_string& encountered_name, + const std::basic_string& encountered_ns, + const std::basic_string& expected_name, + const std::basic_string& expected_ns); + + public: + /** + * @brief Get the name of the encountered element. + * + * @return The name of the encountered element. + */ + const std::basic_string& + encountered_name () const + { + return encountered_name_; + } + + /** + * @brief Get the namespace of the encountered element. + * + * @return The namespace of the encountered element. + */ + const std::basic_string& + encountered_namespace () const + { + return encountered_namespace_; + } + + /** + * @brief Get the name of the expected element. + * + * @return The name of the expected element. + */ + const std::basic_string& + expected_name () const + { + return expected_name_; + } + + /** + * @brief Get the namespace of the expected element. + * + * @return The namespace of the expected element. + */ + const std::basic_string& + expected_namespace () const + { + return expected_namespace_; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + std::basic_string encountered_name_; + std::basic_string encountered_namespace_; + std::basic_string expected_name_; + std::basic_string expected_namespace_; + }; + + + /** + * @brief Exception indicating that an expected attribute was not + * encountered. + * + * @nosubgrouping + */ + template + class expected_attribute: public exception + { + public: + virtual + ~expected_attribute () throw (); + + /** + * @brief Initialize an instance with the expected attribute + * description. + * + * @param name A name of the expected attribute. + * @param ns A namespace of the expected attribute. + */ + expected_attribute (const std::basic_string& name, + const std::basic_string& ns); + + public: + /** + * @brief Get the name of the expected attribute. + * + * @return The name of the expected attribute. + */ + const std::basic_string& + name () const + { + return name_; + } + + /** + * @brief Get the namespace of the expected attribute. + * + * @return The namespace of the expected attribute. + */ + const std::basic_string& + namespace_ () const + { + return namespace__; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + std::basic_string name_; + std::basic_string namespace__; + }; + + + /** + * @brief Exception indicating that an unexpected enumerator was + * encountered. + * + * @nosubgrouping + */ + template + class unexpected_enumerator: public exception + { + public: + virtual + ~unexpected_enumerator () throw (); + + /** + * @brief Initialize an instance with the encountered enumerator. + * + * @param e A value of the encountered enumerator. + */ + unexpected_enumerator (const std::basic_string& e); + + public: + /** + * @brief Get the value of the encountered enumerator. + * + * @return The value of the encountered enumerator. + */ + const std::basic_string& + enumerator () const + { + return enumerator_; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + std::basic_string enumerator_; + }; + + + /** + * @brief Exception indicating that the text content was expected + * for an element. + * + * @nosubgrouping + */ + template + class expected_text_content: public exception + { + public: + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + }; + + + /** + * @brief Exception indicating that the type information is not + * available for a type. + * + * @nosubgrouping + */ + template + class no_type_info: public exception + { + public: + virtual + ~no_type_info () throw (); + + /** + * @brief Initialize an instance with the type description. + * + * @param type_name A name of the type. + * @param type_ns A namespace of the type. + */ + no_type_info (const std::basic_string& type_name, + const std::basic_string& type_ns); + + public: + /** + * @brief Get the type name. + * + * @return The type name. + */ + const std::basic_string& + type_name () const + { + return type_name_; + } + + /** + * @brief Get the type namespace. + * + * @return The type namespace. + */ + const std::basic_string& + type_namespace () const + { + return type_namespace_; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + std::basic_string type_name_; + std::basic_string type_namespace_; + }; + + /** + * @brief Exception indicating that %parsing or %serialization + * information is not available for an element. + * + * @nosubgrouping + */ + template + class no_element_info: public exception + { + public: + virtual + ~no_element_info () throw (); + + /** + * @brief Initialize an instance with the element description. + * + * @param element_name An element name. + * @param element_ns An element namespace. + */ + no_element_info (const std::basic_string& element_name, + const std::basic_string& element_ns); + + public: + /** + * @brief Get the element name. + * + * @return The element name. + */ + const std::basic_string& + element_name () const + { + return element_name_; + } + + /** + * @brief Get the element namespace. + * + * @return The element namespace. + */ + const std::basic_string& + element_namespace () const + { + return element_namespace_; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + std::basic_string element_name_; + std::basic_string element_namespace_; + }; + + /** + * @brief Exception indicating that the types are not related by + * inheritance. + * + * @nosubgrouping + */ + template + class not_derived: public exception + { + public: + virtual + ~not_derived () throw (); + + //@cond + + // @@ tmp + // + not_derived () + { + } + + //@endcond + + /** + * @brief Initialize an instance with the type descriptions. + * + * @param base_type_name A name of the base type. + * @param base_type_ns A namespace of the base type. + * @param derived_type_name A name of the derived type. + * @param derived_type_ns A namespace of the derived type. + */ + not_derived (const std::basic_string& base_type_name, + const std::basic_string& base_type_ns, + const std::basic_string& derived_type_name, + const std::basic_string& derived_type_ns); + + public: + /** + * @brief Get the base type name. + * + * @return The base type name. + */ + const std::basic_string& + base_type_name () const + { + return base_type_name_; + } + + /** + * @brief Get the base type namespace. + * + * @return The base type namespace. + */ + const std::basic_string& + base_type_namespace () const + { + return base_type_namespace_; + } + + /** + * @brief Get the derived type name. + * + * @return The derived type name. + */ + const std::basic_string& + derived_type_name () const + { + return derived_type_name_; + } + + /** + * @brief Get the derived type namespace. + * + * @return The derived type namespace. + */ + const std::basic_string& + derived_type_namespace () const + { + return derived_type_namespace_; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + std::basic_string base_type_name_; + std::basic_string base_type_namespace_; + std::basic_string derived_type_name_; + std::basic_string derived_type_namespace_; + }; + + + /** + * @brief Exception indicating that a duplicate ID value was + * encountered in the object model. + * + * @nosubgrouping + */ + template + class duplicate_id: public exception + { + public: + virtual + ~duplicate_id () throw (); + + /** + * @brief Initialize an instance with the offending ID value. + * + * @param id An offending ID value. + */ + duplicate_id (const std::basic_string& id); + + public: + /** + * @brief Get the offending ID value. + * + * @return The offending ID value. + */ + const std::basic_string& + id () const + { + return id_; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + std::basic_string id_; + }; + + + /** + * @brief Exception indicating a %serialization failure. + * + * @nosubgrouping + */ + template + class serialization: public exception + { + public: + virtual + ~serialization () throw (); + + /** + * @brief Default constructor. + */ + serialization (); + + /** + * @brief Initialize an instance with a %list of %error conditions. + * + * @param d A %list of %error conditions. + */ + serialization (const tree::diagnostics& d); + + public: + /** + * @brief Get the %list of %error conditions. + * + * @return The %list of %error conditions. + */ + const tree::diagnostics& + diagnostics () const + { + return diagnostics_; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + tree::diagnostics diagnostics_; + }; + + + /** + * @brief Exception indicating that a prefix-namespace mapping was + * not provided. + * + * @nosubgrouping + */ + template + class no_prefix_mapping: public exception + { + public: + virtual + ~no_prefix_mapping () throw (); + + /** + * @brief Initialize an instance with the prefix for which the + * prefix-namespace mapping was not provided. + * + * @param prefix A prefix. + */ + no_prefix_mapping (const std::basic_string& prefix); + + public: + /** + * @brief Get the prefix for which the prefix-namespace mapping was + * not provided. + * + * @return The prefix. + */ + const std::basic_string& + prefix () const + { + return prefix_; + } + + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + + private: + std::basic_string prefix_; + }; + + + /** + * @brief Exception indicating that the size argument exceeds + * the capacity argument. + * + * See the buffer class for details. + * + * @nosubgrouping + */ + template + class bounds: public exception + { + public: + /** + * @brief Get %exception description. + * + * @return A C %string describing the %exception. + */ + virtual const char* + what () const throw (); + + protected: + //@cond + + virtual void + print (std::basic_ostream&) const; + + //@endcond + }; + } + } +} + +#include + +#endif // LIBXSD_CXX_TREE_EXCEPTIONS_HXX -- cgit v1.1