blob: cc3245a5e92ab682d0519d61fbddfd0bd22e1646 [file] [log] [blame]
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
#include "OutputStream.h"
namespace rocketmq {
Writes data to an internal memory buffer, which grows as required.
The data that was written into the stream can then be accessed later as
a contiguous block of memory.
class ROCKETMQCLIENT_API MemoryOutputStream : public OutputStream {
/** Creates an empty memory stream, ready to be written into.
@param initialSize the intial amount of capacity to allocate for writing
MemoryOutputStream(size_t initialSize = 256);
/** Creates a memory stream for writing into into a pre-existing MemoryBlock
Note that the destination block will always be larger than the amount of
that has been written to the stream, because the MemoryOutputStream keeps
spare capactity at its end. To trim the block's size down to fit the
data, call flush(), or delete the MemoryOutputStream.
@param memoryBlockToWriteTo the block into which new data will
be written.
@param appendToExistingBlockContent if this is true, the contents of
the block will be
kept, and new data will be
appended to it. If false,
the block will be cleared before
MemoryOutputStream(MemoryBlock& memoryBlockToWriteTo, bool appendToExistingBlockContent);
/** Creates a MemoryOutputStream that will write into a user-supplied,
block of memory.
When using this mode, the stream will write directly into this memory area
it's full, at which point write operations will fail.
MemoryOutputStream(void* destBuffer, size_t destBufferSize);
/** Destructor.
This will free any data that was written to it.
/** Returns a pointer to the data that has been written to the stream.
@see getDataSize
const void* getData() const;
/** Returns the number of bytes of data that have been written to the stream.
@see getData
size_t getDataSize() const { return size; }
/** Resets the stream, clearing any data that has been written to it so far.
void reset();
/** Increases the internal storage capacity to be able to contain at least the
amount of data without needing to be resized.
void preallocate(size_t bytesToPreallocate);
/** Returns a copy of the stream's data as a memory block. */
MemoryBlock getMemoryBlock() const;
/** If the stream is writing to a user-supplied MemoryBlock, this will trim
any excess
capacity off the block, so that its length matches the amount of actual
data that
has been written so far.
void flush();
bool write(const void*, size_t);
int64 getPosition() { return (int64)position; }
bool setPosition(int64);
int64 writeFromInputStream(InputStream&, int64 maxNumBytesToWrite);
bool writeRepeatedByte(uint8 byte, size_t numTimesToRepeat);
MemoryBlock* const blockToUse;
MemoryBlock internalBlock;
void* externalData;
size_t position, size, availableSize;
void trimExternalBlockSize();
char* prepareToWrite(size_t);
/** Copies all the data that has been written to a MemoryOutputStream into
* another stream. */
OutputStream& operator<<(OutputStream& stream, const MemoryOutputStream& streamToRead);
} // namespace rocketmq