OpenShot Audio Library | OpenShotAudio: juce::HeapBlock< ElementType, throwOnFailure > Class Template Reference

OpenShot Audio Library | OpenShotAudio 0.3.1

Loading...
Searching...
No Matches
Public Types | Public Member Functions | List of all members
juce::HeapBlock< ElementType, throwOnFailure > Class Template Reference

`#include <juce_HeapBlock.h>`

## Public Types
using | Type = ElementType

## Public Member Functions
| HeapBlock ()=default
template<typename SizeType >
| HeapBlock (SizeType numElements)
template<typename SizeType >
| HeapBlock (SizeType numElements, bool initialiseToZero)
| ~HeapBlock ()
| HeapBlock (HeapBlock &&other) noexcept
HeapBlock & | operator= (HeapBlock &&other) noexcept
template<class OtherElementType , bool otherThrowOnFailure, typename = AllowConversion<OtherElementType>>
| HeapBlock (HeapBlock< OtherElementType, otherThrowOnFailure > &&other) noexcept
template<class OtherElementType , bool otherThrowOnFailure, typename = AllowConversion<OtherElementType>>
HeapBlock & | operator= (HeapBlock< OtherElementType, otherThrowOnFailure > &&other) noexcept
| operator ElementType * () const noexcept
ElementType * | get () const noexcept
ElementType * | getData () const noexcept
| operator void * () const noexcept
| operator const void * () const noexcept
ElementType * | operator-> () const noexcept
template<typename IndexType >
ElementType & | operator[] (IndexType index) const noexcept
template<typename IndexType >
ElementType * | operator+ (IndexType index) const noexcept
bool | operator== (const ElementType *otherPointer) const noexcept
bool | operator!= (const ElementType *otherPointer) const noexcept
template<typename SizeType >
void | malloc (SizeType newNumElements, size_t elementSize=sizeof(ElementType))
template<typename SizeType >
void | calloc (SizeType newNumElements, const size_t elementSize=sizeof(ElementType))
template<typename SizeType >
void | allocate (SizeType newNumElements, bool initialiseToZero)
template<typename SizeType >
void | realloc (SizeType newNumElements, size_t elementSize=sizeof(ElementType))
void | free () noexcept
template<bool otherBlockThrows>
void | swapWith (HeapBlock< ElementType, otherBlockThrows > &other) noexcept
template<typename SizeType >
void | clear (SizeType numElements) noexcept

## Detailed Description

template<class ElementType, bool throwOnFailure = false>
class juce::HeapBlock< ElementType, throwOnFailure >

Very simple container class to hold a pointer to some data on the heap.

When you need to allocate some heap storage for something, always try to use this class instead of allocating the memory directly using malloc/free.

A HeapBlock<char> object can be treated in pretty much exactly the same way as an char*, but as long as you allocate it on the stack or as a class member, it's almost impossible for it to leak memory.

It also makes your code much more concise and readable than doing the same thing using direct allocations,

E.g. instead of this:

int* temp = (int*) malloc (1024 * sizeof (int));
memcpy (temp, xyz, 1024 * sizeof (int));
free (temp);
temp = (int*) calloc (2048 * sizeof (int));
temp[0] = 1234;
memcpy (foobar, temp, 2048 * sizeof (int));
free (temp);
juce::HeapBlock::malloc
void malloc(SizeType newNumElements, size_t elementSize=sizeof(ElementType))
Definition: juce_HeapBlock.h:252
juce::HeapBlock::free
void free() noexcept
Definition: juce_HeapBlock.h:300
juce::HeapBlock::calloc
void calloc(SizeType newNumElements, const size_t elementSize=sizeof(ElementType))
Definition: juce_HeapBlock.h:263

..you could just write this:

HeapBlock<int> temp (1024);
memcpy (temp, xyz, 1024 * sizeof (int));
temp.calloc (2048);
temp[0] = 1234;
memcpy (foobar, temp, 2048 * sizeof (int));
juce::HeapBlock
Definition: juce_HeapBlock.h:87

The class is extremely lightweight, containing only a pointer to the data, and exposes malloc/realloc/calloc/free methods that do the same jobs as their less object-oriented counterparts. Despite adding safety, you probably won't sacrifice any performance by using this in place of normal pointers.

The throwOnFailure template parameter can be set to true if you'd like the class to throw a std::bad_alloc exception when an allocation fails. If this is false, then a failed allocation will just leave the heapblock with a null pointer (assuming that the system's malloc() function doesn't throw).

See also
  Array, OwnedArray, MemoryBlock

Definition at line 86 of file juce_HeapBlock.h.

## Member Typedef Documentation

## ◆ Type

template<class ElementType , bool throwOnFailure = false>

using juce::HeapBlock< ElementType, throwOnFailure >::Type = ElementType

This typedef can be used to get the type of the heapblock's elements.

Definition at line 326 of file juce_HeapBlock.h.

## Constructor & Destructor Documentation

## ◆ HeapBlock() [1/5]

template<class ElementType , bool throwOnFailure = false>

juce::HeapBlock< ElementType, throwOnFailure >::HeapBlock | ( |  | ) |
| default

Creates a HeapBlock which is initially just a null pointer.

After creation, you can resize the array using the malloc(), calloc(), or realloc() methods.

## ◆ HeapBlock() [2/5]

template<class ElementType , bool throwOnFailure = false>
template<typename SizeType >

juce::HeapBlock< ElementType, throwOnFailure >::HeapBlock | ( | SizeType | numElements | ) |
| inlineexplicit

Creates a HeapBlock containing a number of elements.

The contents of the block are undefined, as it will have been created by a malloc call.

If you want an array of zero values, you can use the calloc() method or the other constructor that takes an InitialisationState parameter.

Definition at line 111 of file juce_HeapBlock.h.

## ◆ HeapBlock() [3/5]

template<class ElementType , bool throwOnFailure = false>
template<typename SizeType >

juce::HeapBlock< ElementType, throwOnFailure >::HeapBlock | ( | SizeType | numElements,
|  | bool | initialiseToZero
| ) |  |
| inline

Creates a HeapBlock containing a number of elements.

The initialiseToZero parameter determines whether the new memory should be cleared, or left uninitialised.

Definition at line 123 of file juce_HeapBlock.h.

## ◆ ~HeapBlock()

template<class ElementType , bool throwOnFailure = false>

juce::HeapBlock< ElementType, throwOnFailure >::~HeapBlock | ( |  | ) |
| inline

Destructor. This will free the data, if any has been allocated.

Definition at line 134 of file juce_HeapBlock.h.

## ◆ HeapBlock() [4/5]

template<class ElementType , bool throwOnFailure = false>

juce::HeapBlock< ElementType, throwOnFailure >::HeapBlock | ( | HeapBlock< ElementType, throwOnFailure > && | other | ) |
| inlinenoexcept

Move constructor

Definition at line 140 of file juce_HeapBlock.h.

## ◆ HeapBlock() [5/5]

template<class ElementType , bool throwOnFailure = false>
template<class OtherElementType , bool otherThrowOnFailure, typename = AllowConversion<OtherElementType>>

juce::HeapBlock< ElementType, throwOnFailure >::HeapBlock | ( | HeapBlock< OtherElementType, otherThrowOnFailure > && | other | ) |
| inlinenoexcept

Converting move constructor. Only enabled if this is a HeapBlock<Base*> and the other object is a HeapBlock<Derived*>, where std::is_base_of<Base, Derived>::value == true.

Definition at line 158 of file juce_HeapBlock.h.

## Member Function Documentation

## ◆ allocate()

template<class ElementType , bool throwOnFailure = false>
template<typename SizeType >

void juce::HeapBlock< ElementType, throwOnFailure >::allocate | ( | SizeType | newNumElements,
|  | bool | initialiseToZero
| ) |  |
| inline

Allocates a specified amount of memory and optionally clears it. This does the same job as either malloc() or calloc(), depending on the initialiseToZero parameter.

Definition at line 275 of file juce_HeapBlock.h.

Referenced by juce::MemoryBlock::MemoryBlock(), juce::MemoryBlock::setSize(), and juce::AudioBuffer< Type >::setSize().

## ◆ calloc()

template<class ElementType , bool throwOnFailure = false>
template<typename SizeType >

void juce::HeapBlock< ElementType, throwOnFailure >::calloc | ( | SizeType | newNumElements,
|  | const size_t | elementSize = `sizeof (ElementType)`
| ) |  |
| inline

Allocates a specified amount of memory and clears it. This does the same job as the malloc() method, but clears the memory that it allocates.

Definition at line 263 of file juce_HeapBlock.h.

Referenced by juce::SystemStats::getStackBacktrace(), and juce::ResamplingAudioSource::prepareToPlay().

## ◆ clear()

template<class ElementType , bool throwOnFailure = false>
template<typename SizeType >

void juce::HeapBlock< ElementType, throwOnFailure >::clear | ( | SizeType | numElements | ) |
| inlinenoexcept

This fills the block with zeros, up to the number of elements specified. Since the block has no way of knowing its own size, you must make sure that the number of elements you specify doesn't exceed the allocated size.

Definition at line 320 of file juce_HeapBlock.h.

Referenced by juce::AudioBuffer< Type >::setSize().

## ◆ free()

template<class ElementType , bool throwOnFailure = false>

void juce::HeapBlock< ElementType, throwOnFailure >::free | ( |  | ) |
| inlinenoexcept

Frees any currently-allocated data. This will free the data and reset this object to be a null pointer.

Definition at line 300 of file juce_HeapBlock.h.

Referenced by juce::BigInteger::clear(), juce::BigInteger::operator=(), juce::HeapBlock< ElementType, throwOnFailure >::operator=(), juce::MemoryBlock::reset(), and juce::AudioBuffer< Type >::setDataToReferTo().

## ◆ get()

template<class ElementType , bool throwOnFailure = false>

ElementType * juce::HeapBlock< ElementType, throwOnFailure >::get | ( |  | ) | const
| inlinenoexcept

Returns a raw pointer to the allocated data. This may be a null pointer if the data hasn't yet been allocated, or if it has been freed by calling the free() method.

Definition at line 188 of file juce_HeapBlock.h.

Referenced by juce::AudioFormatReader::searchForLevel(), and juce::AudioBuffer< Type >::setSize().

## ◆ getData()

template<class ElementType , bool throwOnFailure = false>

ElementType * juce::HeapBlock< ElementType, throwOnFailure >::getData | ( |  | ) | const
| inlinenoexcept

Returns a raw pointer to the allocated data. This may be a null pointer if the data hasn't yet been allocated, or if it has been freed by calling the free() method.

Definition at line 194 of file juce_HeapBlock.h.

Referenced by juce::dsp::FIR::Filter< SampleType >::reset().

## ◆ malloc()

template<class ElementType , bool throwOnFailure = false>
template<typename SizeType >

void juce::HeapBlock< ElementType, throwOnFailure >::malloc | ( | SizeType | newNumElements,
|  | size_t | elementSize = `sizeof (ElementType)`
| ) |  |
| inline

Allocates a specified amount of memory.

This uses the normal malloc to allocate an amount of memory for this object. Any previously allocated memory will be freed by this method.

The number of bytes allocated will be (newNumElements * elementSize). Normally you wouldn't need to specify the second parameter, but it can be handy if you need to allocate a size in bytes rather than in terms of the number of elements.

The data that is allocated will be freed when this object is deleted, or when you call free() or any of the allocation methods.

Definition at line 252 of file juce_HeapBlock.h.

Referenced by juce::BigInteger::BigInteger(), juce::BufferedInputStream::BufferedInputStream(), juce::MemoryBlock::MemoryBlock(), juce::BigInteger::operator=(), and juce::dsp::FIR::Filter< SampleType >::reset().

## ◆ operator const void *()

template<class ElementType , bool throwOnFailure = false>

juce::HeapBlock< ElementType, throwOnFailure >::operator const void * | ( |  | ) | const
| inlinenoexcept

Returns a void pointer to the allocated data. This may be a null pointer if the data hasn't yet been allocated, or if it has been freed by calling the free() method.

Definition at line 206 of file juce_HeapBlock.h.

## ◆ operator ElementType *()

template<class ElementType , bool throwOnFailure = false>

juce::HeapBlock< ElementType, throwOnFailure >::operator ElementType * | ( |  | ) | const
| inlinenoexcept

Returns a raw pointer to the allocated data. This may be a null pointer if the data hasn't yet been allocated, or if it has been freed by calling the free() method.

Definition at line 182 of file juce_HeapBlock.h.

## ◆ operator void *()

template<class ElementType , bool throwOnFailure = false>

juce::HeapBlock< ElementType, throwOnFailure >::operator void * | ( |  | ) | const
| inlinenoexcept

Returns a void pointer to the allocated data. This may be a null pointer if the data hasn't yet been allocated, or if it has been freed by calling the free() method.

Definition at line 200 of file juce_HeapBlock.h.

## ◆ operator!=()

template<class ElementType , bool throwOnFailure = false>

bool juce::HeapBlock< ElementType, throwOnFailure >::operator!= | ( | const ElementType * | otherPointer | ) | const
| inlinenoexcept

Compares the pointer with another pointer. This can be handy for checking whether this is a null pointer.

Definition at line 236 of file juce_HeapBlock.h.

## ◆ operator+()

template<class ElementType , bool throwOnFailure = false>
template<typename IndexType >

ElementType * juce::HeapBlock< ElementType, throwOnFailure >::operator+ | ( | IndexType | index | ) | const
| inlinenoexcept

Returns a pointer to a data element at an offset from the start of the array. This is the same as doing pointer arithmetic on the raw pointer itself.

Definition at line 225 of file juce_HeapBlock.h.

## ◆ operator->()

template<class ElementType , bool throwOnFailure = false>

ElementType * juce::HeapBlock< ElementType, throwOnFailure >::operator-> | ( |  | ) | const
| inlinenoexcept

Lets you use indirect calls to the first element in the array. Obviously this will cause problems if the array hasn't been initialised, because it'll be referencing a null pointer.

Definition at line 212 of file juce_HeapBlock.h.

## ◆ operator=() [1/2]

template<class ElementType , bool throwOnFailure = false>

HeapBlock & juce::HeapBlock< ElementType, throwOnFailure >::operator= | ( | HeapBlock< ElementType, throwOnFailure > && | other | ) |
| inlinenoexcept

Move assignment operator

Definition at line 147 of file juce_HeapBlock.h.

## ◆ operator=() [2/2]

template<class ElementType , bool throwOnFailure = false>
template<class OtherElementType , bool otherThrowOnFailure, typename = AllowConversion<OtherElementType>>

HeapBlock & juce::HeapBlock< ElementType, throwOnFailure >::operator= | ( | HeapBlock< OtherElementType, otherThrowOnFailure > && | other | ) |
| inlinenoexcept

Converting move assignment operator. Only enabled if this is a HeapBlock<Base*> and the other object is a HeapBlock<Derived*>, where std::is_base_of<Base, Derived>::value == true.

Definition at line 169 of file juce_HeapBlock.h.

## ◆ operator==()

template<class ElementType , bool throwOnFailure = false>

bool juce::HeapBlock< ElementType, throwOnFailure >::operator== | ( | const ElementType * | otherPointer | ) | const
| inlinenoexcept

Compares the pointer with another pointer. This can be handy for checking whether this is a null pointer.

Definition at line 231 of file juce_HeapBlock.h.

## ◆ operator[]()

template<class ElementType , bool throwOnFailure = false>
template<typename IndexType >

ElementType & juce::HeapBlock< ElementType, throwOnFailure >::operator[] | ( | IndexType | index | ) | const
| inlinenoexcept

Returns a reference to one of the data elements. Obviously there's no bounds-checking here, as this object is just a dumb pointer and has no idea of the size it currently has allocated.

Definition at line 219 of file juce_HeapBlock.h.

## ◆ realloc()

template<class ElementType , bool throwOnFailure = false>
template<typename SizeType >

void juce::HeapBlock< ElementType, throwOnFailure >::realloc | ( | SizeType | newNumElements,
|  | size_t | elementSize = `sizeof (ElementType)`
| ) |  |
| inline

Re-allocates a specified amount of memory.

The semantics of this method are the same as malloc() and calloc(), but it uses realloc() to keep as much of the existing data as possible.

Definition at line 290 of file juce_HeapBlock.h.

Referenced by juce::MemoryBlock::setSize().

## ◆ swapWith()

template<class ElementType , bool throwOnFailure = false>
template<bool otherBlockThrows>

void juce::HeapBlock< ElementType, throwOnFailure >::swapWith | ( | HeapBlock< ElementType, otherBlockThrows > & | other | ) |
| inlinenoexcept

Swaps this object's data with the data of another HeapBlock. The two objects simply exchange their data pointers.

Definition at line 310 of file juce_HeapBlock.h.

Referenced by juce::AudioBuffer< Type >::setSize().

The documentation for this class was generated from the following file:

- juce_HeapBlock.h