aboutsummaryrefslogtreecommitdiff
path: root/libxsd/xsd/cxx/parser/validating/exceptions.hxx
blob: 07086e365c22153cbe8d89da65332086fbcc7627 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
// file      : xsd/cxx/parser/validating/exceptions.hxx
// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file

#ifndef XSD_CXX_PARSER_VALIDATING_EXCEPTIONS_HXX
#define XSD_CXX_PARSER_VALIDATING_EXCEPTIONS_HXX

#include <string>

#include <xsd/cxx/parser/schema-exceptions.hxx>
#include <xsd/cxx/ro-string.hxx>

namespace xsd
{
  namespace cxx
  {
    namespace parser
    {
      namespace validating
      {
        //
        //
        template <typename C>
        struct expected_attribute: schema_exception<C>
        {
          virtual
          ~expected_attribute ();

          expected_attribute (const std::basic_string<C>& expected_namespace,
                              const std::basic_string<C>& expected_name);

          const std::basic_string<C>&
          expected_namespace () const
          {
            return expected_namespace_;
          }

          const std::basic_string<C>&
          expected_name () const
          {
            return expected_name_;
          }

          virtual std::basic_string<C>
          message () const;

        private:
          std::basic_string<C> expected_namespace_;
          std::basic_string<C> expected_name_;
        };

        //
        //
        template <typename C>
        struct unexpected_attribute: schema_exception<C>
        {
          virtual
          ~unexpected_attribute ();

          unexpected_attribute (
            const std::basic_string<C>& encountered_namespace,
            const std::basic_string<C>& encountered_name);


          const std::basic_string<C>&
          encountered_namespace () const
          {
            return encountered_namespace_;
          }

          const std::basic_string<C>&
          encountered_name () const
          {
            return encountered_name_;
          }

          virtual std::basic_string<C>
          message () const;

        private:
          std::basic_string<C> encountered_namespace_;
          std::basic_string<C> encountered_name_;
        };


        //
        //
        template <typename C>
        struct unexpected_characters: schema_exception<C>
        {
          virtual
          ~unexpected_characters ();

          unexpected_characters (const std::basic_string<C>& s);

          const std::basic_string<C>&
          characters () const
          {
            return characters_;
          }

          virtual std::basic_string<C>
          message () const;

        private:
          std::basic_string<C> characters_;
        };

        //
        //
        template <typename C>
        struct invalid_value: schema_exception<C>
        {
          virtual
          ~invalid_value ();

          invalid_value (const C* type, const std::basic_string<C>& value);

          invalid_value (const C* type, const ro_string<C>& value);

          invalid_value (const std::basic_string<C>& type,
                         const std::basic_string<C>& value);

          const std::basic_string<C>&
          type () const
          {
            return type_;
          }

          const std::basic_string<C>&
          value () const
          {
            return value_;
          }

          virtual std::basic_string<C>
          message () const;

        private:
          std::basic_string<C> type_;
          std::basic_string<C> value_;
        };
      }
    }
  }
}

#include <xsd/cxx/parser/validating/exceptions.txx>

#endif  // XSD_CXX_PARSER_VALIDATING_EXCEPTIONS_HXX

#include <xsd/cxx/parser/validating/exceptions.ixx>