aboutsummaryrefslogtreecommitdiff
path: root/cutl/xml/serializer.hxx
blob: e3fef542a0acc8017f284b53f91a2aee7d0a4e9d (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
153
154
// file      : cutl/xml/serializer.hxx
// copyright : Copyright (c) 2009-2013 Code Synthesis Tools CC
// license   : MIT; see accompanying LICENSE file

#ifndef CUTL_XML_SERIALIZER_HXX
#define CUTL_XML_SERIALIZER_HXX

#include <string>
#include <ostream>
#include <cstddef> // std::size_t

#include <cutl/details/genx/genx.h>

#include <cutl/xml/qname.hxx>
#include <cutl/xml/exception.hxx>

#include <cutl/details/export.hxx>

namespace cutl
{
  namespace xml
  {
    struct LIBCUTL_EXPORT serialization: exception
    {
      virtual
      ~serialization () throw ();

      serialization (const std::string& name,
                     const std::string& description);

      const std::string&
      name () const {return name_;}

      const std::string&
      description () const {return description_;}

      virtual const char*
      what () const throw ();

    private:
      std::string name_;
      std::string description_;
      std::string what_;
    };

    class LIBCUTL_EXPORT serializer
    {
    public:
      ~serializer ();

      typedef xml::qname qname_type;

      // Serialize to std::ostream. Name is used in diagnostics to identify
      // the document being serialized. std::ios_base::failure exception is
      // used to report io errors (badbit and failbit). The indentation
      // argument specifies the number of indentation spaces that should
      // be used for pretty-printing. If 0 is passed, no pretty-printing
      // is performed.
      //
      serializer (std::ostream&,
                  const std::string& name,
                  unsigned short indentation = 2);

      // Serialization functions.
      //
    public:

      // Elements.
      //
      void
      start_element (const qname_type& qname);

      void
      start_element (const std::string& name);

      void
      start_element (const std::string& ns, const std::string& name);

      void
      end_element ();

      // Attributes.
      //
      void
      start_attribute (const qname_type& qname);

      void
      start_attribute (const std::string& name);

      void
      start_attribute (const std::string& ns, const std::string& name);

      void
      end_attribute ();

      void
      attribute (const qname_type& qname, const std::string& value);

      void
      attribute (const std::string& name, const std::string& value);

      void
      attribute (const std::string& ns,
                 const std::string& name,
                 const std::string& value);

      // Characters.
      //
      void
      characters (const std::string& value);

      // Namespaces declaration. If prefix is empty, then the default
      // namespace is declared. If both prefix and namespace are empty,
      // then the default namespace declaration is cleared (xmlns="").
      //
      void
      namespace_decl (const std::string& ns, const std::string& prefix);

      // XML Declaration. If encoding or standalone are not specified,
      // then these attributes are omitted from the output.
      //
      void
      xml_decl (const std::string& version = "1.0",
                const std::string& encoding = "UTF-8",
                const std::string& standalone = "");

      // Other functions.
      //
    public:
      // Return true if there is a mapping. In this case, prefix contains
      // the mapped prefix.
      //
      bool
      lookup_namespace_prefix (const std::string& ns, std::string& prefix);

    private:
      void
      handle_error (genxStatus);

    private:
      std::ostream& os_;
      std::ostream::iostate os_state_; // Original exception state.
      const std::string name_;

      genxWriter s_;
      genxSender sender_;
      std::size_t depth_;
    };
  }
}

#include <cutl/xml/serializer.ixx>

#endif // CUTL_XML_SERIALIZER_HXX