1#ifndef __AUDACITY_MEMORY_X_H__
2#define __AUDACITY_MEMORY_X_H__
26class ArrayOf :
public std::unique_ptr<X[]>
31 template<
typename Integral>
32 explicit ArrayOf(Integral count,
bool initialize =
false)
34 static_assert(std::is_unsigned<Integral>::value,
"Unsigned arguments only");
41 :
std::unique_ptr < X[] >
42 (
std::move((
std::unique_ptr < X[] >&)(that)))
47 std::unique_ptr<X[]>::operator=(std::move(that));
52 std::unique_ptr<X[]>::operator=(std::move(that));
56 template<
typename Integral >
58 bool initialize =
false)
60 static_assert(std::is_unsigned<Integral>::value,
"Unsigned arguments only");
63 std::unique_ptr<X[]>::reset(
safenew X[count]{});
66 std::unique_ptr<X[]>::reset(
safenew X[count]);
85 template<
typename Integral>
90 template<
typename Integral1,
typename Integral2 >
91 ArraysOf(Integral1 N, Integral2 M,
bool initialize =
false)
94 static_assert(std::is_unsigned<Integral1>::value,
"Unsigned arguments only");
95 static_assert(std::is_unsigned<Integral2>::value,
"Unsigned arguments only");
96 for (
size_t ii = 0; ii < N; ++ii)
108 template<
typename Integral >
114 template<
typename Integral >
115 void reinit(Integral count,
bool initialize)
120 template<
typename Integral1,
typename Integral2 >
121 void reinit(Integral1 countN, Integral2 countM,
bool initialize =
false)
123 static_assert(std::is_unsigned<Integral1>::value,
"Unsigned arguments only");
124 static_assert(std::is_unsigned<Integral2>::value,
"Unsigned arguments only");
126 for (
size_t ii = 0; ii < countN; ++ii)
127 (*
this)[ii].reinit(countM, initialize);
139template<
typename T >
145template <
typename Character =
char>
192template<
typename T >
202template<
typename T >
205 using std::unique_ptr< T, RestoreValue<T> >::reset;
219 std::unique_ptr < T, RestoreValue<T> >::operator=(std::move(that));
225template<
typename T >
229template<
typename T >
237template<
typename Value,
typename Category = std::forward_iterator_tag >
251template <
typename Iterator>
257 :
std::pair<Iterator, Iterator> ( a, b ) {}
260 :
std::pair<Iterator, Iterator> (
std::move(a),
std::move(b) ) {}
265 Iterator
begin()
const {
return this->first; }
266 Iterator
end()
const {
return this->second; }
272 explicit operator bool ()
const {
return !this->
empty(); }
273 size_t size()
const {
return std::distance(this->
begin(), this->
end()); }
276 {
return std::find(this->
begin(), this->
end(), t); }
278 template <
typename T>
long index(
const T &t)
const
280 auto iter = this->
find(t);
281 if (iter == this->
end())
283 return std::distance(this->
begin(), iter);
286 template <
typename T>
bool contains(
const T &t)
const
287 {
return this->
end() != this->
find(t); }
290 {
return std::find_if(this->
begin(), this->
end(), f); }
292 template <
typename F>
long index_if(
const F &f)
const
295 if (iter == this->
end())
297 return std::distance(this->
begin(), iter);
301 template <
typename F>
bool all_of(
const F &f)
const
304 [&](
typename std::iterator_traits<Iterator>::reference v)
306 return !this->
any_of( notF );
309 template <
typename F>
bool any_of(
const F &f)
const
312 template <
typename F>
bool none_of(
const F &f)
const
313 {
return !this->
any_of(f); }
316 {
const T&&
operator () (T &&v)
const {
return std::forward(v); } };
322 typename Binary = std::plus< R >,
327 Binary binary_op = {},
332 for (
auto&& v : *
this)
333 result = binary_op(result, unary_op(v));
341 typename Binary = std::plus< R >,
342 typename R2,
typename C
347 R2 (C :: * pmf) ()
const
350 return this->
accumulate( init, binary_op, std::mem_fn( pmf ) );
355 typename Unary = identity< decltype( *std::declval<Iterator>() ) >,
356 typename R =
decltype( std::declval<Unary>()( *std::declval<Iterator>() ) )
358 R
min( Unary unary_op = {} )
const
361 std::numeric_limits< R >::max(),
362 (
const R&(*)(
const R&,
const R&))
std::min,
368 typename R2,
typename C,
371 R
min( R2 (C :: * pmf) ()
const )
const
373 return this->
min( std::mem_fn( pmf ) );
377 typename Unary = identity< decltype( *std::declval<Iterator>() ) >,
378 typename R =
decltype( std::declval<Unary>()( *std::declval<Iterator>() ) )
380 R
max( Unary unary_op = {} )
const
383 std::numeric_limits< R >::lowest(),
384 (
const R&(*)(
const R&,
const R&)) std::max,
390 typename R2,
typename C,
393 R
max( R2 (C :: * pmf) ()
const )
const
395 return this->
max( std::mem_fn( pmf ) );
399 typename Unary = identity< decltype( *std::declval<Iterator>() ) >,
400 typename R =
decltype( std::declval<Unary>()( *std::declval<Iterator>() ) )
402 R
sum( Unary unary_op = {} )
const
412 typename R2,
typename C,
415 R
sum( R2 (C :: * pmf) ()
const )
const
417 return this->
sum( std::mem_fn( pmf ) );
421template<
typename Iterator>
428template<
typename Container >
432 return { container.begin(), container.end() };
435template<
typename Container >
439 return { container.begin(), container.end() };
443template<
typename Container,
typename Iterator,
typename Function >
447 std::transform( first, last, std::back_inserter( result ),
fn );
451template<
typename OutContainer,
typename InContainer,
typename Function >
454 return transform_range<OutContainer>(
455 inContainer.begin(), inContainer.end(),
fn );
465 std::hardware_destructive_interference_size
473 static void *
operator new(std::size_t count, std::align_val_t al);
474 static void operator delete(
void *ptr, std::align_val_t al);
476#if defined (_MSC_VER) && defined(_DEBUG)
480 static void *
operator new(
481 std::size_t count, std::align_val_t al, int,
const char *, int)
482 {
return operator new(count, al); }
483 static void operator delete(
484 void *ptr, std::align_val_t al, int,
const char *, int)
485 {
return operator delete(ptr, al); }
500#define QUANTIZED_TIME(time, rate) (floor(((double)(time) * (rate)) + 0.5) / (rate))
502#define DB_TO_LINEAR(x) (pow(10.0, (x) / 20.0))
503#define LINEAR_TO_DB(x) (20.0 * log10(x))
505#define MAX_AUDIO (1. - 1./(1<<15))
507#include <type_traits>
512template <
typename Visitor,
typename Variant>
514 using Var = std::remove_reference_t<Variant>;
515 using Alt = std::variant_alternative_t<0, Var>;
516 using QAlt = std::conditional_t<
517 std::is_const_v<Var>,
const Alt,
Alt >;
518 using Arg = std::conditional_t<std::is_lvalue_reference_v<Variant>,
519 std::add_lvalue_reference_t<QAlt>, std::add_rvalue_reference_t<QAlt>
522 using type =
decltype( std::invoke(
523 std::forward<Visitor>( std::declval<Visitor>() ),
524 std::declval<Arg>() ) );
528template <
typename Visitor,
typename Variant>
534 throw std::invalid_argument{
"Bad variant"};
538template <
size_t Index,
size_t... Indices,
typename Visitor,
typename Variant>
543 if (
const auto pValue = std::get_if<Index>(&var)) {
544 if constexpr (std::is_lvalue_reference_v<Variant>)
545 return std::invoke( std::forward<Visitor>(vis), (*pValue) );
547 return std::invoke( std::forward<Visitor>(vis), std::move(*pValue) );
551 std::forward<Visitor>(vis), std::forward<Variant>(var));
555template <
size_t... Indices,
typename Visitor,
typename Variant>
556auto VisitHelper(std::index_sequence<Indices...>, Visitor &&vis, Variant &&var)
560 std::forward<Visitor>(vis), std::forward<Variant>(var) );
569template <
typename Visitor,
typename Variant>
570auto Visit(Visitor &&vis, Variant &&var)
572 constexpr auto size = std::variant_size_v<std::remove_reference_t<Variant>>;
573 return VisitHelper( std::make_index_sequence<size>{},
574 std::forward<Visitor>(vis), std::forward<Variant>(var) );
ValueRestorer< T > valueRestorer(T &var)
inline functions provide convenient parameter type deduction
struct UTILITY_API alignas(64) NonInterferingBase
Non-template helper for class template NonInterfering.
auto Visit(Visitor &&vis, Variant &&var)
Mimic some of std::visit, for the case of one visitor only.
std::unique_ptr< Character[], freer > MallocString
Container transform_range(Iterator first, Iterator last, Function &&fn)
IteratorRange< Iterator > make_iterator_range(const Iterator &i1, const Iterator &i2)
auto VisitHelper(Visitor &&, Variant &&) -> typename VisitHelperReturn< Visitor, Variant >::type
Help to define Visit() below.
std::unique_ptr< T, Destroyer< T > > Destroy_ptr
a convenience for using Destroyer
OutContainer transform_container(InContainer &inContainer, Function &&fn)
std::unique_ptr< T, freer > MallocPtr
Memory.h template class for making an array of float, bool, etc.
ArrayOf(const ArrayOf &)=delete
ArrayOf & operator=(ArrayOf &&that)
void reinit(Integral count, bool initialize=false)
ArrayOf(Integral count, bool initialize=false)
memory.h template class for making an array of arrays.
void reinit(Integral count)
ArraysOf(Integral1 N, Integral2 M, bool initialize=false)
ArraysOf(const ArraysOf &)=delete
ArraysOf & operator=(ArraysOf &&that)
void reinit(Integral1 countN, Integral2 countM, bool initialize=false)
void reinit(Integral count, bool initialize)
Set a variable temporarily in a scope.
ValueRestorer(T &var, const T &newValue)
ValueRestorer & operator=(ValueRestorer &&that)
ValueRestorer(ValueRestorer &&that)
A deleter class to supply the second template parameter of unique_ptr for classes like wxWindow that ...
void operator()(T *p) const
"finally" as in The C++ Programming Language, 4th ed., p. 358 Useful for defining ad-hoc RAII actions...
const T && operator()(T &&v) const
A convenience for use with range-for.
R accumulate(R init, Binary binary_op, R2(C ::*pmf)() const) const
bool contains(const T &t) const
R sum(R2(C ::*pmf)() const) const
R sum(Unary unary_op={}) const
R accumulate(R init, Binary binary_op={}, Unary unary_op={}) const
bool all_of(const F &f) const
std::reverse_iterator< Iterator > reverse_iterator
iterator find_if(const F &f) const
iterator find(const T &t) const
IteratorRange(Iterator &&a, Iterator &&b)
long index(const T &t) const
R max(Unary unary_op={}) const
IteratorRange< reverse_iterator > reversal() const
R min(R2(C ::*pmf)() const) const
bool any_of(const F &f) const
long index_if(const F &f) const
reverse_iterator rend() const
bool none_of(const F &f) const
R min(Unary unary_op={}) const
IteratorRange(const Iterator &a, const Iterator &b)
reverse_iterator rbegin() const
R max(R2(C ::*pmf)() const) const
Structure used by ValueRestorer.
void operator()(T *p) const
A convenience for defining iterators that return rvalue types, so that they cooperate correctly with ...
ptrdiff_t difference_type
Category iterator_category
Help to define Visit() below.
std::conditional_t< std::is_const_v< Var >, const Alt, Alt > QAlt
decltype(std::invoke(std::forward< Visitor >(std::declval< Visitor >()), std::declval< Arg >())) type
std::remove_reference_t< Variant > Var
std::conditional_t< std::is_lvalue_reference_v< Variant >, std::add_lvalue_reference_t< QAlt >, std::add_rvalue_reference_t< QAlt > > Arg
std::variant_alternative_t< 0, Var > Alt
void operator()(void *p) const