Lines Matching defs:value
819 static constexpr T value = Value;
879 IsSame<T, float>::value ||
880 IsSame<T, double>::value ||
881 IsSame<T, long double>::value>
992 IsLvalueReference<T>::value || IsRvalueReference<T>::value>
997 : IntegralConstant<bool, IsIntegral<T>::value || IsFloatingPoint<T>::value>
1017 : IntegralConstant<bool, IsArithmetic<T>::value || IsEnum<T>::value ||
1018 IsPointer<T>::value || IsMemberPointer<T>::value>
1062 : IntegralConstant<bool, IsClass<T>::value && __is_empty(T)>
1075 bool = IsFloatingPoint<T>::value,
1076 bool = IsIntegral<T>::value,
1102 bool = IsFloatingPoint<T>::value,
1103 bool = IsIntegral<T>::value,
1115 (IsSame<NoCV, bool>::value || bool(NoCV(1) < NoCV(-1)))>
1188 : IntegralConstant<bool, detail::BaseOfTester<Base, Derived>::value>
1207 static const bool value =
1215 : IntegralConstant<bool, detail::ConvertibleTester<From, To>::value>
1220 : IntegralConstant<bool, IsVoid<B>::value>
1225 : IntegralConstant<bool, IsVoid<A>::value>
1288 template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
1312 template<typename T, Voidness V = IsVoid<T>::value ? TIsVoid : TIsNotVoid>
1372 bool IsSignedIntegerType = IsSigned<CVRemoved>::value &&
1373 !IsSame<char, CVRemoved>::value>
1384 : WithCV<IsConst<T>::value, IsVolatile<T>::value,
1392 : EnableIf<IsIntegral<T>::value &&
1393 !IsSame<bool, typename RemoveCV<T>::Type>::value,
1419 bool IsUnsignedIntegerType = IsUnsigned<CVRemoved>::value &&
1420 !IsSame<char, CVRemoved>::value>
1431 : WithCV<IsConst<T>::value, IsVolatile<T>::value,
1439 : EnableIf<IsIntegral<T>::value &&
1440 !IsSame<bool, typename RemoveCV<T>::Type>::value,
1523 bool IsArray = IsArray<U>::value,
1524 bool IsFunction = IsFunction<U>::value>
1632 static_assert(IsIntegral<IntegerType>::value,
1635 static const size_t value = 8 * sizeof(IntegerType) - 1;
1647 static_assert(IsIntegral<IntegerType>::value,
1651 static const size_t PosOfSignBit = PositionOfSignBit<IntegerType>::value;
1660 static const IntegerType value =
1661 IsSigned<IntegerType>::value
1674 static_assert(IsIntegral<IntegerType>::value,
1680 static const IntegerType value = ~MinValue<IntegerType>::value;
1753 T value;
1756 ServoUnsafeCell() : value() {};
1761 ServoUnsafeCell<T> value;
1762 T Get() const { return value.value; }
1763 void Set(T arg) { value.value = arg; }
1764 ServoCell() : value() {};
2936 static constexpr _Tp value = __v;
2939 constexpr operator value_type() const { return value; }
2944 constexpr value_type operator()() const { return value; }
2949 constexpr _Tp integral_constant<_Tp, __v>::value;
2978 : public conditional<_B1::value, _B1, _B2>::type
2983 : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
3001 : public conditional<_B1::value, _B2, _B1>::type
3006 : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
3011 : public integral_constant<bool, !_Pp::value>
3193 : public integral_constant<bool, !is_function<_Tp>::value> { };
3208 : public integral_constant<bool, is_function<_Tp>::value> { };
3400 : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
3512 bool = is_arithmetic<_Tp>::value>
3554 : public integral_constant<bool, (extent<_Tp>::value > 0)>
3586 is_function<_Tp>>::value,
3587 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
3634 is_function<_Tp>>::value,
3635 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
3680 template<typename _Tp, bool = is_array<_Tp>::value>
3732 _From, _To>::value)>
3774 is_function<_From>>>::value>
3792 static constexpr bool value = type::value;
3802 is_rvalue_reference<_To>>::value>
3817 static constexpr bool value = type::value;
3841 : public conditional<is_reference<_Tp>::value,
3903 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
3921 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
3944 template<typename _Tp, bool = is_array<_Tp>::value>
3989 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
4007 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
4047 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
4065 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
4095 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
4113 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
4260 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
4264 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
4275 _Uint - 1>::value>
4282 _Uint - 1>::value>
4305 is_array<_To>>::value>
4426 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
4440 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
4491 bool _IsConst = is_const<_Qualified>::value,
4492 bool _IsVol = is_volatile<_Qualified>::value>
4536 bool _IsInt = is_integral<_Tp>::value,
4537 bool _IsEnum = is_enum<_Tp>::value>
4625 bool _IsInt = is_integral<_Tp>::value,
4626 bool _IsEnum = is_enum<_Tp>::value>
4727 is_void<_Tp>>::value>
4811 bool _IsArray = is_array<_Up>::value,
4812 bool _IsFunction = is_function<_Up>::value>
4874 using _Require = typename enable_if<__and_<_Cond...>::value>::type;
5080 is_base_of<_Class, _Argval>>::value,
5096 is_base_of<_Class, _Argval>>::value,
5200 >::value,
5203 >::value,
5287 is_move_assignable<_Tp>>::value>::type
5290 is_nothrow_move_assignable<_Tp>>::value);
5294 typename enable_if<__is_swappable<_Tp>::value>::type
5296 noexcept(__is_nothrow_swappable<_Tp>::value);
5370 static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
5393 conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
5423 is_move_assignable<_Tp>>::value>::type
5426 is_nothrow_move_assignable<_Tp>>::value)
5446 typename enable_if<__is_swappable<_Tp>::value>::type
5448 noexcept(__is_nothrow_swappable<_Tp>::value)
5542 static_assert(_CopyConstructible::value,
5554 is_convertible<_Tp*, nested_exception*>>>::value
7346 static constexpr size_t value =
7347 Size < Min<Rest...>::value
7349 : Min<Rest...>::value;
7355 static constexpr size_t value = Size;
7361 static constexpr size_t value =
7362 Size > Max<Rest...>::value
7364 : Max<Rest...>::value;
7370 static constexpr size_t value = Size;
7377 static const size_t value = 1 + FloorLog2<I / 2>::value;
7380 template<> struct FloorLog2<1> { static const size_t value = 0; };
7386 static const size_t value = FloorLog2<2 * I - 1>::value;
7393 static const size_t value = size_t(1) << CeilingLog2<I>::value;
7398 static const size_t value = 1;
7405 static const size_t value = sizeof(T) * 8;
7420 0 / size_t(N < BitSize<size_t>::value);
7421 static const size_t value = (size_t(1) << N) - 1 + checkPrecondition;
7424 struct NBitMask<BitSize<size_t>::value>
7426 static const size_t value = size_t(-1);
7436 static const size_t value =
7437 ~NBitMask<BitSize<size_t>::value - CeilingLog2<N>::value>::value;
7440 template<> struct MulOverflowMask<1> { static const size_t value = 0; };
7608 if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
7623 if (aNewSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
10569 static_assert(!IsArray<ValueT>::value,
10572 static_assert(!IsFunction<ValueT>::value,
10575 static_assert(!IsFloatingPoint<ValueT>::value,
10615 static_assert(!IsLvalueReference<T>::value,
11303 IsEmpty<A>::value ? detail::AsBase : detail::AsMember,
11305 IsEmpty<B>::value && !IsBaseOf<A, B>::value && !IsBaseOf<B, A>::value
11494 template <class T, class D, bool = HasPointerType<D>::value>
11538 static_assert(!IsPointer<D>::value, "must provide a deleter instance");
11539 static_assert(!IsReference<D>::value, "must provide a deleter instance");
11548 static_assert(!IsPointer<D>::value, "must provide a deleter instance");
11549 static_assert(!IsReference<D>::value, "must provide a deleter instance");
11553 typename Conditional<IsReference<D>::value,
11563 static_assert(!IsReference<D>::value,
11575 static_assert(!IsPointer<D>::value, "must provide a deleter instance");
11576 static_assert(!IsReference<D>::value, "must provide a deleter instance");
11583 Pointer>::value &&
11584 !IsArray<U>::value &&
11585 (IsReference<D>::value
11586 ? IsSame<D, E>::value
11587 : IsConvertible<E, D>::value),
11606 Pointer>::value,
11608 static_assert(!IsArray<U>::value,
11683 static_assert(!IsPointer<D>::value, "must provide a deleter instance");
11684 static_assert(!IsReference<D>::value, "must provide a deleter instance");
11693 static_assert(!IsPointer<D>::value, "must provide a deleter instance");
11694 static_assert(!IsReference<D>::value, "must provide a deleter instance");
11704 typename EnableIf<IsPointer<U>::value &&
11705 IsConvertible<U, Pointer>::value,
11710 typename Conditional<IsReference<D>::value,
11724 static_assert(!IsReference<D>::value,
11731 typename EnableIf<IsPointer<U>::value &&
11732 IsConvertible<U, Pointer>::value,
11744 static_assert(!IsPointer<D>::value, "must provide a deleter instance");
11745 static_assert(!IsReference<D>::value, "must provide a deleter instance");
11813 typename EnableIf<mozilla::IsConvertible<U*, T*>::value,
12154 input_iterator_tag>::value>::type;
12854 = typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
12894 static_assert(!is_same<element_type, __undefined>::value,
12896 static_assert(!is_same<rebind<element_type>, __undefined>::value,
13675 typedef typename conditional<is_reference<__base_ref>::value,
13862 <typename iterator_traits<_Iterator>::value_type>::value,
13871 = typename conditional<__move_if_noexcept_cond<_Tp>::value,
14605 is_constructible<_T2, const _U2&>>::value;
14612 is_convertible<const _U2&, _T2>>::value;
14619 is_constructible<_T2, _U2&&>>::value;
14626 is_convertible<_U2&&, _T2>>::value;
14640 >::value;
14654 >::value;
14705 ::value, bool>::type = true>
14719 ::value, bool>::type = false>
14744 using _PCCFP = _PCC<!is_same<_T1, _U1>::value
14745 || !is_same<_T2, _U2>::value,
14843 is_copy_assignable<_T2>>::value,
14854 is_copy_assignable<_T2>>>::value,
14860 is_move_assignable<_T2>>::value,
14863 is_nothrow_move_assignable<_T2>>::value)
14872 is_assignable<_T2&, const _U2&>>::value,
14883 is_assignable<_T2&, _U2&&>>::value,
14894 noexcept(__is_nothrow_swappable<_T1>::value
14895 && __is_nothrow_swappable<_T2>::value)
15435 static_assert( __assignable::type::value, "type is not assignable" );
15602 static_assert( __assignable::type::value, "type is not assignable" );
19077 is_nothrow_move_constructible<typename _Tp::value_type>>::value>
20168 typename _Operation::first_argument_type value;
20173 : op(__x), value(__y) { }
20177 { return op(value, __x); }
20183 { return op(value, __x); }
20203 typename _Operation::second_argument_type value;
20208 : op(__x), value(__y) { }
20212 { return op(__x, value); }
20218 { return op(__x, value); }
20669 static_assert(!is_same<rebind_alloc<value_type>, __undefined>::value,
21009 static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
21018 static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
21029 { return _Base_type::propagate_on_container_copy_assignment::value; }
21032 { return _Base_type::propagate_on_container_move_assignment::value; }
21035 { return _Base_type::propagate_on_container_swap::value; }
21038 { return _Base_type::is_always_equal::value; }
21361 noexcept(is_nothrow_default_constructible<_Alloc>::value)
23329 template<typename _Tp, bool = is_enum<_Tp>::value>
25704 enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
25721 typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
25727 value() const noexcept { return _M_value; }
25738 { return category().message(value()); }
25761 && __lhs.value() < __rhs.value()));
25767 { return (__os << __e.category().name() << ':' << __e.value()); }
25782 enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
25796 <_ErrorConditionEnum>::value, error_condition&>::type
25806 value() const noexcept { return _M_value; }
25814 { return category().message(value()); }
25836 && __lhs.value() < __rhs.value()));
25843 && __lhs.value() == __rhs.value()); }
25848 return (__lhs.category().equivalent(__lhs.value(), __rhs)
25849 || __rhs.category().equivalent(__lhs, __rhs.value()));
25855 return (__rhs.category().equivalent(__rhs.value(), __lhs)
25856 || __lhs.category().equivalent(__rhs, __lhs.value()));
25864 && __lhs.value() == __rhs.value());
36045 inline typename mozilla::EnableIf<detail::AllowDeprecatedAbs<T>::value, T>::Type
36313 static_assert(IsUnsigned<T>::value, "Rotates require unsigned values");
36330 static_assert(IsUnsigned<T>::value, "Rotates require unsigned values");
36342 static_assert(IsUnsigned<T>::value,
36351 static_assert(IsIntegral<T>::value,
36666 FromSignedness = IsSigned<From>::value ? FromIsSigned : FromIsUnsigned,
36667 ToSignedness = IsSigned<To>::value ? ToIsSigned : ToIsUnsigned>
36793 bool TypesAreIntegral = IsIntegral<From>::value &&
36794 IsIntegral<To>::value>
36914 : integral_constant<size_t, tuple_size<_Tp>::value> { };
36918 : integral_constant<size_t, tuple_size<_Tp>::value> { };
36922 : integral_constant<size_t, tuple_size<_Tp>::value> { };
39906 static_assert(std::is_integral<_IntType>::value,
44050 noexcept(__is_nothrow_swappable<_Tp>::value)
44291 constexpr const size_t dynamic_extent = mozilla::MaxValue<size_t>::value;
44360 : public mozilla::IntegralConstant<bool, mozilla::IsConvertible<From (*)[], To (*)[]>::value>
44612 (Dependent || Extent == 0 || Extent == mozilla::MaxValue<size_t>::value)>>
44706 !span_details::is_span<Container>::value &&
44707 !span_details::is_std_array<Container>::value &&
44708 mozilla::IsConvertible<typename Container::pointer, pointer>::value &&
44710 decltype(mozilla::DeclVal<Container>().data())>::value>>
44722 mozilla::IsConst<element_type>::value &&
44723 !span_details::is_span<Container>::value &&
44724 mozilla::IsConvertible<typename Container::pointer, pointer>::value &&
44726 decltype(mozilla::DeclVal<Container>().data())>::value>>
44749 span_details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
44751 element_type>::value>>
44765 span_details::is_allowed_extent_conversion<OtherExtent, Extent>::value &&
44767 element_type>::value>>
44979 do { static_assert(mozilla::detail::AssertionConditionType<decltype((!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue<size_t>::value))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!((!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue<size_t>::value)))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "(!elements && ExtentType::size() == 0) || (elements && ExtentType::size() != mozilla::MaxValue<size_t>::value)" ")"); do { *((volatile int*) __null) = 833; ::abort(); } while (0); } } while (0);
45070 span_details::calculate_byte_size<ElementType, Extent>::value>
45081 class = span_details::enable_if_t<!mozilla::IsConst<ElementType>::value>>
45082 Span<uint8_t, span_details::calculate_byte_size<ElementType, Extent>::value>
45847 typename = EnableIf<!IsVoid<AlignType>::value>>
45870 inline typename EnableIf<IsSame<T, U>::value ||
45871 IsBaseOf<T, U>::value ||
45872 IsVoid<T>::value,
46678 static constexpr bool value =
46679 IsSame<First, Second>::value ||
46680 FirstTypeIsInRest<First, Rest...>::value;
46692 static constexpr bool value =
46693 !FirstTypeIsInRest<First, Rest...>::value &&
46694 TypesAreDistinct<Rest...>::value;
46817 static_assert(mozilla::IsSame<T, U>::value,
46861 return TagHelper<Tag, N, T, U, Next, IsSame<T, U>::value>::tag();
46953 static_assert(detail::TypesAreDistinct<Ts...>::value,
46959 static constexpr size_t RawDataAlignment = tl::Max<alignof(Ts)...>::value;
46960 static constexpr size_t RawDataSize = tl::Max<sizeof(Ts)...>::value;
47055 static_assert(detail::IsVariant<T, Ts...>::value,
47082 static_assert(detail::IsVariant<T, Ts...>::value,
47091 static_assert(detail::IsVariant<T, Ts...>::value,
47105 static_assert(detail::IsVariant<T, Ts...>::value,
47268 static const bool value = sizeof(Impl) <= sizeof(uintptr_t);
47306 static const bool value = false;
47313 static const bool value = true;
47319 template <typename T> struct HasFreeLSB { static const bool value = false; };
47325 static const bool value = (mozilla::AlignmentFinder<T>::alignment & 1) == 0;
47331 static const bool value = HasFreeLSB<T*>::value;
47339 static const PackingStrategy value =
47340 (IsEmpty<V>::value && UnusedZero<E>::value)
47342 : (detail::HasFreeLSB<V>::value && detail::HasFreeLSB<E>::value)
47344 : (IsDefaultConstructible<V>::value && IsDefaultConstructible<E>::value &&
47345 IsPackableVariant<V, E>::value)
47349 using Type = detail::ResultImplementation<V, E, value>;
47386 static_assert(mozilla::IsConvertible<E2, E>::value,
47421 detail::IsResult<decltype((*((F*) nullptr))(*((V*) nullptr)))>::value
47930 static ptrdiff_t GetTag(const Value& value) { return VALVECTOR; }
50225 class Atomic<T, Order, typename EnableIf<IsIntegral<T>::value &&
50226 !IsSame<T, bool>::value>::Type>
50297 class Atomic<T, Order, typename EnableIf<IsEnum<T>::value>::Type>
50595 return (numElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) == 0;
50608 return (numExtra & mozilla::tl::MulOverflowMask<sizeof(Extra)>::value) == 0 &&
50716 typename mozilla::EnableIf<mozilla::IsConvertible<U*, T*>::value,
51858 static_assert(!mozilla::IsSame<T, DestinationType>::value ||
51859 mozilla::IsSame<DestinationType, nsISupports>::value,
51961 bool IsXPCOM = mozilla::IsBaseOf<nsISupports, T>::value>
52811 is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value,
52817 is_constructible<_Tp, _Args..., _Alloc>>::value, "construction with"
52827 __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;
52974 private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
52979 typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
53012 is_nothrow_move_constructible<_Inherited>>::value)
53089 is_nothrow_move_assignable<_Inherited>>::value)
53119 noexcept(__is_nothrow_swappable<_Head>::value
53131 : private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
53135 typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
53159 noexcept(is_nothrow_move_constructible<_Head>::value)
53219 noexcept(is_nothrow_move_assignable<_Head>::value)
53245 noexcept(__is_nothrow_swappable<_Head>::value)
53263 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
53269 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
53275 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
53281 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
53293 >::value;
53301 >::type>>::value;
53357 return __and_<is_default_constructible<_Elements>...>::value;
53362 ::value;
53387 _TC<is_same<_Dummy, void>::value,
53451 _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
53615 noexcept(is_nothrow_move_assignable<_Inherited>::value)
53668 ::value, bool>::type = true>
53682 ::value, bool>::type = false>
53690 _TC<is_same<_Dummy, void>::value, _T1, _T2>;
53964 noexcept(is_nothrow_move_assignable<_Inherited>::value)
54223 : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
54279 typename std::remove_reference<_Tp>::type>::value>::__type __type;
54316 enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
54633 __has_argument_type<_Tp>::value,
54634 __has_first_argument_type<_Tp>::value
54635 && __has_second_argument_type<_Tp>::value,
54818 template<typename _From, typename _To, bool = _From::value == _To::value>
54869 bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
55010 = typename enable_if<(__i < tuple_size<_Tuple>::value),
55014 bool _IsBindExp = is_bind_expression<_Arg>::value,
55015 bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
55082 _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
55086 = __tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>;
55088 ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
55307 struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
55309 struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
55538 static_assert(_Varargs::value
55539 ? sizeof...(_BoundArgs) >= _Arity::value + 1
55540 : sizeof...(_BoundArgs) == _Arity::value + 1,
55573 _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
55792 (__is_location_invariant<_Functor>::value
55921 return is_const<_Functor>::value;
56102 using _Requires = typename enable_if<_Cond::value, _Tp>::type;
56269 && !is_const<_Functor>::value)
56743 static_assert(!mozilla::IsSame<E_NoCV*, A_NoCV>::value,
58027 AssignRangeAlgorithm<mozilla::IsPod<Item>::value,
58028 mozilla::IsSame<Item, elem_type>::value>
59488 static constexpr typename Traits::Bits value =
59591 static float value() { return 1.0f / (1 << 17); }
59598 static double value() { return 1.0 / (1LL << 40); }
59606 T aEpsilon = detail::FuzzyEqualsEpsilon<T>::value())
59608 static_assert(IsFloatingPoint<T>::value, "floating point type required");
59615 T aEpsilon = detail::FuzzyEqualsEpsilon<T>::value())
59617 static_assert(IsFloatingPoint<T>::value, "floating point type required");
59942 static_assert(IsIntegral<T>::value,
60033 TimeStampValue value = mValue + aOther.mValue;
60037 if (aOther.mValue < 0 && value > mValue) {
60038 value = 0;
60040 mValue = value;
60046 TimeStampValue value = mValue - aOther.mValue;
60050 if (aOther.mValue > 0 && value > mValue) {
60051 value = 0;
60053 mValue = value;
60131 if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
60146 if (aNewSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
60467 static const bool kElemIsPod = IsPod<T>::value;
60483 static constexpr size_t value =
60484 tl::Min<MinimumInlineCapacity, kMaxInlineBytes / sizeof(T)>::value;
60490 static constexpr size_t value = 0;
60495 ComputeCapacity<MinInlineCapacity, 0>::value;
60983 tl::RoundUpPow2<(kInlineCapacity + 1) * sizeof(T)>::value;
60994 if ((__builtin_expect(!!(mLength & tl::MulOverflowMask<4 * sizeof(T)>::value), 0))) {
61013 if ((__builtin_expect(!!(newMinCap < mLength || newMinCap & tl::MulOverflowMask<2 * sizeof(T)>::value), 0)))
62487 static_assert(mozilla::IsIntegral<T>::value,
62643 p->value() = mozilla::Forward<ValueInput>(v);
62929 struct DefaultHasher<T*> : PointerHasher<T*, mozilla::tl::FloorLog2<sizeof(void*)>::value>
62938 using PtrHasher = PointerHasher<T*, mozilla::tl::FloorLog2<sizeof(void*)>::value>;
63049 const Value& value() const { return value_; }
63050 Value& value() { return value_; }
63066 : IntegralConstant<bool, IsPod<K>::value && IsPod<V>::value>
63468 static const unsigned sHashBits = mozilla::tl::BitSize<HashNumber>::value;
63943 if (mozilla::IsPod<Entry>::value) {
64365 void setTraceWeakEdges(bool value) {
64366 traceWeakEdges_ = value;
64649 template <typename T> struct IsHeapConstructibleType { static constexpr bool value = false; };
64652 template <> struct IsHeapConstructibleType<JS::Symbol*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSAtom*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSFunction*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSObject*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSScript*> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<JSString*> { static constexpr bool value = true; };
64653 template <> struct IsHeapConstructibleType<JS::Value> { static constexpr bool value = true; }; template <> struct IsHeapConstructibleType<jsid> { static constexpr bool value = true; };
64691 static_assert(js::IsHeapConstructibleType<T>::value,
64870 typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0)
64878 static_assert(mozilla::IsPointer<T>::value,
64900 typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0);
64905 typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0);
64911 typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy = 0);
65149 void set(const T& value) {
65150 ptr = value;
65217 void set(const T& value) {
65218 ptr = value;
65312 typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy)
65320 typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy)
65328 typename mozilla::EnableIf<mozilla::IsConvertible<S, T>::value, int>::Type dummy)
65447 void set(U&& value) {
65449 ptr = mozilla::Forward<U>(value);
65462 Heap<JSObject*> value;
65467 ObjectPtr() : value(nullptr) {}
65469 explicit ObjectPtr(JSObject* obj) : value(obj) {}
65477 void init(JSObject* obj) { value = obj; }
65479 JSObject* get() const { return value; }
65480 JSObject* unbarrieredGet() const { return value.unbarrieredGet(); }
65483 IncrementalPreWriteBarrier(value);
65489 IncrementalPreWriteBarrier(value);
65490 value = obj;
65496 JSObject& operator*() const { return *value; }
65497 JSObject* operator->() const { return value; }
65498 operator JSObject*() const { return value; }
65500 explicit operator bool() const { return value.unbarrieredGet(); }
65501 explicit operator bool() { return value.unbarrieredGet(); }
65624 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65625 js::detail::DefineComparisonOps<U>::value, bool>::Type
65631 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65632 js::detail::DefineComparisonOps<U>::value, bool>::Type
65640 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
65646 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
65652 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
65658 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value, bool>::Type
65667 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65668 mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
65674 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65675 mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
65681 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65682 mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
65688 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65689 mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
65697 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65698 mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
65704 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65705 mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
65711 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65712 mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
65718 typename mozilla::EnableIf<js::detail::DefineComparisonOps<T>::value &&
65719 mozilla::IsPointer<typename T::ElementType>::value, bool>::Type
65908 bool IsXPCOM = mozilla::IsBaseOf<nsISupports, T>::value>
67078 do { static_assert(mozilla::detail::AssertionConditionType<decltype(len <= mozilla::MaxValue<size_type>::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue<size_type>::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue<size_type>::value" ")"); do { *((volatile int*) __null) = 944; ::abort(); } while (0); } } while (0);
67086 if (len > mozilla::MaxValue<size_type>::value) {
67143 static_assert(mozilla::IsSame<T, never>::value,
68126 do { static_assert(mozilla::detail::AssertionConditionType<decltype(len <= mozilla::MaxValue<size_type>::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue<size_type>::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue<size_type>::value" ")"); do { *((volatile int*) __null) = 944; ::abort(); } while (0); } } while (0);
68134 if (len > mozilla::MaxValue<size_type>::value) {
68156 do { static_assert(mozilla::detail::AssertionConditionType<decltype(len <= mozilla::MaxValue<size_type>::value)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(len <= mozilla::MaxValue<size_type>::value))), 0))) { do { } while (0); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT(" "len <= mozilla::MaxValue<size_type>::value" ")"); do { *((volatile int*) __null) = 974; ::abort(); } while (0); } } while (0);
68164 if (len > mozilla::MaxValue<size_type>::value) {
68228 static_assert(mozilla::IsSame<T, never>::value,
70816 void *value;
70850 PL_HashTableAdd(PLHashTable *ht, const void *key, void *value);
70886 const void *key, void *value);
71201 static_assert(mozilla::IsBaseOf<T, U>::value,
71214 static_assert(mozilla::IsBaseOf<T, U>::value,
71316 static_assert(mozilla::IsBaseOf<T, U>::value,
71328 static_assert(mozilla::IsBaseOf<T, U>::value,
72235 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<NodeInfo>::value, "Reference-counted class " "NodeInfo" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast<void*>(this), NodeInfo::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast<void*>(this), NodeInfo::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
73522 typedef typename mozilla::Conditional<mozilla::IsSame<T, float>::value, float, double>::Type FloatType;
74015 T value;
74018 constexpr BaseCoord() : value(0) {}
74019 explicit constexpr BaseCoord(T aValue) : value(aValue) {}
74024 operator T() const { return value; }
74027 return aA.value == aB.value;
74030 return aA.value != aB.value;
74034 return Sub(aA.value + aB.value);
74037 return Sub(aA.value - aB.value);
74040 return Sub(aCoord.value * aScale);
74043 return Sub(aScale * aCoord.value);
74046 return Sub(aCoord.value / aScale);
74051 value += aCoord.value;
74055 value -= aCoord.value;
74059 value *= aScale;
74063 value /= aScale;
74072 return aA.value == aB;
74075 return aA == aB.value;
74078 return aA.value != aB;
74081 return aA != aB.value;
74084 return aA.value + aB;
74087 return aA + aB.value;
74090 return aA.value - aB;
74093 return aA - aB.value;
74097 return Sub(-value);
74140 return aA.value == aB;
74143 return aA == aB.value;
74146 return aA.value != aB;
74149 return aA != aB.value;
74155 return aA.value + aB;
74158 return aA + aB.value;
74161 return aA.value - aB;
74164 return aA - aB.value;
74167 return aCoord.value * aScale;
74170 return aScale * aCoord.value;
74173 return aCoord.value / aScale;
74186 static_assert(IsPixel<units>::value,
74198 public CoordOperatorsHelper< !IsSame<F, int32_t>::value, CoordTyped<units, F>, int32_t >,
74199 public CoordOperatorsHelper< !IsSame<F, uint32_t>::value, CoordTyped<units, F>, uint32_t >,
74200 public CoordOperatorsHelper< !IsSame<F, double>::value, CoordTyped<units, F>, double >,
74201 public CoordOperatorsHelper< !IsSame<F, float>::value, CoordTyped<units, F>, float > {
74202 static_assert(IsPixel<units>::value,
74209 explicit constexpr CoordTyped(const IntCoordTyped<units>& aCoord) : Super(F(aCoord.value)) {}
74212 this->value = floor(this->value + 0.5);
74215 this->value = int32_t(this->value);
74219 return IntCoordTyped<units>(int32_t(floor(this->value + 0.5)));
74222 return IntCoordTyped<units>(int32_t(this->value));
74495 constexpr IntParam(char val) : value(val) {}
74496 constexpr IntParam(unsigned char val) : value(val) {}
74497 constexpr IntParam(short val) : value(val) {}
74498 constexpr IntParam(unsigned short val) : value(val) {}
74499 constexpr IntParam(int val) : value(val) {}
74500 constexpr IntParam(unsigned int val) : value(val) {}
74501 constexpr IntParam(long val) : value(val) {}
74502 constexpr IntParam(unsigned long val) : value(val) {}
74503 constexpr IntParam(long long val) : value(val) {}
74504 constexpr IntParam(unsigned long long val) : value(val) {}
74506 constexpr IntParam(IntCoordTyped<Unit> val) : value(val) {}
74512 T value;
74522 static_assert(IsPixel<units>::value,
74530 constexpr IntPointTyped(ToInt aX, ToInt aY) : Super(Coord(aX.value), Coord(aY.value)) {}
74570 static_assert(IsPixel<units>::value,
74582 constexpr PointTyped(Coord aX, Coord aY) : Super(aX.value, aY.value) {}
74612 static_assert(IsPixel<units>::value,
74665 static_assert(IsPixel<units>::value,
74705 static_assert(IsPixel<units>::value,
74712 constexpr IntSizeTyped(ToInt aWidth, ToInt aHeight) : Super(aWidth.value, aHeight.value) {}
74752 static_assert(IsPixel<units>::value,
75144 typedef typename mozilla::Conditional<mozilla::IsSame<T, float>::value, float, double>::Type FloatType;
75719 static const bool value = false;
75725 static const bool value = IsSupportedPass2<IntegerType>::value;
75730 { static const bool value = true; };
75734 { static const bool value = true; };
75738 { static const bool value = true; };
75742 { static const bool value = true; };
75746 { static const bool value = true; };
75750 { static const bool value = true; };
75754 { static const bool value = true; };
75758 { static const bool value = true; };
75763 { static const bool value = true; };
75767 { static const bool value = true; };
75771 { static const bool value = true; };
75775 { static const bool value = true; };
75779 { static const bool value = true; };
75783 { static const bool value = true; };
75787 { static const bool value = true; };
75791 { static const bool value = true; };
75795 { static const bool value = true; };
75799 { static const bool value = true; };
75803 { static const bool value = true; };
75816 IsSigned<IntegerType>::value
75835 PositionOfSignBit<T>::value);
75849 bool IsTSigned = IsSigned<T>::value,
75850 bool IsUSigned = IsSigned<U>::value>
75858 static const bool value = sizeof(T) >= sizeof(U);
75864 static const bool value = sizeof(T) > sizeof(U);
75870 static const bool value = false;
75875 bool IsTSigned = IsSigned<T>::value,
75876 bool IsUSigned = IsSigned<U>::value,
75877 bool DoesTRangeContainURange = DoesRangeContainRange<T, U>::value>
75894 return aX <= MaxValue<T>::value && aX >= MinValue<T>::value;
75903 return aX <= MaxValue<T>::value;
75912 return sizeof(T) > sizeof(U) || aX <= U(MaxValue<T>::value);
75923 : aX >= 0 && aX <= U(MaxValue<T>::value);
75947 return IsSigned<T>::value
75963 return IsSigned<T>::value
75969 bool IsTSigned = IsSigned<T>::value,
75971 IsSupported<typename TwiceBiggerType<T>::Type>::value>
75990 const T max = MaxValue<T>::value;
75991 const T min = MinValue<T>::value;
76014 return aY == 0 || aX <= MaxValue<T>::value / aY;
76032 !(IsSigned<T>::value && aX == MinValue<T>::value && aY == T(-1));
76035 template<typename T, bool IsTSigned = IsSigned<T>::value>
76066 template<typename T, bool IsSigned = IsSigned<T>::value>
76087 if (!aVal.isValid() || aVal.mValue == MinValue<T>::value) {
76106 static_assert(detail::IsSupported<T>::value &&
76107 detail::IsSupported<U>::value,
76120 static_assert(detail::IsSupported<T>::value &&
76121 detail::IsSupported<U>::value,
76139 static_assert(detail::IsSupported<T>::value,
76144 T value() const
76275 static_assert(detail::IsSupported<T>::value &&
76276 detail::IsSupported<U>::value,
76452 static_assert(mozilla::IsPod<T>::value,
76476 mStorage = static_cast<uint8_t *>(calloc(1, storageByteCount.value()));
76478 mStorage = static_cast<uint8_t *>(malloc(storageByteCount.value()));
76527 return stride.value() & ~mask;
76573 typename std::enable_if<std::is_convertible<U, T>::value>::type>
76597 typename std::enable_if<std::is_convertible<U, T>::value>::type>
76626 typename std::enable_if<std::is_convertible<U, T>::value>::type>
76661 typename std::enable_if<std::is_convertible<U, T>::value>::type>
76684 T value() const
76937 Maybe<U> value;
76938 value.emplace(Forward<T>(aValue));
76939 return value;
77053 static_assert(IsPixel<units>::value,
77081 static_assert(IsPixel<units>::value,
77109 static_assert(IsPixel<units>::value,
77121 Super(aX.value, aY.value, aWidth.value, aHeight.value) {}
77221 return Some(Self(newX.value(), newY.value(), newW.value(), newH.value()));
77255 static_assert(IsPixel<units>::value,
77552 detail::CanonicalizedNaNSignificand>::value;
78470 const JS::Value& value() const { return static_cast<const Wrapper*>(this)->get(); }
78473 bool isUndefined() const { return value().isUndefined(); }
78474 bool isNull() const { return value().isNull(); }
78475 bool isBoolean() const { return value().isBoolean(); }
78476 bool isTrue() const { return value().isTrue(); }
78477 bool isFalse() const { return value().isFalse(); }
78478 bool isNumber() const { return value().isNumber(); }
78479 bool isInt32() const { return value().isInt32(); }
78480 bool isInt32(int32_t i32) const { return value().isInt32(i32); }
78481 bool isDouble() const { return value().isDouble(); }
78482 bool isString() const { return value().isString(); }
78483 bool isSymbol() const { return value().isSymbol(); }
78484 bool isObject() const { return value().isObject(); }
78485 bool isMagic() const { return value().isMagic(); }
78486 bool isMagic(JSWhyMagic why) const { return value().isMagic(why); }
78487 bool isGCThing() const { return value().isGCThing(); }
78488 bool isPrimitive() const { return value().isPrimitive(); }
78490 bool isNullOrUndefined() const { return value().isNullOrUndefined(); }
78491 bool isObjectOrNull() const { return value().isObjectOrNull(); }
78493 bool toBoolean() const { return value().toBoolean(); }
78494 double toNumber() const { return value().toNumber(); }
78495 int32_t toInt32() const { return value().toInt32(); }
78496 double toDouble() const { return value().toDouble(); }
78497 JSString* toString() const { return value().toString(); }
78498 JS::Symbol* toSymbol() const { return value().toSymbol(); }
78499 JSObject& toObject() const { return value().toObject(); }
78500 JSObject* toObjectOrNull() const { return value().toObjectOrNull(); }
78501 gc::Cell* toGCThing() const { return value().toGCThing(); }
78502 JS::TraceKind traceKind() const { return value().traceKind(); }
78503 void* toPrivate() const { return value().toPrivate(); }
78504 uint32_t toPrivateUint32() const { return value().toPrivateUint32(); }
78506 uint64_t asRawBits() const { return value().asRawBits(); }
78507 JSValueType extractNonDoubleType() const { return value().extractNonDoubleType(); }
78509 JSWhyMagic whyMagic() const { return value().whyMagic(); }
78510 uint32_t magicUint32() const { return value().magicUint32(); }
78522 JS::Value& value() { return static_cast<Wrapper*>(this)->get(); }
78525 void setNull() { value().setNull(); }
78526 void setUndefined() { value().setUndefined(); }
78527 void setInt32(int32_t i) { value().setInt32(i); }
78528 void setDouble(double d) { value().setDouble(d); }
78530 void setBoolean(bool b) { value().setBoolean(b); }
78531 void setMagic(JSWhyMagic why) { value().setMagic(why); }
78532 bool setNumber(uint32_t ui) { return value().setNumber(ui); }
78533 bool setNumber(double d) { return value().setNumber(d); }
78534 void setString(JSString* str) { this->value().setString(str); }
78535 void setSymbol(JS::Symbol* sym) { this->value().setSymbol(sym); }
78536 void setObject(JSObject& obj) { this->value().setObject(obj); }
78537 void setObjectOrNull(JSObject* arg) { this->value().setObjectOrNull(arg); }
78538 void setPrivate(void* ptr) { this->value().setPrivate(ptr); }
78539 void setPrivateUint32(uint32_t ui) { this->value().setPrivateUint32(ui); }
78540 void setPrivateGCThing(js::gc::Cell* cell) { this->value().setPrivateGCThing(cell); }
78644 static_assert(!mozilla::IsScalar<T>::value, "If you are using "
79560 const char* value;
80065 std::is_signed<typename std::underlying_type<T>::type>::value,
80067 std::is_signed<Storage>::value
80070 static_assert(std::is_enum<T>::value, "must provide an enum type");
80071 static_assert(std::is_integral<Storage>::value, "must provide an integral type");
80267 , value(aValue)
80272 typename = typename std::enable_if<std::is_enum<T>::value>::type>
80275 , value(static_cast<int16_t>(aValue))
80277 static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
80284 int16_t value;
82476 static nsIAtom* value;
84129 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsNodeInfoManager>::value, "Reference-counted class " "nsNodeInfoManager" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast<void*>(this), nsNodeInfoManager::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast<void*>(this), nsNodeInfoManager::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
88591 void SetBoolFlag(BooleanFlag name, bool value) {
88594 mBoolFlags = (mBoolFlags & ~(1 << name)) | (value << name);
92278 static_assert(mozilla::IsPointer<typename EntryType::KeyTypePointer>::value,
92949 mozilla::Maybe<DataType> value;
92951 value.emplace(mozilla::Move(ent->mData));
92954 return value;
93441 virtual nsresult SetAttribute(const nsAString & name, const nsAString & value) = 0;
94287 static_assert(IsBaseOf<RefCounted, T>::value,
94301 static_assert(IsBaseOf<AtomicRefCounted, T>::value,
94354 static_assert(IsBaseOf<SupportsWeakPtr<T>, T>::value,
94666 static_assert(mozilla::IsSame<Dest, typename Dest::Has_NS_DECL_QUERYFRAME_TARGET>::value,
95598 class = typename EnableIf<IsConvertible<U (*)[], T (*)[]>::value,
95611 class = typename EnableIf<IsConvertible<U (*)[], T (*)[]>::value,
95711 static_assert(mozilla::IsSame<WantUsedRval, IncludeUsedRval>::value ||
95712 mozilla::IsSame<WantUsedRval, NoUsedRval>::value,
96428 const JS::PropertyResult& value() const { return static_cast<const Wrapper*>(this)->get(); }
96431 bool isFound() const { return value().isFound(); }
96432 explicit operator bool() const { return bool(value()); }
96433 js::Shape* maybeShape() const { return value().maybeShape(); }
96434 js::Shape* shape() const { return value().shape(); }
96435 bool isNativeProperty() const { return value().isNativeProperty(); }
96436 bool isNonNativeProperty() const { return value().isNonNativeProperty(); }
96437 bool isDenseOrTypedArrayElement() const { return value().isDenseOrTypedArrayElement(); }
96438 js::Shape* asTaggedShape() const { return value().asTaggedShape(); }
96445 JS::PropertyResult& value() { return static_cast<Wrapper*>(this)->get(); }
96449 value().setNotFound();
96452 value().setNativeProperty(shape);
96455 value().setNonNativeProperty();
96458 value().setDenseOrTypedArrayElement();
96944 typename = typename mozilla::EnableIf<!detail::TypeIsGCThing<T>::value>::Type
98617 explicit HandleValueArray(const RootedValue& value) : length_(1), elements_(value.address()) {}
99377 JS_MarkCrossZoneIdValue(JSContext* cx, const JS::Value& value);
99699 JS_SetGCParameter(JSContext* cx, JSGCParamKey key, uint32_t value);
99814 ValueWrapper value;
99820 bool getValue(JSContext* cx, JS::MutableHandleValue value) const;
99862 inline int CheckIsInt32(int32_t value);
100269 JS::Value value;
100272 : obj(nullptr), attrs(0), getter(nullptr), setter(nullptr), value(JS::UndefinedValue())
100323 JS::HandleValue value() const {
100324 return JS::HandleValue::fromMarkedLocation(&desc().value);
100381 value().setUndefined();
100390 value().set(v);
100401 value().set(other.value);
100415 value().set(v);
100424 JS::MutableHandleValue value() {
100425 return JS::MutableHandleValue::fromMarkedLocation(&desc().value);
100430 value().set(v);
100566 JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue value,
100570 JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleObject value,
100574 JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleString value,
100578 JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, int32_t value,
100582 JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, uint32_t value,
100586 JS_DefinePropertyById(JSContext* cx, JS::HandleObject obj, JS::HandleId id, double value,
100590 JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleValue value,
100594 JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleObject value,
100598 JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, JS::HandleString value,
100602 JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, int32_t value,
100606 JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, uint32_t value,
100610 JS_DefineProperty(JSContext* cx, JS::HandleObject obj, const char* name, double value,
100624 JS::HandleValue value, unsigned attrs,
100629 JS::HandleObject value, unsigned attrs,
100634 JS::HandleString value, unsigned attrs,
100639 int32_t value, unsigned attrs,
100644 uint32_t value, unsigned attrs,
100649 double value, unsigned attrs,
100653 JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleValue value,
100657 JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleObject value,
100661 JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::HandleString value,
100665 JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, int32_t value,
100669 JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, uint32_t value,
100673 JS_DefineElement(JSContext* cx, JS::HandleObject obj, uint32_t index, double value,
100922 JS_IsArrayObject(JSContext* cx, JS::HandleValue value, bool* isArray);
101650 SetModuleHostDefinedField(JSObject* module, const JS::Value& value);
102200 JS_Stringify(JSContext* cx, JS::MutableHandleValue value, JS::HandleObject replacer,
102838 JS_SetGlobalJitCompilerOption(JSContext* cx, JSJitCompilerOption opt, uint32_t value);
105456 __attribute__ ((warn_unused_result)) virtual nsresult SetResponseHeader(const nsACString & header, const nsACString & value, bool merge) = 0;
109068 static_assert(mozilla::tl::FloorLog2<Alignment>::value ==
109069 mozilla::tl::CeilingLog2<Alignment>::value,
110865 typedef void (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);
112044 static_assert(IsPixel<units>::value, "'units' must be a coordinate system tag");
112465 return gfx::CoordTyped<dst>(aCoord.value * aScale.scale);
112470 return gfx::CoordTyped<dst>(aCoord.value / aScale.scale);
114618 nsString value;
114625 ((a.alternate == b.alternate) && (a.value < b.value));
114631 return (a.alternate == b.alternate) && (a.value == b.value);
114636 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<gfxFontFeatureValueSet>::value, "Reference-counted class " "gfxFontFeatureValueSet" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
115552 "size of the value must never be larger than a pointer");
115563 PropertyType<T> value;
115564 memcpy(&value, &aPtr, sizeof(value));
115565 return value;
116191 : IntegralConstant<bool, tl::And<IsConvertible<SourceTypes, TargetTypes>::value...>::value> { };
116251 Group<HeadT, TailT...>>::value>::Type>
116329 detail::Group<Elements...>>::value>::Type>
116386 detail::Group<A, B>>::value>::Type>
116713 static_assert(IsVoid<decltype(mFunction())>::value,
116904 static_assert(mozilla::IsBaseOf<C, class_type>::value,
116915 static_assert(mozilla::IsBaseOf<C, class_type>::value,
117101 : mozilla::Conditional<mozilla::IsConst<TWithoutPointer>::value,
117109 : mozilla::Conditional<HasRefCountMethods<TWithoutPointer>::value,
117118 : mozilla::Conditional<mozilla::IsConst<TWithoutRef>::value,
117126 : mozilla::Conditional<mozilla::IsRefcountedSmartPointer<T>::value,
117134 : mozilla::Conditional<mozilla::IsRvalueReference<T>::value,
117142 : mozilla::Conditional<mozilla::IsLvalueReference<T>::value,
117151 : mozilla::Conditional<mozilla::IsPointer<T>::value,
117160 : mozilla::Conditional<IsParameterStorageClass<T>::value,
117896 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<Calc>::value, "Reference-counted class " "Calc" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
118006 typename = typename std::enable_if<std::is_enum<T>::value>::type>
118029 typename = typename std::enable_if<std::is_enum<T>::value>::type>
118032 static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
118865 virtual void trace(JSObject* m, JS::GCCellPtr key, JS::GCCellPtr value) = 0;
119104 SetReservedOrProxyPrivateSlotWithBarrier(JSObject* obj, size_t slot, const JS::Value& value);
119107 SetReservedSlot(JSObject* obj, size_t slot, const JS::Value& value)
119111 if (sobj->slotRef(slot).isGCThing() || value.isGCThing())
119112 SetReservedOrProxyPrivateSlotWithBarrier(obj, slot, value);
119114 sobj->slotRef(slot) = value;
122963 TrySetToHTMLImageElement(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
122992 TrySetToHTMLVideoElement(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
123021 TrySetToHTMLCanvasElement(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
123050 TrySetToBlob(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
123079 TrySetToImageData(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
123108 TrySetToCanvasRenderingContext2D(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
123137 TrySetToImageBitmap(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
123166 TrySetToArrayBufferView(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
123195 TrySetToArrayBuffer(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
123569 SetValueInProxy(Value* slot, const Value& value);
123599 SetReservedOrProxyPrivateSlot(JSObject* obj, size_t slot, const Value& value)
123604 if (sobj->slotRef(slot).isGCThing() || value.isGCThing())
123605 SetReservedOrProxyPrivateSlotWithBarrier(obj, slot, value);
123607 sobj->slotRef(slot) = value;
124123 template<class T, bool isISupports = IsBaseOf<nsISupports, T>::value>
124359 PersistentRooted<T> value;
124362 : owner(owner_), value(cx, value_)
124372 BuiltThing(const BuiltThing& rhs) : owner(rhs.owner), value(rhs.value) { }
124375 owner.assertBuilt(rhs.value);
124376 value = rhs.value;
124382 return value;
124404 JS::MutableHandleValue value);
124410 bool defineProperty(JSContext* cx, const char* name, JS::HandleValue value);
124411 bool defineProperty(JSContext* cx, const char* name, JS::HandleObject value);
124412 bool defineProperty(JSContext* cx, const char* name, Object& value);
124431 return thing.value.get();
125263 virtual nsresult VariantToJS(JSContext *ctx, JSObject *scope, nsIVariant *value, JS::MutableHandleValue _retval) = 0;
125266 virtual nsresult JSToVariant(JSContext *ctx, JS::HandleValue value, nsIVariant * *_retval) = 0;
127593 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<ErrorReport>::value, "Reference-counted class " "ErrorReport" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
128211 "is currently passed by value in various places. If it is "
128787 static_assert(mozilla::IsUnsigned<ResultType>::value,
128839 static_assert(mozilla::IsSigned<ResultType>::value,
128982 const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
129035 const bool __assignable = is_copy_assignable<_ValueType>::value;
129086 const bool __assignable = is_copy_assignable<_ValueType>::value;
129387 const bool __assignable = is_copy_assignable<_ValueType>::value;
129403 const bool __assignable = is_copy_assignable<_ValueType>::value;
132299 noexcept(is_nothrow_default_constructible<_Alloc>::value)
133566 noexcept(is_nothrow_default_constructible<allocator_type>::value)
135088 enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
135214 noexcept(__is_nothrow_swappable<_Tp>::value)
135276 enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
135411 noexcept(__is_nothrow_swappable<_Tp>::value
135412 && __is_nothrow_swappable<_Compare>::value)
144046 JS::Value value;
144546 desc.value().set(v);
144555 desc.value().set(v);
148163 TrySetToElementCreationOptions(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
148192 TrySetToString(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
151802 static_assert(mozilla::IsPointer<T>::value || mozilla::IsIntegral<T>::value,
153444 UnwrapObject(JSObject* obj, U& value, prototypes::ID protoID,
153472 value = UnwrapDOMObject<T>(obj);
153482 UnwrapObject(JSObject* obj, U& value)
153484 return UnwrapObject<T>(obj, value, PrototypeID,
153778 private: template<typename V> static yes& Checkget(char (*)[sizeof(&V::get) + 1]); template<typename V> static no& Checkget(...); public: static bool const value = sizeof(Checkget<T>(nullptr)) == sizeof(yes);
153790 static bool const value = HasAddref && HasRelease;
153796 static_assert(!IsBaseOf<nsISupports, T>::value || IsRefcounted::value,
153935 static const bool value =
153936 IsBaseOf<nsGlobalWindow, T>::value || IsSame<EventTarget, T>::value;
153941 DoGetOrCreateDOMReflector(JSContext* cx, T* value,
153948 bool couldBeDOMBinding = CouldBeDOMBinding(value);
153949 JSObject* obj = value->GetWrapper();
153963 obj = value->WrapObject(cx, givenProto);
153983 return TypeNeedsOuterization<T>::value ? TryToOuterize(rval) : true;
153987 if (TypeNeedsOuterization<T>::value) {
154002 GetOrCreateDOMReflector(JSContext* cx, T* value,
154007 return DoGetOrCreateDOMReflector<T, eWrapIntoContextCompartment>(cx, value,
154016 GetOrCreateDOMReflectorNoWrap(JSContext* cx, T* value,
154021 value,
154033 T* value,
154037 static_assert(IsRefcounted<T>::value, "Don't pass owned classes in here.");
154061 if (!value->WrapObject(cx, proto, &obj)) {
154080 nsAutoPtr<T>& value,
154084 static_assert(!IsRefcounted<T>::value, "Only pass owned classes in here.");
154087 if (!value) {
154112 if (!value->WrapObject(cx, proto, &obj)) {
154116 value.forget();
154127 typename U=typename EnableIf<IsRefcounted<T>::value, T>::Type,
154128 typename V=typename EnableIf<IsSmartPtr<SmartPtr<T>>::value, T>::Type>
154131 const SmartPtr<T>& value,
154135 return WrapNewBindingNonWrapperCachedObject(cx, scope, value.get(), rval,
154141 typename U=typename EnableIf<!IsSmartPtr<T>::value, T>::Type>
154144 T& value,
154148 return WrapNewBindingNonWrapperCachedObject(cx, scope, &value, rval,
154169 T* value, JS::MutableHandle<JS::Value> rval)
154175 qsObjectHelper helper(value, GetWrapperCache(value));
154183 template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
154187 const T& value, JS::MutableHandle<JS::Value> rval)
154189 return HandleNewBindingWrappingFailure(cx, scope, value.get(), rval);
154196 static inline bool Wrap(JSContext* cx, JS::Handle<JSObject*> scope, T& value,
154199 return HandleNewBindingWrappingFailure(cx, scope, &value, rval);
154206 T& value, JS::MutableHandle<JS::Value> rval)
154208 return HandleNewBindingWrappingFailureHelper<T>::Wrap(cx, scope, value, rval);
154243 for (const EnumEntry* value = values; value->value; ++value, ++i) {
154244 if (length != value->length) {
154249 const char* val = value->value;
154509 template<typename T, bool isISupports=IsBaseOf<nsISupports, T>::value>
154675 template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
154678 static inline bool GetOrCreate(JSContext* cx, const T& value,
154682 return GetOrCreateDOMReflector(cx, value.get(), rval, givenProto);
154689 static inline bool GetOrCreate(JSContext* cx, T& value,
154693 static_assert(IsRefcounted<T>::value, "Don't pass owned classes in here.");
154694 return GetOrCreateDOMReflector(cx, &value, rval, givenProto);
154700 GetOrCreateDOMReflector(JSContext* cx, T& value,
154704 return GetOrCreateDOMReflectorHelper<T>::GetOrCreate(cx, value, givenProto,
154710 template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
154713 static inline bool GetOrCreate(JSContext* cx, const T& value,
154716 return GetOrCreateDOMReflectorNoWrap(cx, value.get(), rval);
154723 static inline bool GetOrCreate(JSContext* cx, T& value,
154726 return GetOrCreateDOMReflectorNoWrap(cx, &value, rval);
154732 GetOrCreateDOMReflectorNoWrap(JSContext* cx, T& value,
154736 GetOrCreateDOMReflectorNoWrapHelper<T>::GetOrCreate(cx, value, rval);
154749 template <class T, bool isSmartPtr=IsSmartPtr<T>::value>
154817 static_assert(IsBaseOf<nsISupports, T>::value,
154973 bool isDictionary=IsBaseOf<DictionaryBase, T>::value,
154974 bool isTypedArray=IsBaseOf<AllTypedArraysBase, T>::value,
154975 bool isOwningUnion=IsBaseOf<AllOwningUnionBase, T>::value>
155519 template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
155543 template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
155645 static_assert(IsBaseOf<NonRefcountedDOMObject, T>::value,
155664 typename Conditional<IsRefcounted<T>::value, RefPtr<T>, OwnedNative>::Type mNative;
155670 typedef typename Conditional<IsSame<T, nsISupports>::value,
155672 typename Conditional<IsRefcounted<T>::value,
155677 static_assert(IsSame<T, nsISupports>::value || !IsBaseOf<nsISupports, T>::value,
155728 bool isISupports=IsBaseOf<nsISupports, T>::value>
155760 template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
156022 class ReturnType=typename Conditional<IsRefcounted<T>::value, T*,
156037 typedef typename Conditional<IsRefcounted<T>::value,
156143 typename EnableIf<IsSame<T, bool>::value, bool>::Type
156247 typename EnableIf<IsBaseOf<nsWrapperCache, T>::value, bool>::Type
156263 typename EnableIf<IsBaseOf<AllTypedArraysBase, T>::value, bool>::Type
156283 typename EnableIf<!IsBaseOf<nsWrapperCache, T>::value &&
156284 !IsBaseOf<CallbackObject, T>::value &&
156285 IsBaseOf<nsISupports, T>::value, bool>::Type
156329 typename EnableIf<IsBaseOf<DictionaryBase, T>::value, bool>::Type
156392 typename EnableIf<IsBaseOf<AllOwningUnionBase, T>::value, bool>::Type
156404 typename EnableIf<IsPointer<T>::value, bool>::Type
156730 TrySetToExternal(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
156759 TrySetToWindowProxy(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
163028 TrySetToDouble(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
163057 TrySetToDoubleSequence(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
165997 virtual nsresult Set(const char * prop, nsISupports *value) = 0;
166470 typename = typename std::enable_if<std::is_enum<T>::value>::type>
166475 static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
166557 typename = typename std::enable_if<std::is_enum<T>::value>::type>
166561 static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
166569 typename = typename std::enable_if<std::is_enum<T>::value>::type>
166573 static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
167211 ::detail::ProxyReleaseChooser<mozilla::IsBaseOf<nsISupports, T>::value>
167320 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsMainThreadPtrHolder<T> >::value, "Reference-counted class " "nsMainThreadPtrHolder<T>" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
167452 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<URLExtraData>::value, "Reference-counted class " "URLExtraData" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
167496 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<URLValueData>::value, "Reference-counted class " "URLValueData" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
167630 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<GridTemplateAreasValue>::value, "Reference-counted class " "GridTemplateAreasValue" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
167665 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<FontFamilyListRefCnt>::value, "Reference-counted class " "FontFamilyListRefCnt" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:;
167758 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<ComplexColorValue>::value, "Reference-counted class " "ComplexColorValue" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
168209 typename = typename std::enable_if<std::is_enum<T>::value>::type>
168212 static_assert(mozilla::EnumTypeFitsWithin<T, int32_t>::value,
168387 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<Array>::value, "Reference-counted class " "Array" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
168472 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueList_heap>::value, "Reference-counted class " "nsCSSValueList_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
168504 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueSharedList>::value, "Reference-counted class " "nsCSSValueSharedList" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
168601 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSRect_heap>::value, "Reference-counted class " "nsCSSRect_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
168707 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValuePair_heap>::value, "Reference-counted class " "nsCSSValuePair_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
168798 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueTriplet_heap>::value, "Reference-counted class " "nsCSSValueTriplet_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
168875 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValuePairList_heap>::value, "Reference-counted class " "nsCSSValuePairList_heap" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
169026 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueGradient>::value, "Reference-counted class " "nsCSSValueGradient" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
169075 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueTokenStream>::value, "Reference-counted class " "nsCSSValueTokenStream" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
169139 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSValueFloatColor>::value, "Reference-counted class " "nsCSSValueFloatColor" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
170944 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<EffectCompositor>::value, "Reference-counted class " "EffectCompositor" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); nsrefcnt count = mRefCnt.incr(static_cast<void*>(this), EffectCompositor::cycleCollection::GetParticipant()); ; return count; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); nsrefcnt count = mRefCnt.decr(static_cast<void*>(this), EffectCompositor::cycleCollection::GetParticipant()); ; return count; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsCycleCollectingAutoRefCnt mRefCnt; public:
173068 public: MozExternalRefCountType AddRef(void) override { static_assert(!mozilla::IsDestructible<AnonymousCounterStyle>::value, "Reference-counted class " "AnonymousCounterStyle" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) override { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
173115 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<CounterStyleManager>::value, "Reference-counted class " "CounterStyleManager" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); ((void)0); ++mRefCnt; ; return mRefCnt; } MozExternalRefCountType Release(void) { do { } while (0); ((void)0); --mRefCnt; ; if (mRefCnt == 0) { mRefCnt = 1; delete(this); return 0; } return mRefCnt; } typedef mozilla::FalseType HasThreadSafeRefCnt; protected: nsAutoRefCnt mRefCnt; public:
173296 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsStyleGradient>::value, "Reference-counted class " "nsStyleGradient" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
173365 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsStyleImageRequest>::value, "Reference-counted class " "nsStyleImageRequest" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
174069 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsCSSShadowArray>::value, "Reference-counted class " "nsCSSShadowArray" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:
174358 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<nsStyleQuoteValues>::value, "Reference-counted class " "nsStyleQuoteValues" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
174478 void SetToInteger(uint32_t value)
174481 mInteger = value;
175326 public: MozExternalRefCountType AddRef(void) { static_assert(!mozilla::IsDestructible<StyleBasicShape>::value, "Reference-counted class " "StyleBasicShape" " should not have a public destructor. " "Make this class's destructor non-public"); do { } while (0); nsrefcnt count = ++mRefCnt; ; return (nsrefcnt) count; } MozExternalRefCountType Release(void) { do { } while (0); nsrefcnt count = --mRefCnt; ; if (count == 0) { delete (this); return 0; } return count; } typedef mozilla::TrueType HasThreadSafeRefCnt; protected: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; public:;
176351 uint8_t value = (mContextFlags & FILL_OPACITY_SOURCE_MASK) >>
176353 return nsStyleSVGOpacitySource(value);
176356 uint8_t value = (mContextFlags & STROKE_OPACITY_SOURCE_MASK) >>
176358 return nsStyleSVGOpacitySource(value);
177268 void Gecko_ResetStyleCoord(nsStyleUnit* unit, nsStyleUnion* value);
177271 void Gecko_SetStyleCoordCalcValue(nsStyleUnit* unit, nsStyleUnion* value, nsStyleCoord::CalcValue calc);
177565 RawServoDeclarationBlockStrong Servo_ParseProperty(const nsACString* property, const nsACString* value, RawGeckoURLExtraData* data);
177579 void Servo_AnimationValueMap_Push(RawServoAnimationValueMapBorrowed, nsCSSPropertyID property, RawServoAnimationValueBorrowed value);
177594 void Servo_AnimationValue_Serialize(RawServoAnimationValueBorrowed value, nsCSSPropertyID property, nsAString* buffer);
177598 float Servo_AnimationValue_GetOpacity(RawServoAnimationValueBorrowed value);
177600 void Servo_AnimationValue_GetTransform(RawServoAnimationValueBorrowed value, RefPtr<nsCSSValueSharedList>* list);
177629 void Servo_DeclarationBlock_GetPropertyValue(RawServoDeclarationBlockBorrowed declarations, const nsACString* property, nsAString* value);
177632 void Servo_DeclarationBlock_GetPropertyValueById(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nsAString* value);
177638 bool Servo_DeclarationBlock_SetProperty(RawServoDeclarationBlockBorrowed declarations, const nsACString* property, const nsACString* value, bool is_important, RawGeckoURLExtraData* data);
177643 bool Servo_DeclarationBlock_SetPropertyById(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, const nsACString* value, bool is_important, RawGeckoURLExtraData* data);
177668 void Servo_DeclarationBlock_SetIdentStringValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nsIAtom* value);
177672 void Servo_DeclarationBlock_SetKeywordValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, int32_t value);
177676 void Servo_DeclarationBlock_SetIntValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, int32_t value);
177680 void Servo_DeclarationBlock_SetPixelValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, float value);
177684 void Servo_DeclarationBlock_SetPercentValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, float value);
177694 void Servo_DeclarationBlock_SetColorValue(RawServoDeclarationBlockBorrowed declarations, nsCSSPropertyID property, nscolor value);
177698 void Servo_DeclarationBlock_SetFontFamily(RawServoDeclarationBlockBorrowed declarations, const nsAString& value);
177720 bool Servo_CSSSupports2(const nsACString* name, const nsACString* value);