include/llvm/BinaryFormat/MsgPackWriter.h

   1 //===- MsgPackWriter.h - Simple MsgPack writer ------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 ///  \file
  10 ///  This file contains a MessagePack writer.
  11 ///
  12 ///  See https://github.com/msgpack/msgpack/blob/master/spec.md for the full
  13 ///  specification.
  14 ///
  15 ///  Typical usage:
  16 ///  \code
  17 ///  raw_ostream output = GetOutputStream();
  18 ///  msgpack::Writer MPWriter(output);
  19 ///  MPWriter.writeNil();
  20 ///  MPWriter.write(false);
  21 ///  MPWriter.write("string");
  22 ///  // ...
  23 ///  \endcode
  24 ///
  25 ///
  26 //===----------------------------------------------------------------------===//
  27
  28 #ifndef LLVM_SUPPORT_MSGPACKPARSER_H
  29 #define LLVM_SUPPORT_MSGPACKPARSER_H
  30
  31 #include "llvm/BinaryFormat/MsgPack.h"
  32 #include "llvm/Support/EndianStream.h"
  33 #include "llvm/Support/MemoryBuffer.h"
  34 #include "llvm/Support/raw_ostream.h"
  35
  36 namespace llvm {
  37 namespace msgpack {
  38
  39 /// Writes MessagePack objects to an output stream, one at a time.
  40 class Writer {
  41 public:
  42   /// Construct a writer, optionally enabling "Compatibility Mode" as defined
  43   /// in the MessagePack specification.
  44   ///
  45   /// When in \p Compatible mode, the writer will write \c Str16 formats
  46   /// instead of \c Str8 formats, and will refuse to write any \c Bin formats.
  47   ///
  48   /// \param OS stream to output MessagePack objects to.
  49   /// \param Compatible when set, write in "Compatibility Mode".
  50   Writer(raw_ostream &OS, bool Compatible = false);
  51
  52   Writer(const Writer &) = delete;
  53   Writer &operator=(const Writer &) = delete;
  54
  55   /// Write a \em Nil to the output stream.
  56   ///
  57   /// The output will be the \em nil format.
  58   void writeNil();
  59
  60   /// Write a \em Boolean to the output stream.
  61   ///
  62   /// The output will be a \em bool format.
  63   void write(bool b);
  64
  65   /// Write a signed integer to the output stream.
  66   ///
  67   /// The output will be in the smallest possible \em int format.
  68   ///
  69   /// The format chosen may be for an unsigned integer.
  70   void write(int64_t i);
  71
  72   /// Write an unsigned integer to the output stream.
  73   ///
  74   /// The output will be in the smallest possible \em int format.
  75   void write(uint64_t u);
  76
  77   /// Write a floating point number to the output stream.
  78   ///
  79   /// The output will be in the smallest possible \em float format.
  80   void write(double d);
  81
  82   /// Write a string to the output stream.
  83   ///
  84   /// The output will be in the smallest possible \em str format.
  85   void write(StringRef s);
  86
  87   /// Write a memory buffer to the output stream.
  88   ///
  89   /// The output will be in the smallest possible \em bin format.
  90   ///
  91   /// \warning Do not use this overload if in \c Compatible mode.
  92   void write(MemoryBufferRef Buffer);
  93
  94   /// Write the header for an \em Array of the given size.
  95   ///
  96   /// The output will be in the smallest possible \em array format.
  97   //
  98   /// The header contains an identifier for the \em array format used, as well
  99   /// as an encoding of the size of the array.
 100   ///
 101   /// N.B. The caller must subsequently call \c Write an additional \p Size
 102   /// times to complete the array.
 103   void writeArraySize(uint32_t Size);
 104
 105   /// Write the header for a \em Map of the given size.
 106   ///
 107   /// The output will be in the smallest possible \em map format.
 108   //
 109   /// The header contains an identifier for the \em map format used, as well
 110   /// as an encoding of the size of the map.
 111   ///
 112   /// N.B. The caller must subsequently call \c Write and additional \c Size*2
 113   /// times to complete the map. Each even numbered call to \c Write defines a
 114   /// new key, and each odd numbered call defines the previous key's value.
 115   void writeMapSize(uint32_t Size);
 116
 117   /// Write a typed memory buffer (an extension type) to the output stream.
 118   ///
 119   /// The output will be in the smallest possible \em ext format.
 120   void writeExt(int8_t Type, MemoryBufferRef Buffer);
 121
 122 private:
 123   support::endian::Writer EW;
 124   bool Compatible;
 125 };
 126
 127 } // end namespace msgpack
 128 } // end namespace llvm
 129
 130 #endif // LLVM_SUPPORT_MSGPACKPARSER_H