| /* |
| * 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 __DATABLOCK_H__ |
| #define __DATABLOCK_H__ |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <algorithm> |
| #include <cstdlib> |
| #include <cstring> |
| |
| #include "RocketMQClient.h" |
| |
| namespace rocketmq { |
| |
| class ROCKETMQCLIENT_API MemoryBlock { |
| public: |
| //============================================================================== |
| /** Create an uninitialised block with 0 size. */ |
| MemoryBlock(); |
| |
| /** Creates a memory block with a given initial size. |
| |
| @param initialSize the size of block to create |
| @param initialiseToZero whether to clear the memory or just leave it |
| uninitialised |
| */ |
| MemoryBlock(const int initialSize, bool initialiseToZero = false); |
| |
| /** Creates a memory block using a copy of a block of data. |
| |
| @param dataToInitialiseFrom some data to copy into this block |
| @param sizeInBytes how much space to use |
| */ |
| MemoryBlock(const void* dataToInitialiseFrom, size_t sizeInBytes); |
| |
| /** Creates a copy of another memory block. */ |
| MemoryBlock(const MemoryBlock&); |
| |
| MemoryBlock(MemoryBlock&&); |
| |
| /** Destructor. */ |
| ~MemoryBlock(); |
| |
| /** Copies another memory block onto this one. |
| This block will be resized and copied to exactly match the other one. |
| */ |
| MemoryBlock& operator=(const MemoryBlock&); |
| |
| MemoryBlock& operator=(MemoryBlock&&); |
| |
| //============================================================================== |
| /** Compares two memory blocks. |
| @returns true only if the two blocks are the same size and have identical |
| contents. |
| */ |
| bool operator==(const MemoryBlock& other) const; |
| |
| /** Compares two memory blocks. |
| @returns true if the two blocks are different sizes or have different |
| contents. |
| */ |
| bool operator!=(const MemoryBlock& other) const; |
| |
| //============================================================================== |
| /** Returns a void pointer to the data. |
| |
| Note that the pointer returned will probably become invalid when the |
| block is resized. |
| */ |
| char* getData() const { return data; } |
| |
| /** Returns a byte from the memory block. |
| This returns a reference, so you can also use it to set a byte. |
| */ |
| template <typename Type> |
| char& operator[](const Type offset) const { |
| return data[offset]; |
| } |
| |
| /** Returns true if the data in this MemoryBlock matches the raw bytes |
| * passed-in. */ |
| bool matches(const void* data, int dataSize) const; |
| |
| //============================================================================== |
| /** Returns the block's current allocated size, in bytes. */ |
| int getSize() const { return size; } |
| |
| /** Resizes the memory block. |
| |
| Any data that is present in both the old and new sizes will be retained. |
| When enlarging the block, the new space that is allocated at the end can |
| either be |
| cleared, or left uninitialised. |
| |
| @param newSize the new desired size for the block |
| @param initialiseNewSpaceToZero if the block gets enlarged, this |
| determines |
| whether to clear the new section or |
| just leave it |
| uninitialised |
| @see ensureSize |
| */ |
| void setSize(const int newSize, bool initialiseNewSpaceToZero = false); |
| |
| /** Increases the block's size only if it's smaller than a given size. |
| |
| @param minimumSize if the block is already bigger than |
| this size, no action |
| will be taken; otherwise it will be |
| increased to this size |
| @param initialiseNewSpaceToZero if the block gets enlarged, this |
| determines |
| whether to clear the new section or |
| just leave it |
| uninitialised |
| @see setSize |
| */ |
| void ensureSize(const int minimumSize, bool initialiseNewSpaceToZero = false); |
| |
| /** Frees all the blocks data, setting its size to 0. */ |
| void reset(); |
| |
| //============================================================================== |
| /** Fills the entire memory block with a repeated byte value. |
| This is handy for clearing a block of memory to zero. |
| */ |
| void fillWith(int valueToUse); |
| |
| /** Adds another block of data to the end of this one. |
| The data pointer must not be null. This block's size will be increased |
| accordingly. |
| */ |
| void append(const void* data, int numBytes); |
| |
| /** Resizes this block to the given size and fills its contents from the |
| supplied buffer. |
| The data pointer must not be null. |
| */ |
| void replaceWith(const void* data, int numBytes); |
| |
| /** Inserts some data into the block. |
| The dataToInsert pointer must not be null. This block's size will be |
| increased accordingly. |
| If the insert position lies outside the valid range of the block, it will |
| be clipped to |
| within the range before being used. |
| */ |
| void insert(const void* dataToInsert, int numBytesToInsert, int insertPosition); |
| |
| /** Chops out a section of the block. |
| |
| This will remove a section of the memory block and close the gap around |
| it, |
| shifting any subsequent data downwards and reducing the size of the block. |
| |
| If the range specified goes beyond the size of the block, it will be |
| clipped. |
| */ |
| void removeSection(int startByte, int numBytesToRemove); |
| |
| //============================================================================== |
| /** Copies data into this MemoryBlock from a memory address. |
| |
| @param srcData the memory location of the data to copy into |
| this block |
| @param destinationOffset the offset in this block at which the data |
| being copied should begin |
| @param numBytes how much to copy in (if this goes beyond the |
| size of the memory block, |
| it will be clipped so not to do anything |
| nasty) |
| */ |
| void copyFrom(const void* srcData, int destinationOffset, int numBytes); |
| |
| /** Copies data from this MemoryBlock to a memory address. |
| |
| @param destData the memory location to write to |
| @param sourceOffset the offset within this block from which the copied |
| data will be read |
| @param numBytes how much to copy (if this extends beyond the |
| limits of the memory block, |
| zeros will be used for that portion of the data) |
| */ |
| void copyTo(void* destData, int sourceOffset, int numBytes) const; |
| |
| private: |
| //============================================================================== |
| int size; |
| char* data; |
| }; |
| } |
| |
| #endif |