/src/mozilla-central/dom/media/webaudio/AlignedTArray.h

Source (jump to first uncovered line)
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef AlignedTArray_h__
#define AlignedTArray_h__

#include "mozilla/Alignment.h"
#include "nsTArray.h"

/**
 * E: element type, must be a POD type.
 * N: N bytes alignment for the first element, defaults to 32
 * S: S bytes of inline storage
  */
template <typename E, int S, int N = 32>
class AlignedAutoTArray : private AutoTArray<E, S + N>
{
  static_assert((N & (N-1)) == 0, "N must be power of 2");
  typedef AutoTArray<E, S + N> base_type;
public:
  typedef E                                          elem_type;
  typedef typename base_type::size_type              size_type;
  typedef typename base_type::index_type             index_type;

  AlignedAutoTArray() {}
  explicit AlignedAutoTArray(size_type capacity) : base_type(capacity + sExtra) {}
  elem_type* Elements() { return getAligned(base_type::Elements()); }
  const elem_type* Elements() const { return getAligned(base_type::Elements()); }
  elem_type& operator[](index_type i) { return Elements()[i];}
  const elem_type& operator[](index_type i) const { return Elements()[i]; }

  void SetLength(size_type newLen)
  {
    base_type::SetLength(newLen + sExtra);
  }

  MOZ_MUST_USE
  bool SetLength(size_type newLen, const mozilla::fallible_t&)
  {
    return base_type::SetLength(newLen + sExtra, mozilla::fallible);
  }

  size_type Length() const {
    return base_type::Length() <= sExtra ? 0 : base_type::Length() - sExtra;
  }

  using base_type::ShallowSizeOfExcludingThis;
  using base_type::ShallowSizeOfIncludingThis;

private:
  AlignedAutoTArray(const AlignedAutoTArray& other) = delete;
  void operator=(const AlignedAutoTArray& other) = delete;

  static const size_type sPadding = N <= MOZ_ALIGNOF(E) ? 0 : N - MOZ_ALIGNOF(E);
  static const size_type sExtra = (sPadding + sizeof(E) - 1) / sizeof(E);

  template <typename U>
  static U* getAligned(U* p)
  {
    return reinterpret_cast<U*>(((uintptr_t)p + N - 1) & ~(N-1));
  }
};

/**
 * E: element type, must be a POD type.
 * N: N bytes alignment for the first element, defaults to 32
  */
template <typename E, int N = 32>
class AlignedTArray : private nsTArray_Impl<E, nsTArrayInfallibleAllocator>
{
  static_assert((N & (N-1)) == 0, "N must be power of 2");
  typedef nsTArray_Impl<E, nsTArrayInfallibleAllocator> base_type;
public:
  typedef E                                          elem_type;
  typedef typename base_type::size_type              size_type;
  typedef typename base_type::index_type             index_type;

  AlignedTArray() {}
  explicit AlignedTArray(size_type capacity) : base_type(capacity + sExtra) {}
  elem_type* Elements() { return getAligned(base_type::Elements()); }
  const elem_type* Elements() const { return getAligned(base_type::Elements()); }
  elem_type& operator[](index_type i) { return Elements()[i];}
  const elem_type& operator[](index_type i) const { return Elements()[i]; }

  void SetLength(size_type newLen)
  {
    base_type::SetLength(newLen + sExtra);
  }

  MOZ_MUST_USE
  bool SetLength(size_type newLen, const mozilla::fallible_t&)
  {
    return base_type::SetLength(newLen + sExtra, mozilla::fallible);
  }

  size_type Length() const {
    return base_type::Length() <= sExtra ? 0 : base_type::Length() - sExtra;
  }

  using base_type::ShallowSizeOfExcludingThis;
  using base_type::ShallowSizeOfIncludingThis;

private:
  AlignedTArray(const AlignedTArray& other) = delete;
  void operator=(const AlignedTArray& other) = delete;

  static const size_type sPadding = N <= MOZ_ALIGNOF(E) ? 0 : N - MOZ_ALIGNOF(E);
  static const size_type sExtra = (sPadding + sizeof(E) - 1) / sizeof(E);

  template <typename U>
  static U* getAligned(U* p)
  {
    return reinterpret_cast<U*>(((uintptr_t)p + N - 1) & ~(N-1));
  }
};


#endif // AlignedTArray_h__

Line	Count	Source (jump to first uncovered line)
1		/* -- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -- */
2		/* vim:set ts=2 sw=2 sts=2 et cindent: */
3		/* This Source Code Form is subject to the terms of the Mozilla Public
4		* License, v. 2.0. If a copy of the MPL was not distributed with this
5		* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7		#ifndef AlignedTArray_h__
8		#define AlignedTArray_h__
9
10		#include "mozilla/Alignment.h"
11		#include "nsTArray.h"
12
13		/**
14		* E: element type, must be a POD type.
15		* N: N bytes alignment for the first element, defaults to 32
16		* S: S bytes of inline storage
17		*/
18		template <typename E, int S, int N = 32>
19		class AlignedAutoTArray : private AutoTArray<E, S + N>
20		{
21		static_assert((N & (N-1)) == 0, "N must be power of 2");
22		typedef AutoTArray<E, S + N> base_type;
23		public:
24		typedef E elem_type;
25		typedef typename base_type::size_type size_type;
26		typedef typename base_type::index_type index_type;
27
28	0	AlignedAutoTArray() {}
29		explicit AlignedAutoTArray(size_type capacity) : base_type(capacity + sExtra) {}
30	0	elem_type* Elements() { return getAligned(base_type::Elements()); }
31		const elem_type* Elements() const { return getAligned(base_type::Elements()); }
32	0	elem_type& operator[](index_type i) { return Elements()[i];}
33		const elem_type& operator[](index_type i) const { return Elements()[i]; }
34
35		void SetLength(size_type newLen)
36	0	{
37	0	base_type::SetLength(newLen + sExtra);
38	0	}
39
40		MOZ_MUST_USE
41		bool SetLength(size_type newLen, const mozilla::fallible_t&)
42		{
43		return base_type::SetLength(newLen + sExtra, mozilla::fallible);
44		}
45
46		size_type Length() const {
47		return base_type::Length() <= sExtra ? 0 : base_type::Length() - sExtra;
48		}
49
50		using base_type::ShallowSizeOfExcludingThis;
51		using base_type::ShallowSizeOfIncludingThis;
52
53		private:
54		AlignedAutoTArray(const AlignedAutoTArray& other) = delete;
55		void operator=(const AlignedAutoTArray& other) = delete;
56
57		static const size_type sPadding = N <= MOZ_ALIGNOF(E) ? 0 : N - MOZ_ALIGNOF(E);
58		static const size_type sExtra = (sPadding + sizeof(E) - 1) / sizeof(E);
59
60		template <typename U>
61		static U* getAligned(U* p)
62	0	{
63	0	return reinterpret_cast<U*>(((uintptr_t)p + N - 1) & ~(N-1));
64	0	}
65		};
66
67		/**
68		* E: element type, must be a POD type.
69		* N: N bytes alignment for the first element, defaults to 32
70		*/
71		template <typename E, int N = 32>
72		class AlignedTArray : private nsTArray_Impl<E, nsTArrayInfallibleAllocator>
73		{
74		static_assert((N & (N-1)) == 0, "N must be power of 2");
75		typedef nsTArray_Impl<E, nsTArrayInfallibleAllocator> base_type;
76		public:
77		typedef E elem_type;
78		typedef typename base_type::size_type size_type;
79		typedef typename base_type::index_type index_type;
80
81	0	AlignedTArray() {} Unexecuted instantiation: AlignedTArray<mozilla::FFTBlock::ComplexU, 32>::AlignedTArray() Unexecuted instantiation: AlignedTArray<float, 32>::AlignedTArray() Unexecuted instantiation: AlignedTArray<float, 16>::AlignedTArray()
82	0	explicit AlignedTArray(size_type capacity) : base_type(capacity + sExtra) {}
83	0	elem_type* Elements() { return getAligned(base_type::Elements()); } Unexecuted instantiation: AlignedTArray<mozilla::FFTBlock::ComplexU, 32>::Elements() Unexecuted instantiation: AlignedTArray<float, 32>::Elements() Unexecuted instantiation: AlignedTArray<float, 16>::Elements()
84	0	const elem_type* Elements() const { return getAligned(base_type::Elements()); }
85	0	elem_type& operator[](index_type i) { return Elements()[i];} Unexecuted instantiation: AlignedTArray<mozilla::FFTBlock::ComplexU, 32>::operator[](unsigned long) Unexecuted instantiation: AlignedTArray<float, 32>::operator[](unsigned long)
86	0	const elem_type& operator[](index_type i) const { return Elements()[i]; }
87
88		void SetLength(size_type newLen)
89	0	{
90	0	base_type::SetLength(newLen + sExtra);
91	0	} Unexecuted instantiation: AlignedTArray<float, 32>::SetLength(unsigned long) Unexecuted instantiation: AlignedTArray<mozilla::FFTBlock::ComplexU, 32>::SetLength(unsigned long) Unexecuted instantiation: AlignedTArray<float, 16>::SetLength(unsigned long)
92
93		MOZ_MUST_USE
94		bool SetLength(size_type newLen, const mozilla::fallible_t&)
95	0	{
96	0	return base_type::SetLength(newLen + sExtra, mozilla::fallible);
97	0	}
98
99	0	size_type Length() const {
100	0	return base_type::Length() <= sExtra ? 0 : base_type::Length() - sExtra;
101	0	} Unexecuted instantiation: AlignedTArray<float, 32>::Length() const Unexecuted instantiation: AlignedTArray<float, 16>::Length() const
102
103		using base_type::ShallowSizeOfExcludingThis;
104		using base_type::ShallowSizeOfIncludingThis;
105
106		private:
107		AlignedTArray(const AlignedTArray& other) = delete;
108		void operator=(const AlignedTArray& other) = delete;
109
110		static const size_type sPadding = N <= MOZ_ALIGNOF(E) ? 0 : N - MOZ_ALIGNOF(E);
111		static const size_type sExtra = (sPadding + sizeof(E) - 1) / sizeof(E);
112
113		template <typename U>
114		static U* getAligned(U* p)
115	0	{
116	0	return reinterpret_cast<U*>(((uintptr_t)p + N - 1) & ~(N-1));
117	0	} Unexecuted instantiation: mozilla::FFTBlock::ComplexU* AlignedTArray<mozilla::FFTBlock::ComplexU, 32>::getAligned<mozilla::FFTBlock::ComplexU>(mozilla::FFTBlock::ComplexU) Unexecuted instantiation: mozilla::FFTBlock::ComplexU const AlignedTArray<mozilla::FFTBlock::ComplexU, 32>::getAligned<mozilla::FFTBlock::ComplexU const>(mozilla::FFTBlock::ComplexU const) Unexecuted instantiation: float AlignedTArray<float, 32>::getAligned<float>(float) Unexecuted instantiation: float AlignedTArray<float, 16>::getAligned<float>(float*)
118		};
119
120
121		#endif // AlignedTArray_h__

Coverage Report

Created: 2018-09-25 14:53