1// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
2// Licensed under the MIT License:
3//
4// Permission is hereby granted, free of charge, to any person obtaining a copy
5// of this software and associated documentation files (the "Software"), to deal
6// in the Software without restriction, including without limitation the rights
7// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8// copies of the Software, and to permit persons to whom the Software is
9// furnished to do so, subject to the following conditions:
10//
11// The above copyright notice and this permission notice shall be included in
12// all copies or substantial portions of the Software.
13//
14// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20// THE SOFTWARE.
21
22#pragma once
23
24#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
25#pragma GCC system_header
26#endif
27
28#include "serialize.h"
29
30namespace capnp {
31
32namespace _ { // private
33
34class PackedInputStream: public kj::InputStream {
35 // An input stream that unpacks packed data with a picky constraint: The caller must read data
36 // in the exact same size and sequence as the data was written to PackedOutputStream.
37
38public:
39 explicit PackedInputStream(kj::BufferedInputStream& inner);
40 KJ_DISALLOW_COPY(PackedInputStream);
41 ~PackedInputStream() noexcept(false);
42
43 // implements InputStream ------------------------------------------
44 size_t tryRead(void* buffer, size_t minBytes, size_t maxBytes) override;
45 void skip(size_t bytes) override;
46
47private:
48 kj::BufferedInputStream& inner;
49};
50
51class PackedOutputStream: public kj::OutputStream {
52 // An output stream that packs data. Buffers passed to `write()` must be word-aligned.
53public:
54 explicit PackedOutputStream(kj::BufferedOutputStream& inner);
55 KJ_DISALLOW_COPY(PackedOutputStream);
56 ~PackedOutputStream() noexcept(false);
57
58 // implements OutputStream -----------------------------------------
59 void write(const void* buffer, size_t bytes) override;
60
61private:
62 kj::BufferedOutputStream& inner;
63};
64
65} // namespace _ (private)
66
67class PackedMessageReader: private _::PackedInputStream, public InputStreamMessageReader {
68public:
69 PackedMessageReader(kj::BufferedInputStream& inputStream, ReaderOptions options = ReaderOptions(),
70 kj::ArrayPtr<word> scratchSpace = nullptr);
71 KJ_DISALLOW_COPY(PackedMessageReader);
72 ~PackedMessageReader() noexcept(false);
73};
74
75class PackedFdMessageReader: private kj::FdInputStream, private kj::BufferedInputStreamWrapper,
76 public PackedMessageReader {
77public:
78 PackedFdMessageReader(int fd, ReaderOptions options = ReaderOptions(),
79 kj::ArrayPtr<word> scratchSpace = nullptr);
80 // Read message from a file descriptor, without taking ownership of the descriptor.
81 // Note that if you want to reuse the descriptor after the reader is destroyed, you'll need to
82 // seek it, since otherwise the position is unspecified.
83
84 PackedFdMessageReader(kj::AutoCloseFd fd, ReaderOptions options = ReaderOptions(),
85 kj::ArrayPtr<word> scratchSpace = nullptr);
86 // Read a message from a file descriptor, taking ownership of the descriptor.
87
88 KJ_DISALLOW_COPY(PackedFdMessageReader);
89
90 ~PackedFdMessageReader() noexcept(false);
91};
92
93void writePackedMessage(kj::BufferedOutputStream& output, MessageBuilder& builder);
94void writePackedMessage(kj::BufferedOutputStream& output,
95 kj::ArrayPtr<const kj::ArrayPtr<const word>> segments);
96// Write a packed message to a buffered output stream.
97
98void writePackedMessage(kj::OutputStream& output, MessageBuilder& builder);
99void writePackedMessage(kj::OutputStream& output,
100 kj::ArrayPtr<const kj::ArrayPtr<const word>> segments);
101// Write a packed message to an unbuffered output stream. If you intend to write multiple messages
102// in succession, consider wrapping your output in a buffered stream in order to reduce system
103// call overhead.
104
105void writePackedMessageToFd(int fd, MessageBuilder& builder);
106void writePackedMessageToFd(int fd, kj::ArrayPtr<const kj::ArrayPtr<const word>> segments);
107// Write a single packed message to the file descriptor.
108
109size_t computeUnpackedSizeInWords(kj::ArrayPtr<const byte> packedBytes);
110// Computes the number of words to which the given packed bytes will unpack. Not intended for use
111// in performance-sensitive situations.
112
113// =======================================================================================
114// inline stuff
115
116inline void writePackedMessage(kj::BufferedOutputStream& output, MessageBuilder& builder) {
117 writePackedMessage(output, builder.getSegmentsForOutput());
118}
119
120inline void writePackedMessage(kj::OutputStream& output, MessageBuilder& builder) {
121 writePackedMessage(output, builder.getSegmentsForOutput());
122}
123
124inline void writePackedMessageToFd(int fd, MessageBuilder& builder) {
125 writePackedMessageToFd(fd, builder.getSegmentsForOutput());
126}
127
128} // namespace capnp
129