| //===- MsgPackWriter.h - Simple MsgPack writer ------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| /// |
| /// \file |
| /// This file contains a MessagePack writer. |
| /// |
| /// See https://github.com/msgpack/msgpack/blob/master/spec.md for the full |
| /// specification. |
| /// |
| /// Typical usage: |
| /// \code |
| /// raw_ostream output = GetOutputStream(); |
| /// msgpack::Writer MPWriter(output); |
| /// MPWriter.writeNil(); |
| /// MPWriter.write(false); |
| /// MPWriter.write("string"); |
| /// // ... |
| /// \endcode |
| /// |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_SUPPORT_MSGPACKPARSER_H |
| #define LLVM_SUPPORT_MSGPACKPARSER_H |
| |
| #include "llvm/BinaryFormat/MsgPack.h" |
| #include "llvm/Support/EndianStream.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "llvm/Support/raw_ostream.h" |
| |
| namespace llvm { |
| namespace msgpack { |
| |
| /// Writes MessagePack objects to an output stream, one at a time. |
| class Writer { |
| public: |
| /// Construct a writer, optionally enabling "Compatibility Mode" as defined |
| /// in the MessagePack specification. |
| /// |
| /// When in \p Compatible mode, the writer will write \c Str16 formats |
| /// instead of \c Str8 formats, and will refuse to write any \c Bin formats. |
| /// |
| /// \param OS stream to output MessagePack objects to. |
| /// \param Compatible when set, write in "Compatibility Mode". |
| Writer(raw_ostream &OS, bool Compatible = false); |
| |
| Writer(const Writer &) = delete; |
| Writer &operator=(const Writer &) = delete; |
| |
| /// Write a \em Nil to the output stream. |
| /// |
| /// The output will be the \em nil format. |
| void writeNil(); |
| |
| /// Write a \em Boolean to the output stream. |
| /// |
| /// The output will be a \em bool format. |
| void write(bool b); |
| |
| /// Write a signed integer to the output stream. |
| /// |
| /// The output will be in the smallest possible \em int format. |
| /// |
| /// The format chosen may be for an unsigned integer. |
| void write(int64_t i); |
| |
| /// Write an unsigned integer to the output stream. |
| /// |
| /// The output will be in the smallest possible \em int format. |
| void write(uint64_t u); |
| |
| /// Write a floating point number to the output stream. |
| /// |
| /// The output will be in the smallest possible \em float format. |
| void write(double d); |
| |
| /// Write a string to the output stream. |
| /// |
| /// The output will be in the smallest possible \em str format. |
| void write(StringRef s); |
| |
| /// Write a memory buffer to the output stream. |
| /// |
| /// The output will be in the smallest possible \em bin format. |
| /// |
| /// \warning Do not use this overload if in \c Compatible mode. |
| void write(MemoryBufferRef Buffer); |
| |
| /// Write the header for an \em Array of the given size. |
| /// |
| /// The output will be in the smallest possible \em array format. |
| // |
| /// The header contains an identifier for the \em array format used, as well |
| /// as an encoding of the size of the array. |
| /// |
| /// N.B. The caller must subsequently call \c Write an additional \p Size |
| /// times to complete the array. |
| void writeArraySize(uint32_t Size); |
| |
| /// Write the header for a \em Map of the given size. |
| /// |
| /// The output will be in the smallest possible \em map format. |
| // |
| /// The header contains an identifier for the \em map format used, as well |
| /// as an encoding of the size of the map. |
| /// |
| /// N.B. The caller must subsequently call \c Write and additional \c Size*2 |
| /// times to complete the map. Each even numbered call to \c Write defines a |
| /// new key, and each odd numbered call defines the previous key's value. |
| void writeMapSize(uint32_t Size); |
| |
| /// Write a typed memory buffer (an extension type) to the output stream. |
| /// |
| /// The output will be in the smallest possible \em ext format. |
| void writeExt(int8_t Type, MemoryBufferRef Buffer); |
| |
| private: |
| support::endian::Writer EW; |
| bool Compatible; |
| }; |
| |
| } // end namespace msgpack |
| } // end namespace llvm |
| |
| #endif // LLVM_SUPPORT_MSGPACKPARSER_H |