/src/CMake/Source/cmXMLWriter.h

Source
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#pragma once

#include "cmConfigure.h" // IWYU pragma: keep

#include <chrono>
#include <cstddef> // IWYU pragma: keep
#include <ctime>
#include <ostream>
#include <stack>
#include <string>
#include <vector>

#include "cmXMLSafe.h"

class cmXMLWriter
{
public:
  cmXMLWriter(std::ostream& output, std::size_t level = 0);
  ~cmXMLWriter();

  cmXMLWriter(cmXMLWriter const&) = delete;
  cmXMLWriter& operator=(cmXMLWriter const&) = delete;

  void StartDocument(char const* encoding = "UTF-8");
  void EndDocument();

  void StartElement(std::string const& name);
  void EndElement();

  void BreakAttributes();

  template <typename T>
  void Attribute(char const* name, T const& value)
  {
    this->PreAttribute();
    this->Output << name << "=\"" << SafeAttribute(value) << '"';
  }

  void Element(char const* name);

  template <typename T>
  void Element(std::string const& name, T const& value)
  {
    this->StartElement(name);
    this->Content(value);
    this->EndElement();
  }

  template <typename T>
  void Content(T const& content)
  {
    this->PreContent();
    this->Output << SafeContent(content);
  }

  void Comment(char const* comment);

  void CData(std::string const& data);

  void Doctype(char const* doctype);

  void ProcessingInstruction(char const* target, char const* data);

  void FragmentFile(char const* fname);

  void SetIndentationElement(std::string const& element);

private:
  void ConditionalLineBreak(bool condition);

  void PreAttribute();
  void PreContent();

  void CloseStartElement();

  static cmXMLSafe SafeAttribute(char const* value) { return { value }; }

  static cmXMLSafe SafeAttribute(std::string const& value)
  {
    return { value };
  }

  template <typename T>
  static T SafeAttribute(T value)
  {
    return value;
  }

  static cmXMLSafe SafeContent(char const* value)
  {
    return cmXMLSafe(value).Quotes(false);
  }

  static cmXMLSafe SafeContent(std::string const& value)
  {
    return cmXMLSafe(value).Quotes(false);
  }

  /*
   * Convert a std::chrono::system::time_point to the number of seconds since
   * the UN*X epoch.
   *
   * It would be tempting to convert a time_point to number of seconds by
   * using time_since_epoch(). Unfortunately the C++11 standard does not
   * specify what the epoch of the system_clock must be.
   * Therefore we must assume it is an arbitrary point in time. Instead of this
   * method, it is recommended to convert it by means of the to_time_t method.
   */
  static std::time_t SafeContent(std::chrono::system_clock::time_point value)
  {
    return std::chrono::system_clock::to_time_t(value);
  }

  template <typename T>
  static T SafeContent(T value)
  {
    return value;
  }

  std::ostream& Output;
  std::stack<std::string, std::vector<std::string>> Elements;
  std::string IndentationElement;
  std::size_t Level;
  std::size_t Indent = 0;
  bool ElementOpen = false;
  bool BreakAttrib = false;
  bool IsContent = false;
};

class cmXMLElement; // IWYU pragma: keep

class cmXMLDocument
{
public:
  cmXMLDocument(cmXMLWriter& xml)
    : xmlwr(xml)
  {
    this->xmlwr.StartDocument();
  }
  ~cmXMLDocument() { this->xmlwr.EndDocument(); }
  cmXMLDocument(cmXMLDocument const&) = delete;
  cmXMLDocument& operator=(cmXMLDocument const&) = delete;

private:
  friend class cmXMLElement;
  cmXMLWriter& xmlwr;
};

class cmXMLElement
{
public:
  cmXMLElement(cmXMLWriter& xml, char const* tag)
    : xmlwr(xml)
  {
    this->xmlwr.StartElement(tag);
  }
  cmXMLElement(cmXMLElement& par, char const* tag)
    : xmlwr(par.xmlwr)
  {
    this->xmlwr.StartElement(tag);
  }
  cmXMLElement(cmXMLDocument& doc, char const* tag)
    : xmlwr(doc.xmlwr)
  {
    this->xmlwr.StartElement(tag);
  }
  ~cmXMLElement() { this->xmlwr.EndElement(); }

  cmXMLElement(cmXMLElement const&) = delete;
  cmXMLElement& operator=(cmXMLElement const&) = delete;

  template <typename T>
  cmXMLElement& Attribute(char const* name, T const& value)
  {
    this->xmlwr.Attribute(name, value);
    return *this;
  }
  template <typename T>
  void Content(T const& content)
  {
    this->xmlwr.Content(content);
  }
  template <typename T>
  void Element(std::string const& name, T const& value)
  {
    this->xmlwr.Element(name, value);
  }
  void Comment(char const* comment) { this->xmlwr.Comment(comment); }

private:
  cmXMLWriter& xmlwr;
};

Line	Count	Source
1		/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
2		file LICENSE.rst or https://cmake.org/licensing for details. */
3		#pragma once
4
5		#include "cmConfigure.h" // IWYU pragma: keep
6
7		#include <chrono>
8		#include <cstddef> // IWYU pragma: keep
9		#include <ctime>
10		#include <ostream>
11		#include <stack>
12		#include <string>
13		#include <vector>
14
15		#include "cmXMLSafe.h"
16
17		class cmXMLWriter
18		{
19		public:
20		cmXMLWriter(std::ostream& output, std::size_t level = 0);
21		~cmXMLWriter();
22
23		cmXMLWriter(cmXMLWriter const&) = delete;
24		cmXMLWriter& operator=(cmXMLWriter const&) = delete;
25
26		void StartDocument(char const* encoding = "UTF-8");
27		void EndDocument();
28
29		void StartElement(std::string const& name);
30		void EndElement();
31
32		void BreakAttributes();
33
34		template <typename T>
35		void Attribute(char const* name, T const& value)
36	0	{
37	0	this->PreAttribute();
38	0	this->Output << name << "=\"" << SafeAttribute(value) << '"';
39	0	} Unexecuted instantiation: void cmXMLWriter::Attribute<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Unexecuted instantiation: void cmXMLWriter::Attribute<char [13]>(char const, char const (&) [13]) Unexecuted instantiation: void cmXMLWriter::Attribute<int>(char const, int const&) Unexecuted instantiation: void cmXMLWriter::Attribute<char [3]>(char const, char const (&) [3]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [4]>(char const, char const (&) [4]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [1]>(char const, char const (&) [1]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [8]>(char const, char const (&) [8]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [17]>(char const, char const (&) [17]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [7]>(char const, char const (&) [7]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [2]>(char const, char const (&) [2]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [40]>(char const, char const (&) [40]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [25]>(char const, char const (&) [25]) Unexecuted instantiation: void cmXMLWriter::Attribute<char const>(char const, char const* const&) Unexecuted instantiation: void cmXMLWriter::Attribute<char [5]>(char const, char const (&) [5]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [30]>(char const, char const (&) [30]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [38]>(char const, char const (&) [38]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [47]>(char const, char const (&) [47]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [14]>(char const, char const (&) [14]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [34]>(char const, char const (&) [34]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [29]>(char const, char const (&) [29]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [31]>(char const, char const (&) [31]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [24]>(char const, char const (&) [24]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [39]>(char const, char const (&) [39]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [15]>(char const, char const (&) [15]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [6]>(char const, char const (&) [6]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [21]>(char const, char const (&) [21]) Unexecuted instantiation: void cmXMLWriter::Attribute<char [59]>(char const, char const (&) [59])
40
41		void Element(char const* name);
42
43		template <typename T>
44		void Element(std::string const& name, T const& value)
45	0	{
46	0	this->StartElement(name);
47	0	this->Content(value);
48	0	this->EndElement();
49	0	} Unexecuted instantiation: void cmXMLWriter::Element<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Unexecuted instantiation: void cmXMLWriter::Element<char [17]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [17]) Unexecuted instantiation: void cmXMLWriter::Element<char [1]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [1]) Unexecuted instantiation: void cmXMLWriter::Element<char [38]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [38]) Unexecuted instantiation: void cmXMLWriter::Element<char [24]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [24]) Unexecuted instantiation: void cmXMLWriter::Element<char [4]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [4]) Unexecuted instantiation: void cmXMLWriter::Element<char [47]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [47]) Unexecuted instantiation: void cmXMLWriter::Element<char [37]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [37]) Unexecuted instantiation: void cmXMLWriter::Element<char [46]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [46]) Unexecuted instantiation: void cmXMLWriter::Element<char const>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const const&) Unexecuted instantiation: void cmXMLWriter::Element<char [5]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [5]) Unexecuted instantiation: void cmXMLWriter::Element<char [6]>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, char const (&) [6]) Unexecuted instantiation: void cmXMLWriter::Element<int>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, int const&)
50
51		template <typename T>
52		void Content(T const& content)
53	0	{
54	0	this->PreContent();
55	0	this->Output << SafeContent(content);
56	0	} Unexecuted instantiation: void cmXMLWriter::Content<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Unexecuted instantiation: void cmXMLWriter::Content<char [17]>(char const (&) [17]) Unexecuted instantiation: void cmXMLWriter::Content<char [1]>(char const (&) [1]) Unexecuted instantiation: void cmXMLWriter::Content<char [38]>(char const (&) [38]) Unexecuted instantiation: void cmXMLWriter::Content<char [24]>(char const (&) [24]) Unexecuted instantiation: void cmXMLWriter::Content<char [4]>(char const (&) [4]) Unexecuted instantiation: void cmXMLWriter::Content<char [47]>(char const (&) [47]) Unexecuted instantiation: void cmXMLWriter::Content<char [37]>(char const (&) [37]) Unexecuted instantiation: void cmXMLWriter::Content<char [46]>(char const (&) [46]) Unexecuted instantiation: void cmXMLWriter::Content<char const>(char const const&) Unexecuted instantiation: void cmXMLWriter::Content<char [5]>(char const (&) [5]) Unexecuted instantiation: void cmXMLWriter::Content<char [6]>(char const (&) [6]) Unexecuted instantiation: void cmXMLWriter::Content<int>(int const&)
57
58		void Comment(char const* comment);
59
60		void CData(std::string const& data);
61
62		void Doctype(char const* doctype);
63
64		void ProcessingInstruction(char const* target, char const* data);
65
66		void FragmentFile(char const* fname);
67
68		void SetIndentationElement(std::string const& element);
69
70		private:
71		void ConditionalLineBreak(bool condition);
72
73		void PreAttribute();
74		void PreContent();
75
76		void CloseStartElement();
77
78	0	static cmXMLSafe SafeAttribute(char const* value) { return { value }; }
79
80		static cmXMLSafe SafeAttribute(std::string const& value)
81	0	{
82	0	return { value };
83	0	}
84
85		template <typename T>
86		static T SafeAttribute(T value)
87	0	{
88	0	return value;
89	0	}
90
91		static cmXMLSafe SafeContent(char const* value)
92	0	{
93	0	return cmXMLSafe(value).Quotes(false);
94	0	}
95
96		static cmXMLSafe SafeContent(std::string const& value)
97	0	{
98	0	return cmXMLSafe(value).Quotes(false);
99	0	}
100
101		/*
102		* Convert a std::chrono::system::time_point to the number of seconds since
103		* the UN*X epoch.
104		*
105		* It would be tempting to convert a time_point to number of seconds by
106		* using time_since_epoch(). Unfortunately the C++11 standard does not
107		* specify what the epoch of the system_clock must be.
108		* Therefore we must assume it is an arbitrary point in time. Instead of this
109		* method, it is recommended to convert it by means of the to_time_t method.
110		*/
111		static std::time_t SafeContent(std::chrono::system_clock::time_point value)
112	0	{
113	0	return std::chrono::system_clock::to_time_t(value);
114	0	}
115
116		template <typename T>
117		static T SafeContent(T value)
118	0	{
119	0	return value;
120	0	}
121
122		std::ostream& Output;
123		std::stack<std::string, std::vector<std::string>> Elements;
124		std::string IndentationElement;
125		std::size_t Level;
126		std::size_t Indent = 0;
127		bool ElementOpen = false;
128		bool BreakAttrib = false;
129		bool IsContent = false;
130		};
131
132		class cmXMLElement; // IWYU pragma: keep
133
134		class cmXMLDocument
135		{
136		public:
137		cmXMLDocument(cmXMLWriter& xml)
138		: xmlwr(xml)
139	0	{
140	0	this->xmlwr.StartDocument();
141	0	}
142	0	~cmXMLDocument() { this->xmlwr.EndDocument(); }
143		cmXMLDocument(cmXMLDocument const&) = delete;
144		cmXMLDocument& operator=(cmXMLDocument const&) = delete;
145
146		private:
147		friend class cmXMLElement;
148		cmXMLWriter& xmlwr;
149		};
150
151		class cmXMLElement
152		{
153		public:
154		cmXMLElement(cmXMLWriter& xml, char const* tag)
155		: xmlwr(xml)
156	0	{
157	0	this->xmlwr.StartElement(tag);
158	0	}
159		cmXMLElement(cmXMLElement& par, char const* tag)
160		: xmlwr(par.xmlwr)
161	0	{
162	0	this->xmlwr.StartElement(tag);
163	0	}
164		cmXMLElement(cmXMLDocument& doc, char const* tag)
165		: xmlwr(doc.xmlwr)
166	0	{
167	0	this->xmlwr.StartElement(tag);
168	0	}
169	0	~cmXMLElement() { this->xmlwr.EndElement(); }
170
171		cmXMLElement(cmXMLElement const&) = delete;
172		cmXMLElement& operator=(cmXMLElement const&) = delete;
173
174		template <typename T>
175		cmXMLElement& Attribute(char const* name, T const& value)
176		{
177		this->xmlwr.Attribute(name, value);
178		return *this;
179		}
180		template <typename T>
181		void Content(T const& content)
182		{
183		this->xmlwr.Content(content);
184		}
185		template <typename T>
186		void Element(std::string const& name, T const& value)
187		{
188		this->xmlwr.Element(name, value);
189		}
190	0	void Comment(char const* comment) { this->xmlwr.Comment(comment); }
191
192		private:
193		cmXMLWriter& xmlwr;
194		};

Coverage Report

Created: 2026-02-09 06:05