| /* |
| * 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 |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
|
|
| #ifndef MEMORYOUTPUTSTREAM_H_INCLUDED
|
| #define MEMORYOUTPUTSTREAM_H_INCLUDED
|
|
|
| #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 {
|
| public:
|
| //==============================================================================
|
| /** Creates an empty memory stream, ready to be written into.
|
| @param initialSize the intial amount of capacity to allocate for writing
|
| into
|
| */
|
| MemoryOutputStream(size_t initialSize = 256);
|
|
|
| /** Creates a memory stream for writing into into a pre-existing MemoryBlock
|
| object.
|
|
|
| Note that the destination block will always be larger than the amount of
|
| data
|
| that has been written to the stream, because the MemoryOutputStream keeps
|
| some
|
| spare capactity at its end. To trim the block's size down to fit the
|
| actual
|
| 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
|
| use
|
| */
|
| MemoryOutputStream(MemoryBlock& memoryBlockToWriteTo,
|
| bool appendToExistingBlockContent);
|
|
|
| /** Creates a MemoryOutputStream that will write into a user-supplied,
|
| fixed-size
|
| block of memory.
|
| When using this mode, the stream will write directly into this memory area
|
| until
|
| 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.
|
| */
|
| ~MemoryOutputStream();
|
|
|
| //==============================================================================
|
| /** 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
|
| specified
|
| 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);
|
|
|
| private:
|
| //==============================================================================
|
| 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);
|
| }
|
| #endif // MEMORYOUTPUTSTREAM_H_INCLUDED
|