mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-26 04:32:44 +01:00
ae65e281f3
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
131 lines
4.1 KiB
C++
131 lines
4.1 KiB
C++
//===- MsgPackWriter.h - Simple MsgPack writer ------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \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
|