1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef AAPT_BIG_BUFFER_H
18#define AAPT_BIG_BUFFER_H
19
20#include <cassert>
21#include <cstring>
22#include <memory>
23#include <vector>
24
25namespace aapt {
26
27/**
28 * Inspired by protobuf's ZeroCopyOutputStream, offers blocks of memory
29 * in which to write without knowing the full size of the entire payload.
30 * This is essentially a list of memory blocks. As one fills up, another
31 * block is allocated and appended to the end of the list.
32 */
33class BigBuffer {
34public:
35    /**
36     * A contiguous block of allocated memory.
37     */
38    struct Block {
39        /**
40         * Pointer to the memory.
41         */
42        std::unique_ptr<uint8_t[]> buffer;
43
44        /**
45         * Size of memory that is currently occupied. The actual
46         * allocation may be larger.
47         */
48        size_t size;
49
50    private:
51        friend class BigBuffer;
52
53        /**
54         * The size of the memory block allocation.
55         */
56        size_t mBlockSize;
57    };
58
59    typedef std::vector<Block>::const_iterator const_iterator;
60
61    /**
62     * Create a BigBuffer with block allocation sizes
63     * of blockSize.
64     */
65    BigBuffer(size_t blockSize);
66
67    BigBuffer(const BigBuffer&) = delete; // No copying.
68
69    BigBuffer(BigBuffer&& rhs);
70
71    /**
72     * Number of occupied bytes in all the allocated blocks.
73     */
74    size_t size() const;
75
76    /**
77     * Returns a pointer to an array of T, where T is
78     * a POD type. The elements are zero-initialized.
79     */
80    template <typename T>
81    T* nextBlock(size_t count = 1);
82
83    /**
84     * Moves the specified BigBuffer into this one. When this method
85     * returns, buffer is empty.
86     */
87    void appendBuffer(BigBuffer&& buffer);
88
89    /**
90     * Pads the block with 'bytes' bytes of zero values.
91     */
92    void pad(size_t bytes);
93
94    /**
95     * Pads the block so that it aligns on a 4 byte boundary.
96     */
97    void align4();
98
99    const_iterator begin() const;
100    const_iterator end() const;
101
102private:
103    /**
104     * Returns a pointer to a buffer of the requested size.
105     * The buffer is zero-initialized.
106     */
107    void* nextBlockImpl(size_t size);
108
109    size_t mBlockSize;
110    size_t mSize;
111    std::vector<Block> mBlocks;
112};
113
114inline BigBuffer::BigBuffer(size_t blockSize) : mBlockSize(blockSize), mSize(0) {
115}
116
117inline BigBuffer::BigBuffer(BigBuffer&& rhs) :
118        mBlockSize(rhs.mBlockSize), mSize(rhs.mSize), mBlocks(std::move(rhs.mBlocks)) {
119}
120
121inline size_t BigBuffer::size() const {
122    return mSize;
123}
124
125template <typename T>
126inline T* BigBuffer::nextBlock(size_t count) {
127    assert(count != 0);
128    return reinterpret_cast<T*>(nextBlockImpl(sizeof(T) * count));
129}
130
131inline void BigBuffer::appendBuffer(BigBuffer&& buffer) {
132    std::move(buffer.mBlocks.begin(), buffer.mBlocks.end(), std::back_inserter(mBlocks));
133    mSize += buffer.mSize;
134    buffer.mBlocks.clear();
135    buffer.mSize = 0;
136}
137
138inline void BigBuffer::pad(size_t bytes) {
139    nextBlock<char>(bytes);
140}
141
142inline void BigBuffer::align4() {
143    const size_t unaligned = mSize % 4;
144    if (unaligned != 0) {
145        pad(4 - unaligned);
146    }
147}
148
149inline BigBuffer::const_iterator BigBuffer::begin() const {
150    return mBlocks.begin();
151}
152
153inline BigBuffer::const_iterator BigBuffer::end() const {
154    return mBlocks.end();
155}
156
157} // namespace aapt
158
159#endif // AAPT_BIG_BUFFER_H
160