mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
7041704c76
There are several changes here: 1) Adds some MutableThis methods to Optional, Nullable, and dictionaries to effectively allow doing a const_cast without knowing the actual type being templated over. I needed this because I do not in fact know that type in the relevant code. I'm open to suggestions for a better name for this method. 2) Adds some operator& to RootedJSValue to make it look more like a JS::Value, and in particular so I can JS_WrapValue the thing in it. 3) Adds a Slot() method to NonNullLazyRootedObject, just like NonNull has. 4) Adds an operator& to LazyRootedObject to make it look more like JSObject* so I can JS_WrapObject the thing in it. 5) Implements the actual rewrapping of the arguments into the content compartment. 6) Fixes a small preexisting bug in which we didn't look at named constructors in getTypesFromDescriptor (this was causing my tests to not compile). 7) Changes Xrays to not enter the content compartment when calling a WebIDL constructor. 8) Adds some friend API to report things as not being functions.
93 lines
2.2 KiB
C++
93 lines
2.2 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
|
|
/* vim: set ts=2 sw=2 et tw=79: */
|
|
/* 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 mozilla_dom_Nullable_h
|
|
#define mozilla_dom_Nullable_h
|
|
|
|
#include "mozilla/Assertions.h"
|
|
#include "nsTArrayForwardDeclare.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
// Support for nullable types
|
|
template <typename T>
|
|
struct Nullable
|
|
{
|
|
private:
|
|
// mIsNull MUST COME FIRST because otherwise the casting in our array
|
|
// conversion operators would shift where it is found in the struct.
|
|
bool mIsNull;
|
|
T mValue;
|
|
|
|
public:
|
|
Nullable()
|
|
: mIsNull(true)
|
|
{}
|
|
|
|
explicit Nullable(T aValue)
|
|
: mIsNull(false)
|
|
, mValue(aValue)
|
|
{}
|
|
|
|
void SetValue(T aValue) {
|
|
mValue = aValue;
|
|
mIsNull = false;
|
|
}
|
|
|
|
// For cases when |T| is some type with nontrivial copy behavior, we may want
|
|
// to get a reference to our internal copy of T and work with it directly
|
|
// instead of relying on the copying version of SetValue().
|
|
T& SetValue() {
|
|
mIsNull = false;
|
|
return mValue;
|
|
}
|
|
|
|
void SetNull() {
|
|
mIsNull = true;
|
|
}
|
|
|
|
const T& Value() const {
|
|
MOZ_ASSERT(!mIsNull);
|
|
return mValue;
|
|
}
|
|
|
|
T& Value() {
|
|
MOZ_ASSERT(!mIsNull);
|
|
return mValue;
|
|
}
|
|
|
|
bool IsNull() const {
|
|
return mIsNull;
|
|
}
|
|
|
|
Nullable& AsMutable() const {
|
|
return *const_cast<Nullable*>(this);
|
|
}
|
|
|
|
// Make it possible to use a const Nullable of an array type with other
|
|
// array types.
|
|
template<typename U>
|
|
operator const Nullable< nsTArray<U> >&() const {
|
|
// Make sure that T is ok to reinterpret to nsTArray<U>
|
|
const nsTArray<U>& arr = mValue;
|
|
(void)arr;
|
|
return *reinterpret_cast<const Nullable< nsTArray<U> >*>(this);
|
|
}
|
|
template<typename U>
|
|
operator const Nullable< FallibleTArray<U> >&() const {
|
|
// Make sure that T is ok to reinterpret to FallibleTArray<U>
|
|
const FallibleTArray<U>& arr = mValue;
|
|
(void)arr;
|
|
return *reinterpret_cast<const Nullable< FallibleTArray<U> >*>(this);
|
|
}
|
|
};
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
#endif /* mozilla_dom_Nullable_h */
|