mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
155 lines
3.6 KiB
C++
155 lines
3.6 KiB
C++
// Copyright 2013 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_
|
|
#define MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_
|
|
|
|
#include "mojo/public/cpp/bindings/lib/template_util.h"
|
|
#include "mojo/public/cpp/bindings/struct_ptr.h"
|
|
#include "mojo/public/cpp/system/core.h"
|
|
|
|
namespace mojo {
|
|
class String;
|
|
|
|
template <typename T>
|
|
class Array;
|
|
|
|
template <typename K, typename V>
|
|
class Map;
|
|
|
|
namespace internal {
|
|
template <typename T>
|
|
class Array_Data;
|
|
|
|
#pragma pack(push, 1)
|
|
|
|
struct StructHeader {
|
|
uint32_t num_bytes;
|
|
uint32_t version;
|
|
};
|
|
static_assert(sizeof(StructHeader) == 8, "Bad sizeof(StructHeader)");
|
|
|
|
struct ArrayHeader {
|
|
uint32_t num_bytes;
|
|
uint32_t num_elements;
|
|
};
|
|
static_assert(sizeof(ArrayHeader) == 8, "Bad_sizeof(ArrayHeader)");
|
|
|
|
template <typename T>
|
|
union StructPointer {
|
|
uint64_t offset;
|
|
T* ptr;
|
|
};
|
|
static_assert(sizeof(StructPointer<char>) == 8, "Bad_sizeof(StructPointer)");
|
|
|
|
template <typename T>
|
|
union ArrayPointer {
|
|
uint64_t offset;
|
|
Array_Data<T>* ptr;
|
|
};
|
|
static_assert(sizeof(ArrayPointer<char>) == 8, "Bad_sizeof(ArrayPointer)");
|
|
|
|
union StringPointer {
|
|
uint64_t offset;
|
|
Array_Data<char>* ptr;
|
|
};
|
|
static_assert(sizeof(StringPointer) == 8, "Bad_sizeof(StringPointer)");
|
|
|
|
struct Interface_Data {
|
|
MessagePipeHandle handle;
|
|
uint32_t version;
|
|
};
|
|
static_assert(sizeof(Interface_Data) == 8, "Bad_sizeof(Interface_Data)");
|
|
|
|
template <typename T>
|
|
union UnionPointer {
|
|
uint64_t offset;
|
|
T* ptr;
|
|
};
|
|
static_assert(sizeof(UnionPointer<char>) == 8, "Bad_sizeof(UnionPointer)");
|
|
|
|
#pragma pack(pop)
|
|
|
|
template <typename T>
|
|
void ResetIfNonNull(T* ptr) {
|
|
if (ptr)
|
|
*ptr = T();
|
|
}
|
|
|
|
template <typename T>
|
|
T FetchAndReset(T* ptr) {
|
|
T temp = *ptr;
|
|
*ptr = T();
|
|
return temp;
|
|
}
|
|
|
|
template <typename H>
|
|
struct IsHandle {
|
|
enum { value = IsBaseOf<Handle, H>::value };
|
|
};
|
|
|
|
template <typename T>
|
|
struct IsUnionDataType {
|
|
template <typename U>
|
|
static YesType Test(const typename U::MojomUnionDataType*);
|
|
|
|
template <typename U>
|
|
static NoType Test(...);
|
|
|
|
static const bool value =
|
|
sizeof(Test<T>(0)) == sizeof(YesType) && !IsConst<T>::value;
|
|
};
|
|
|
|
template <typename T, bool move_only = IsMoveOnlyType<T>::value>
|
|
struct WrapperTraits;
|
|
|
|
template <typename T>
|
|
struct WrapperTraits<T, false> {
|
|
typedef T DataType;
|
|
};
|
|
template <typename H>
|
|
struct WrapperTraits<ScopedHandleBase<H>, true> {
|
|
typedef H DataType;
|
|
};
|
|
template <typename S>
|
|
struct WrapperTraits<StructPtr<S>, true> {
|
|
typedef typename S::Data_* DataType;
|
|
};
|
|
template <typename S>
|
|
struct WrapperTraits<InlinedStructPtr<S>, true> {
|
|
typedef typename S::Data_* DataType;
|
|
};
|
|
template <typename S>
|
|
struct WrapperTraits<S, true> {
|
|
typedef typename S::Data_* DataType;
|
|
};
|
|
|
|
template <typename T, typename Enable = void>
|
|
struct ValueTraits {
|
|
static bool Equals(const T& a, const T& b) { return a == b; }
|
|
};
|
|
|
|
template <typename T>
|
|
struct ValueTraits<
|
|
T,
|
|
typename EnableIf<IsSpecializationOf<Array, T>::value ||
|
|
IsSpecializationOf<Map, T>::value ||
|
|
IsSpecializationOf<StructPtr, T>::value ||
|
|
IsSpecializationOf<InlinedStructPtr, T>::value>::type> {
|
|
static bool Equals(const T& a, const T& b) { return a.Equals(b); }
|
|
};
|
|
|
|
template <typename T>
|
|
struct ValueTraits<ScopedHandleBase<T>> {
|
|
static bool Equals(const ScopedHandleBase<T>& a,
|
|
const ScopedHandleBase<T>& b) {
|
|
return a.get().value() == b.get().value();
|
|
}
|
|
};
|
|
|
|
} // namespace internal
|
|
} // namespace mojo
|
|
|
|
#endif // MOJO_PUBLIC_CPP_BINDINGS_LIB_BINDINGS_INTERNAL_H_
|