| // Copyright 2013 The Flutter Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #ifndef FLUTTER_IMPELLER_BASE_ALLOCATION_H_ | |
| #define FLUTTER_IMPELLER_BASE_ALLOCATION_H_ | |
| #include <cstdint> | |
| #include <memory> | |
| #include "flutter/fml/mapping.h" | |
| #include "impeller/base/allocation_size.h" | |
| namespace impeller { | |
| //------------------------------------------------------------------------------ | |
| /// @brief Describes an allocation on the heap. | |
| /// | |
| /// Managing allocations through this utility makes it harder to | |
| /// miss allocation failures. | |
| /// | |
| class Allocation { | |
| public: | |
| //---------------------------------------------------------------------------- | |
| /// @brief Constructs a new zero-sized allocation. | |
| /// | |
| Allocation(); | |
| //---------------------------------------------------------------------------- | |
| /// @brief Destroys the allocation. | |
| /// | |
| ~Allocation(); | |
| //---------------------------------------------------------------------------- | |
| /// @brief Gets the pointer to the start of the allocation. | |
| /// | |
| /// This pointer is only valid till the next call to `Truncate`. | |
| /// | |
| /// @return The pointer to the start of the allocation. | |
| /// | |
| uint8_t* GetBuffer() const; | |
| //---------------------------------------------------------------------------- | |
| /// @brief Gets the length of the allocation. | |
| /// | |
| /// @return The length. | |
| /// | |
| Bytes GetLength() const; | |
| //---------------------------------------------------------------------------- | |
| /// @brief Gets the reserved length of the allocation. Calls to truncate | |
| /// may be ignored till the length exceeds the reserved length. | |
| /// | |
| /// @return The reserved length. | |
| /// | |
| Bytes GetReservedLength() const; | |
| //---------------------------------------------------------------------------- | |
| /// @brief Resize the underlying allocation to at least given number of | |
| /// bytes. | |
| /// | |
| /// In case of failure, false is returned and the underlying | |
| /// allocation remains unchanged. | |
| /// | |
| /// @warning Pointers to buffers obtained via previous calls to `GetBuffer` | |
| /// may become invalid at this point. | |
| /// | |
| /// @param[in] length The length. | |
| /// @param[in] npot Whether to round up the length to the next power of | |
| /// two. | |
| /// | |
| /// @return If the underlying allocation was resized to the new size. | |
| /// | |
| [[nodiscard]] bool Truncate(Bytes length, bool npot = true); | |
| //---------------------------------------------------------------------------- | |
| /// @brief Gets the next power of two size. | |
| /// | |
| /// @param[in] x The size. | |
| /// | |
| /// @return The next power of two of x. | |
| /// | |
| static uint32_t NextPowerOfTwoSize(uint32_t x); | |
| private: | |
| uint8_t* buffer_ = nullptr; | |
| Bytes length_; | |
| Bytes reserved_; | |
| [[nodiscard]] bool Reserve(Bytes reserved); | |
| [[nodiscard]] bool ReserveNPOT(Bytes reserved); | |
| Allocation(const Allocation&) = delete; | |
| Allocation& operator=(const Allocation&) = delete; | |
| }; | |
| //------------------------------------------------------------------------------ | |
| /// @brief Creates a mapping with copy of the bytes. | |
| /// | |
| /// @param[in] contents The contents | |
| /// @param[in] length The length | |
| /// | |
| /// @return The new mapping or nullptr if the copy could not be performed. | |
| /// | |
| std::shared_ptr<fml::Mapping> CreateMappingWithCopy(const uint8_t* contents, | |
| Bytes length); | |
| //------------------------------------------------------------------------------ | |
| /// @brief Creates a mapping from allocation. | |
| /// | |
| /// No data copy occurs. Only a reference to the underlying | |
| /// allocation is bumped up. | |
| /// | |
| /// Changes to the underlying allocation will not be reflected in | |
| /// the mapping and must not change. | |
| /// | |
| /// @param[in] allocation The allocation. | |
| /// | |
| /// @return A new mapping or nullptr if the argument allocation was invalid. | |
| /// | |
| std::shared_ptr<fml::Mapping> CreateMappingFromAllocation( | |
| const std::shared_ptr<Allocation>& allocation); | |
| //------------------------------------------------------------------------------ | |
| /// @brief Creates a mapping with string data. | |
| /// | |
| /// Only a reference to the underlying string is bumped up and the | |
| /// string is not copied. | |
| /// | |
| /// @param[in] string The string | |
| /// | |
| /// @return A new mapping or nullptr in case of allocation failures. | |
| /// | |
| std::shared_ptr<fml::Mapping> CreateMappingWithString( | |
| std::shared_ptr<const std::string> string); | |
| //------------------------------------------------------------------------------ | |
| /// @brief Creates a mapping with string data. | |
| /// | |
| /// The string is copied. | |
| /// | |
| /// @param[in] string The string | |
| /// | |
| /// @return A new mapping or nullptr in case of allocation failures. | |
| /// | |
| std::shared_ptr<fml::Mapping> CreateMappingWithString(std::string string); | |
| } // namespace impeller | |
| #endif // FLUTTER_IMPELLER_BASE_ALLOCATION_H_ |