exceptions.hxx

Go to the documentation of this file.

// file      : xsd/cxx/tree/exceptions.hxx
// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
#ifndef XSD_CXX_TREE_EXCEPTIONS_HXX
#define XSD_CXX_TREE_EXCEPTIONS_HXX
 
#include <string>
#include <vector>
#include <ostream>
 
#include <xsd/cxx/exceptions.hxx> // xsd::cxx::exception
 
namespace xsd
{
  namespace cxx
  {
    namespace tree
    {
      template <typename C>
      class exception: public xsd::cxx::exception
      {
      public:
        friend
        std::basic_ostream<C>&
        operator<< (std::basic_ostream<C>& os, const exception& e)
        {
          e.print (os);
          return os;
        }
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const = 0;
 
        //@endcond
      };
 
 
      class severity
      {
      public:
        enum value
        {
          warning,
 
          error
        };
 
        severity (value v) : v_ (v) {}
 
        operator value () const { return v_; }
 
      private:
        value v_;
      };
 
      template <typename C>
      class error
      {
      public:
        error (tree::severity s,
               const std::basic_string<C>& res_id,
               unsigned long line,
               unsigned long column,
               const std::basic_string<C>& message);
 
        tree::severity
        severity () const
        {
          return severity_;
        }
 
        const std::basic_string<C>&
        id () const
        {
          return id_;
        }
 
        unsigned long
        line () const
        {
          return line_;
        }
 
        unsigned long
        column () const
        {
          return column_;
        }
 
        const std::basic_string<C>&
        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<C> id_;
        unsigned long line_;
        unsigned long column_;
        std::basic_string<C> message_;
      };
 
      // See exceptions.ixx for operator<< (error).
 
 
      template <typename C>
      class diagnostics: public std::vector<error<C> >
      {
      };
 
      // See exceptions.ixx for operator<< (diagnostics).
 
      template <typename C>
      class parsing: public exception<C>
      {
      public:
        virtual
        ~parsing () throw ();
 
        parsing ();
 
        parsing (const tree::diagnostics<C>& d);
 
      public:
        const tree::diagnostics<C>&
        diagnostics () const
        {
          return diagnostics_;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        tree::diagnostics<C> diagnostics_;
      };
 
 
      template <typename C>
      class expected_element: public exception<C>
      {
      public:
        virtual
        ~expected_element () throw ();
 
        expected_element (const std::basic_string<C>& name,
                          const std::basic_string<C>& ns);
 
 
      public:
        const std::basic_string<C>&
        name () const
        {
          return name_;
        }
 
        const std::basic_string<C>&
        namespace_ () const
        {
          return namespace__;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        std::basic_string<C> name_;
        std::basic_string<C> namespace__;
      };
 
 
      template <typename C>
      class unexpected_element: public exception<C>
      {
      public:
        virtual
        ~unexpected_element () throw ();
 
        unexpected_element (const std::basic_string<C>& encountered_name,
                            const std::basic_string<C>& encountered_ns,
                            const std::basic_string<C>& expected_name,
                            const std::basic_string<C>& expected_ns);
 
      public:
        const std::basic_string<C>&
        encountered_name () const
        {
          return encountered_name_;
        }
 
        const std::basic_string<C>&
        encountered_namespace () const
        {
          return encountered_namespace_;
        }
 
        const std::basic_string<C>&
        expected_name () const
        {
          return expected_name_;
        }
 
        const std::basic_string<C>&
        expected_namespace () const
        {
          return expected_namespace_;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        std::basic_string<C> encountered_name_;
        std::basic_string<C> encountered_namespace_;
        std::basic_string<C> expected_name_;
        std::basic_string<C> expected_namespace_;
      };
 
 
      template <typename C>
      class expected_attribute: public exception<C>
      {
      public:
        virtual
        ~expected_attribute () throw ();
 
        expected_attribute (const std::basic_string<C>& name,
                            const std::basic_string<C>& ns);
 
      public:
        const std::basic_string<C>&
        name () const
        {
          return name_;
        }
 
        const std::basic_string<C>&
        namespace_ () const
        {
          return namespace__;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        std::basic_string<C> name_;
        std::basic_string<C> namespace__;
      };
 
 
      template <typename C>
      class unexpected_enumerator: public exception<C>
      {
      public:
        virtual
        ~unexpected_enumerator () throw ();
 
        unexpected_enumerator (const std::basic_string<C>& e);
 
      public:
        const std::basic_string<C>&
        enumerator () const
        {
          return enumerator_;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        std::basic_string<C> enumerator_;
      };
 
 
      template <typename C>
      class expected_text_content: public exception<C>
      {
      public:
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
      };
 
 
      template <typename C>
      class no_type_info: public exception<C>
      {
      public:
        virtual
        ~no_type_info () throw ();
 
        no_type_info (const std::basic_string<C>& type_name,
                      const std::basic_string<C>& type_ns);
 
      public:
        const std::basic_string<C>&
        type_name () const
        {
          return type_name_;
        }
 
        const std::basic_string<C>&
        type_namespace () const
        {
          return type_namespace_;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        std::basic_string<C> type_name_;
        std::basic_string<C> type_namespace_;
      };
 
      template <typename C>
      class no_element_info: public exception<C>
      {
      public:
        virtual
        ~no_element_info () throw ();
 
        no_element_info (const std::basic_string<C>& element_name,
                         const std::basic_string<C>& element_ns);
 
      public:
        const std::basic_string<C>&
        element_name () const
        {
          return element_name_;
        }
 
        const std::basic_string<C>&
        element_namespace () const
        {
          return element_namespace_;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        std::basic_string<C> element_name_;
        std::basic_string<C> element_namespace_;
      };
 
      template <typename C>
      class not_derived: public exception<C>
      {
      public:
        virtual
        ~not_derived () throw ();
 
        //@cond
 
        // @@ tmp
        //
        not_derived ()
        {
        }
 
        //@endcond
 
        not_derived (const std::basic_string<C>& base_type_name,
                     const std::basic_string<C>& base_type_ns,
                     const std::basic_string<C>& derived_type_name,
                     const std::basic_string<C>& derived_type_ns);
 
      public:
        const std::basic_string<C>&
        base_type_name () const
        {
          return base_type_name_;
        }
 
        const std::basic_string<C>&
        base_type_namespace () const
        {
          return base_type_namespace_;
        }
 
        const std::basic_string<C>&
        derived_type_name () const
        {
          return derived_type_name_;
        }
 
        const std::basic_string<C>&
        derived_type_namespace () const
        {
          return derived_type_namespace_;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        std::basic_string<C> base_type_name_;
        std::basic_string<C> base_type_namespace_;
        std::basic_string<C> derived_type_name_;
        std::basic_string<C> derived_type_namespace_;
      };
 
 
      template <typename C>
      class duplicate_id: public exception<C>
      {
      public:
        virtual
        ~duplicate_id () throw ();
 
        duplicate_id (const std::basic_string<C>& id);
 
      public:
        const std::basic_string<C>&
        id () const
        {
          return id_;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        std::basic_string<C> id_;
      };
 
 
      template <typename C>
      class serialization: public exception<C>
      {
      public:
        virtual
        ~serialization () throw ();
 
        serialization ();
 
        serialization (const tree::diagnostics<C>& d);
 
      public:
        const tree::diagnostics<C>&
        diagnostics () const
        {
          return diagnostics_;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        tree::diagnostics<C> diagnostics_;
      };
 
 
      template <typename C>
      class no_prefix_mapping: public exception<C>
      {
      public:
        virtual
        ~no_prefix_mapping () throw ();
 
        no_prefix_mapping (const std::basic_string<C>& prefix);
 
      public:
        const std::basic_string<C>&
        prefix () const
        {
          return prefix_;
        }
 
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
 
      private:
        std::basic_string<C> prefix_;
      };
 
 
      template <typename C>
      class bounds: public exception<C>
      {
      public:
        virtual const char*
        what () const throw ();
 
      protected:
        //@cond
 
        virtual void
        print (std::basic_ostream<C>&) const;
 
        //@endcond
      };
    }
  }
}
 
#include <xsd/cxx/tree/exceptions.txx>
 
#endif  // XSD_CXX_TREE_EXCEPTIONS_HXX