| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef STAGEFRIGHT_FOUNDATION_A_DATA_H_ |
| #define STAGEFRIGHT_FOUNDATION_A_DATA_H_ |
| |
| #include <memory> // for std::shared_ptr, weak_ptr and unique_ptr |
| #include <type_traits> // for std::aligned_union |
| |
| #include <utils/StrongPointer.h> // for android::sp and wp |
| |
| #include <media/stagefright/foundation/TypeTraits.h> |
| #include <media/stagefright/foundation/Flagged.h> |
| |
| namespace android { |
| |
| /** |
| * AData is a flexible union type that supports non-POD members. It supports arbitrary types as long |
| * as they are either moveable or copyable. |
| * |
| * Internally, AData is using AUnion - a structure providing the union support. AUnion should not |
| * be used by generic code as it is very unsafe - it opens type aliasing errors where an object of |
| * one type can be easily accessed as an object of another type. AData prevents this. |
| * |
| * AData allows a custom type flagger to be used for future extensions (e.g. allowing automatic |
| * type conversion). A strict and a relaxed flagger are provided as internal types. |
| * |
| * Use as follows: |
| * |
| * AData<int, float>::Basic data; // strict type support |
| * int i = 1; |
| * float f = 7.0f; |
| * |
| * data.set(5); |
| * EXPECT_TRUE(data.find(&i)); |
| * EXPECT_FALSE(data.find(&f)); |
| * EXPECT_EQ(i, 5); |
| * |
| * data.set(6.0f); |
| * EXPECT_FALSE(data.find(&i)); |
| * EXPECT_TRUE(data.find(&f)); |
| * EXPECT_EQ(f, 6.0f); |
| * |
| * AData<int, sp<RefBase>>::RelaxedBasic objdata; // relaxed type support |
| * sp<ABuffer> buf = new ABuffer(16), buf2; |
| * sp<RefBase> obj; |
| * |
| * objdata.set(buf); |
| * EXPECT_TRUE(objdata.find(&buf2)); |
| * EXPECT_EQ(buf, buf2); |
| * EXPECT_FALSE(objdata.find(&i)); |
| * EXPECT_TRUE(objdata.find(&obj)); |
| * EXPECT_TRUE(obj == buf); |
| * |
| * obj = buf; |
| * objdata.set(obj); // storing as sp<RefBase> |
| * EXPECT_FALSE(objdata.find(&buf2)); // not stored as ABuffer(!) |
| * EXPECT_TRUE(objdata.find(&obj)); |
| */ |
| |
| /// \cond Internal |
| |
| /** |
| * Helper class to call constructor and destructor for a specific type in AUnion. |
| * This class is needed as member function specialization is not allowed for a |
| * templated class. |
| */ |
| struct _AUnion_impl { |
| /** |
| * Calls placement constuctor for type T with arbitrary arguments for a storage at an address. |
| * Storage MUST be large enough to contain T. |
| * Also clears the slack space after type T. \todo This is not technically needed, so we may |
| * choose to do this just for debugging. |
| * |
| * \param totalSize size of the storage |
| * \param addr pointer to where object T should be constructed |
| * \param args arbitrary arguments for constructor |
| */ |
| template<typename T, typename ...Args> |
| inline static void emplace(size_t totalSize, T *addr, Args&&... args) { |
| new(addr)T(std::forward<Args>(args)...); |
| // clear slack space - this is not technically required |
| constexpr size_t size = sizeof(T); |
| memset(reinterpret_cast<uint8_t*>(addr) + size, 0, totalSize - size); |
| } |
| |
| /** |
| * Calls destuctor for an object of type T located at a specific address. |
| * |
| * \note we do not clear the storage in this case as the storage should not be used |
| * until another object is placed there, at which case the storage will be cleared. |
| * |
| * \param addr pointer to where object T is stored |
| */ |
| template<typename T> |
| inline static void del(T *addr) { |
| addr->~T(); |
| } |
| }; |
| |
| /** Constructor specialization for void type */ |
| template<> |
| inline void _AUnion_impl::emplace<void>(size_t totalSize, void *addr) { |
| memset(addr, 0, totalSize); |
| } |
| |
| /** Destructor specialization for void type */ |
| template<> |
| inline void _AUnion_impl::del<void>(void *) { |
| } |
| |
| /// \endcond |
| |
| /** |
| * A templated union class that can contain specific types of data, and provides |
| * constructors, destructor and access methods strictly for those types. |
| * |
| * \note This class is VERY UNSAFE compared to a union, but it allows non-POD unions. |
| * In particular care must be taken that methods are called in a careful order to |
| * prevent accessing objects of one type as another type. This class provides no |
| * facilities to help with this ordering. This is meant to be wrapped by safer |
| * utility classes that do that. |
| * |
| * \param Ts types stored in this union. |
| */ |
| template<typename ...Ts> |
| struct AUnion { |
| private: |
| using _type = typename std::aligned_union<0, Ts...>::type; ///< storage type |
| _type mValue; ///< storage |
| |
| public: |
| /** |
| * Constructs an object of type T with arbitrary arguments in this union. After this call, |
| * this union will contain this object. |
| * |
| * This method MUST be called only when either 1) no object or 2) a void object (equivalent to |
| * no object) is contained in this union. |
| * |
| * \param T type of object to be constructed. This must be one of the template parameters of |
| * the union class with the same cv-qualification, or void. |
| * \param args arbitrary arguments for the constructor |
| */ |
| template< |
| typename T, typename ...Args, |
| typename=typename std::enable_if<is_one_of<T, void, Ts...>::value>::type> |
| inline void emplace(Args&&... args) { |
| _AUnion_impl::emplace( |
| sizeof(_type), reinterpret_cast<T*>(&mValue), std::forward<Args>(args)...); |
| } |
| |
| /** |
| * Destructs an object of type T in this union. After this call, this union will contain no |
| * object. |
| * |
| * This method MUST be called only when this union contains an object of type T. |
| * |
| * \param T type of object to be destructed. This must be one of the template parameters of |
| * the union class with the same cv-qualification, or void. |
| */ |
| template< |
| typename T, |
| typename=typename std::enable_if<is_one_of<T, void, Ts...>::value>::type> |
| inline void del() { |
| _AUnion_impl::del(reinterpret_cast<T*>(&mValue)); |
| } |
| |
| /** |
| * Returns a const reference to the object of type T in this union. |
| * |
| * This method MUST be called only when this union contains an object of type T. |
| * |
| * \param T type of object to be returned. This must be one of the template parameters of |
| * the union class with the same cv-qualification. |
| */ |
| template< |
| typename T, |
| typename=typename std::enable_if<is_one_of<T, Ts...>::value>::type> |
| inline const T &get() const { |
| return *reinterpret_cast<const T*>(&mValue); |
| } |
| |
| /** |
| * Returns a reference to the object of type T in this union. |
| * |
| * This method MUST be called only when this union contains an object of type T. |
| * |
| * \param T type of object to be returned. This must be one of the template parameters of |
| * the union class with the same cv-qualification. |
| */ |
| template<typename T> |
| inline T &get() { |
| return *reinterpret_cast<T*>(&mValue); |
| } |
| }; |
| |
| /** |
| * Helper utility class that copies an object of type T to a destination. |
| * |
| * T must be copy assignable or copy constructible. |
| * |
| * It provides: |
| * |
| * void assign(T*, const U&) // for copiable types - this leaves the source unchanged, hence const. |
| * |
| * \param T type of object to assign to |
| */ |
| template< |
| typename T, |
| bool=std::is_copy_assignable<T>::value> |
| struct _AData_copier { |
| static_assert(std::is_copy_assignable<T>::value, "T must be copy assignable here"); |
| |
| /** |
| * Copies src to data without modifying data. |
| * |
| * \param data pointer to destination |
| * \param src source object |
| */ |
| inline static void assign(T *data, const T &src) { |
| *data = src; |
| } |
| |
| template<typename U> |
| using enable_if_T_is_same_as = typename std::enable_if<std::is_same<U, T>::value>::type; |
| |
| /** |
| * Downcast specializations for sp<>, shared_ptr<> and weak_ptr<> |
| */ |
| template<typename Tp, typename U, typename=enable_if_T_is_same_as<sp<Tp>>> |
| inline static void assign(sp<Tp> *data, const sp<U> &src) { |
| *data = static_cast<Tp*>(src.get()); |
| } |
| |
| template<typename Tp, typename U, typename=enable_if_T_is_same_as<wp<Tp>>> |
| inline static void assign(wp<Tp> *data, const wp<U> &src) { |
| sp<U> __tmp = src.promote(); |
| *data = static_cast<Tp*>(__tmp.get()); |
| } |
| |
| template<typename Tp, typename U, typename=enable_if_T_is_same_as<sp<Tp>>> |
| inline static void assign(sp<Tp> *data, sp<U> &&src) { |
| sp<U> __tmp = std::move(src); // move src out as get cannot |
| *data = static_cast<Tp*>(__tmp.get()); |
| } |
| |
| template<typename Tp, typename U, typename=enable_if_T_is_same_as<std::shared_ptr<Tp>>> |
| inline static void assign(std::shared_ptr<Tp> *data, const std::shared_ptr<U> &src) { |
| *data = std::static_pointer_cast<Tp>(src); |
| } |
| |
| template<typename Tp, typename U, typename=enable_if_T_is_same_as<std::shared_ptr<Tp>>> |
| inline static void assign(std::shared_ptr<Tp> *data, std::shared_ptr<U> &&src) { |
| std::shared_ptr<U> __tmp = std::move(src); // move src out as static_pointer_cast cannot |
| *data = std::static_pointer_cast<Tp>(__tmp); |
| } |
| |
| template<typename Tp, typename U, typename=enable_if_T_is_same_as<std::weak_ptr<Tp>>> |
| inline static void assign(std::weak_ptr<Tp> *data, const std::weak_ptr<U> &src) { |
| *data = std::static_pointer_cast<Tp>(src.lock()); |
| } |
| |
| // shared_ptrs are implicitly convertible to weak_ptrs but not vice versa, but picking the |
| // first compatible type in Ts requires having shared_ptr types before weak_ptr types, so that |
| // they are stored as shared_ptrs. |
| /** |
| * Provide sensible error message if encountering shared_ptr/weak_ptr ambiguity. This method |
| * is not enough to detect this, only if someone is trying to find the shared_ptr. |
| */ |
| template<typename Tp, typename U> |
| inline static void assign(std::shared_ptr<Tp> *, const std::weak_ptr<U> &) { |
| static_assert(std::is_same<Tp, void>::value, |
| "shared/weak pointer ambiguity. move shared ptr types before weak_ptrs"); |
| } |
| }; |
| |
| /** |
| * Template specialization for non copy assignable, but copy constructible types. |
| * |
| * \todo Test this. No basic classes are copy constructible but not assignable. |
| * |
| */ |
| template<typename T> |
| struct _AData_copier<T, false> { |
| static_assert(!std::is_copy_assignable<T>::value, "T must not be copy assignable here"); |
| static_assert(std::is_copy_constructible<T>::value, "T must be copy constructible here"); |
| |
| inline static void copy(T *data, const T &src) { |
| data->~T(); |
| new(data)T(src); |
| } |
| }; |
| |
| /** |
| * Helper utility class that moves an object of type T to a destination. |
| * |
| * T must be move assignable or move constructible. |
| * |
| * It provides multiple methods: |
| * |
| * void assign(T*, T&&) |
| * |
| * \param T type of object to assign |
| */ |
| template< |
| typename T, |
| bool=std::is_move_assignable<T>::value> |
| struct _AData_mover { |
| static_assert(std::is_move_assignable<T>::value, "T must be move assignable here"); |
| |
| /** |
| * Moves src to data while likely modifying it. |
| * |
| * \param data pointer to destination |
| * \param src source object |
| */ |
| inline static void assign(T *data, T &&src) { |
| *data = std::move(src); |
| } |
| |
| template<typename U> |
| using enable_if_T_is_same_as = typename std::enable_if<std::is_same<U, T>::value>::type; |
| |
| /** |
| * Downcast specializations for sp<>, shared_ptr<> and weak_ptr<> |
| */ |
| template<typename Tp, typename U, typename=enable_if_T_is_same_as<sp<Tp>>> |
| inline static void assign(sp<Tp> *data, sp<U> &&src) { |
| sp<U> __tmp = std::move(src); // move src out as get cannot |
| *data = static_cast<Tp*>(__tmp.get()); |
| } |
| |
| template<typename Tp, typename U, typename=enable_if_T_is_same_as<std::shared_ptr<Tp>>> |
| inline static void assign(std::shared_ptr<Tp> *data, std::shared_ptr<U> &&src) { |
| std::shared_ptr<U> __tmp = std::move(src); // move src out as static_pointer_cast cannot |
| *data = std::static_pointer_cast<Tp>(__tmp); |
| } |
| |
| template<typename Tp, typename Td, typename U, typename Ud, |
| typename=enable_if_T_is_same_as<std::unique_ptr<Tp, Td>>> |
| inline static void assign(std::unique_ptr<Tp, Td> *data, std::unique_ptr<U, Ud> &&src) { |
| *data = std::unique_ptr<Tp, Td>(static_cast<Tp*>(src.release())); |
| } |
| |
| // shared_ptrs are implicitly convertible to weak_ptrs but not vice versa, but picking the |
| // first compatible type in Ts requires having shared_ptr types before weak_ptr types, so that |
| // they are stored as shared_ptrs. |
| /** |
| * Provide sensible error message if encountering shared_ptr/weak_ptr ambiguity. This method |
| * is not enough to detect this, only if someone is trying to remove the shared_ptr. |
| */ |
| template<typename Tp, typename U> |
| inline static void assign(std::shared_ptr<Tp> *, std::weak_ptr<U> &&) { |
| static_assert(std::is_same<Tp, void>::value, |
| "shared/weak pointer ambiguity. move shared ptr types before weak_ptrs"); |
| } |
| |
| // unique_ptrs are implicitly convertible to shared_ptrs but not vice versa, but picking the |
| // first compatible type in Ts requires having unique_ptrs types before shared_ptrs types, so |
| // that they are stored as unique_ptrs. |
| /** |
| * Provide sensible error message if encountering shared_ptr/unique_ptr ambiguity. This method |
| * is not enough to detect this, only if someone is trying to remove the unique_ptr. |
| */ |
| template<typename Tp, typename U> |
| inline static void assign(std::unique_ptr<Tp> *, std::shared_ptr<U> &&) { |
| static_assert(std::is_same<Tp, void>::value, |
| "unique/shared pointer ambiguity. move unique ptr types before shared_ptrs"); |
| } |
| }; |
| |
| /** |
| * Template specialization for non move assignable, but move constructible types. |
| * |
| * \todo Test this. No basic classes are move constructible but not assignable. |
| * |
| */ |
| template<typename T> |
| struct _AData_mover<T, false> { |
| static_assert(!std::is_move_assignable<T>::value, "T must not be move assignable here"); |
| static_assert(std::is_move_constructible<T>::value, "T must be move constructible here"); |
| |
| inline static void assign(T *data, T &&src) { |
| data->~T(); |
| new(data)T(std::move(src)); |
| } |
| }; |
| |
| /** |
| * Helper template that deletes an object of a specific type (member) in an AUnion. |
| * |
| * \param Flagger type flagger class (see AData) |
| * \param U AUnion object in which the member should be deleted |
| * \param Ts types to consider for the member |
| */ |
| template<typename Flagger, typename U, typename ...Ts> |
| struct _AData_deleter; |
| |
| /** |
| * Template specialization when there are still types to consider (T and rest) |
| */ |
| template<typename Flagger, typename U, typename T, typename ...Ts> |
| struct _AData_deleter<Flagger, U, T, Ts...> { |
| static bool del(typename Flagger::type flags, U &data) { |
| if (Flagger::canDeleteAs(flags, Flagger::flagFor((T*)0))) { |
| data.template del<T>(); |
| return true; |
| } |
| return _AData_deleter<Flagger, U, Ts...>::del(flags, data); |
| } |
| }; |
| |
| /** |
| * Template specialization when there are no more types to consider. |
| */ |
| template<typename Flagger, typename U> |
| struct _AData_deleter<Flagger, U> { |
| inline static bool del(typename Flagger::type, U &) { |
| return false; |
| } |
| }; |
| |
| /** |
| * Container that can store an arbitrary object of a set of specified types. |
| * |
| * This struct is an outer class that contains various inner classes based on desired type |
| * strictness. The following inner classes are supported: |
| * |
| * AData<types...>::Basic - strict type support using uint32_t flag. |
| * |
| * AData<types...>::Strict<Flag> - strict type support using custom flag. |
| * AData<types...>::Relaxed<Flag, MaxSize, Align> |
| * - relaxed type support with compatible (usually derived) class support |
| * for pointer types with added size checking for minimal additional |
| * safety. |
| * |
| * AData<types...>::RelaxedBasic - strict type support using uint32_t flag. |
| * |
| * AData<types...>::Custom<flagger> - custom type support (flaggers determine the supported types |
| * and the base type to use for each) |
| * |
| */ |
| template<typename ...Ts> |
| struct AData { |
| private: |
| static_assert(are_unique<Ts...>::value, "types must be unique"); |
| |
| static constexpr size_t num_types = sizeof...(Ts); ///< number of types to support |
| |
| public: |
| /** |
| * Default (strict) type flagger provided. |
| * |
| * The default flagger simply returns the index of the type within Ts, or 0 for void. |
| * |
| * Type flaggers return a flag for a supported type. |
| * |
| * They must provide: |
| * |
| * - a flagFor(T*) method for supported types _and_ for T=void. T=void is used to mark that no |
| * object is stored in the container. For this, an arbitrary unique value may be returned. |
| * - a mask field that contains the flag mask. |
| * - a canDeleteAs(Flag, Flag) flag comparison method that checks if a type of a flag can be |
| * deleted as another type. |
| * |
| * \param Flag the underlying unsigned integral to use for the flags. |
| */ |
| template<typename Flag> |
| struct flagger { |
| private: |
| static_assert(std::is_unsigned<Flag>::value, "Flag must be unsigned"); |
| static_assert(std::is_integral<Flag>::value, "Flag must be an integral type"); |
| |
| static constexpr Flag count = num_types + 1; |
| |
| public: |
| typedef Flag type; ///< flag type |
| |
| static constexpr Flag mask = _Flagged_helper::minMask<Flag>(count); ///< flag mask |
| |
| /** |
| * Return the stored type for T. This is itself. |
| */ |
| template<typename T> |
| struct store { |
| typedef T as_type; ///< the base type that T is stored as |
| }; |
| |
| /** |
| * Constexpr method that returns if two flags are compatible for deletion. |
| * |
| * \param objectFlag flag for object to be deleted |
| * \param deleteFlag flag for type that object is to be deleted as |
| */ |
| static constexpr bool canDeleteAs(Flag objectFlag, Flag deleteFlag) { |
| // default flagger requires strict type equality |
| return objectFlag == deleteFlag; |
| } |
| |
| /** |
| * Constexpr method that returns the flag to use for a given type. |
| * |
| * Function overload for void*. |
| */ |
| static constexpr Flag flagFor(void*) { |
| return 0u; |
| } |
| |
| /** |
| * Constexpr method that returns the flag to use for a given supported type (T). |
| */ |
| template<typename T, typename=typename std::enable_if<is_one_of<T, Ts...>::value>::type> |
| static constexpr Flag flagFor(T*) { |
| return find_first<T, Ts...>::index; |
| } |
| }; |
| |
| /** |
| * Relaxed flagger returns the index of the type within Ts. However, for pointers T* it returns |
| * the first type in Ts that T* can be converted into (this is normally a base type, but also |
| * works for sp<>, shared_ptr<> or unique_ptr<>). For a bit more strictness, the flag also |
| * contains the size of the class to avoid finding objects that were stored as a different |
| * derived class of the same base class. |
| * |
| * Flag is basically the index of the (base) type in Ts multiplied by the max size stored plus |
| * the size of the type (divided by alignment) for derived pointer types. |
| * |
| * \param MaxSize max supported size for derived class pointers |
| * \param Align alignment to assume for derived class pointers |
| */ |
| template<typename Flag, size_t MaxSize=1024, size_t Align=4> |
| struct relaxed_flagger { |
| private: |
| static_assert(std::is_unsigned<Flag>::value, "Flag must be unsigned"); |
| static_assert(std::is_integral<Flag>::value, "Flag must be an integral type"); |
| |
| static constexpr Flag count = num_types + 1; |
| static_assert(std::numeric_limits<Flag>::max() / count > (MaxSize / Align), |
| "not enough bits to fit into flag"); |
| |
| static constexpr Flag max_size_stored = MaxSize / Align + 1; |
| |
| // T can be converted if it's size is <= MaxSize and it can be converted to one of the Ts |
| template<typename T, size_t size> |
| using enable_if_can_be_converted = typename std::enable_if< |
| (size / Align < max_size_stored |
| && find_first_convertible_to<T, Ts...>::index)>::type; |
| |
| |
| template<typename W, typename T, typename=enable_if_can_be_converted<W, sizeof(T)>> |
| static constexpr Flag relaxedFlagFor(W*, T*) { |
| return find_first_convertible_to<W, Ts...>::index * max_size_stored |
| + (is_one_of<W, Ts...>::value ? 0 : (sizeof(T) / Align)); |
| } |
| |
| public: |
| typedef Flag type; ///< flag type |
| |
| static constexpr Flag mask = |
| _Flagged_helper::minMask<Flag>(count * max_size_stored); ///< flag mask |
| |
| /** |
| * Constexpr method that returns if two flags are compatible for deletion. |
| * |
| * \param objectFlag flag for object to be deleted |
| * \param deleteFlag flag for type that object is to be deleted as |
| */ |
| static constexpr bool canDeleteAs(Flag objectFlag, Flag deleteFlag) { |
| // can delete if objects have the same base type |
| return |
| objectFlag / max_size_stored == deleteFlag / max_size_stored && |
| (deleteFlag % max_size_stored) == 0; |
| } |
| |
| /** |
| * Constexpr method that returns the flag to use for a given type. |
| * |
| * Function overload for void*. |
| */ |
| static constexpr Flag flagFor(void*) { |
| return 0u; |
| } |
| |
| /** |
| * Constexpr method that returns the flag to use for a given supported type (T). |
| * |
| * This is a member method to enable both overloading as well as template specialization. |
| */ |
| template<typename T, typename=typename std::enable_if<is_one_of<T, Ts...>::value>::type> |
| static constexpr Flag flagFor(T*) { |
| return find_first<T, Ts...>::index * max_size_stored; |
| } |
| |
| /** |
| * For precaution, we only consider converting pointers to their base classes. |
| */ |
| |
| /** |
| * Template specialization for derived class pointers and managed pointers. |
| */ |
| template<typename T> |
| static constexpr Flag flagFor(T**p) { return relaxedFlagFor(p, (T*)0); } |
| template<typename T> |
| static constexpr Flag flagFor(std::shared_ptr<T>*p) { return relaxedFlagFor(p, (T*)0); } |
| template<typename T> |
| static constexpr Flag flagFor(std::unique_ptr<T>*p) { return relaxedFlagFor(p, (T*)0); } |
| template<typename T> |
| static constexpr Flag flagFor(std::weak_ptr<T>*p) { return relaxedFlagFor(p, (T*)0); } |
| template<typename T> |
| static constexpr Flag flagFor(sp<T>*p) { return relaxedFlagFor(p, (T*)0); } |
| template<typename T> |
| static constexpr Flag flagFor(wp<T>*p) { return relaxedFlagFor(p, (T*)0); } |
| |
| /** |
| * Type support template that provodes the stored type for T. |
| * This is itself if it is one of Ts, or the first type in Ts that T is convertible to. |
| * |
| * NOTE: This template may provide a base class for an unsupported type. Support is |
| * determined by flagFor(). |
| */ |
| template<typename T> |
| struct store { |
| typedef typename std::conditional< |
| is_one_of<T, Ts...>::value, |
| T, |
| typename find_first_convertible_to<T, Ts...>::type>::type as_type; |
| }; |
| }; |
| |
| /** |
| * Implementation of AData. |
| */ |
| template<typename Flagger> |
| struct Custom : protected Flagged<AUnion<Ts...>, typename Flagger::type, Flagger::mask> { |
| using data_t = AUnion<Ts...>; |
| using base_t = Flagged<AUnion<Ts...>, typename Flagger::type, Flagger::mask>; |
| |
| /** |
| * Constructor. Initializes this to a container that does not contain any object. |
| */ |
| Custom() : base_t(Flagger::flagFor((void*)0)) { } |
| |
| /** |
| * Removes the contained object, if any. |
| */ |
| ~Custom() { |
| if (!this->clear()) { |
| __builtin_trap(); |
| // std::cerr << "could not delete data of type " << this->flags() << std::endl; |
| } |
| } |
| |
| /** |
| * Returns whether there is any object contained. |
| */ |
| inline bool used() const { |
| return this->flags() != Flagger::flagFor((void*)0); |
| } |
| |
| /** |
| * Removes the contained object, if any. Returns true if there are no objects contained, |
| * or false on any error (this is highly unexpected). |
| */ |
| bool clear() { |
| if (this->used()) { |
| if (_AData_deleter<Flagger, data_t, Ts...>::del(this->flags(), this->get())) { |
| this->setFlags(Flagger::flagFor((void*)0)); |
| return true; |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| template<typename T> |
| using is_supported_by_flagger = |
| typename std::enable_if<Flagger::flagFor((T*)0) != Flagger::flagFor((void*)0)>::type; |
| |
| /** |
| * Checks if there is a copiable object of type T in this container. If there is, it copies |
| * that object into the provided address and returns true. Otherwise, it does nothing and |
| * returns false. |
| * |
| * This method normally requires a flag equality between the stored and retrieved types. |
| * However, it also allows retrieving the stored object as the stored type |
| * (usually base type). |
| * |
| * \param T type of object to sought |
| * \param data address at which the object should be retrieved |
| * |
| * \return true if the object was retrieved. false if it was not. |
| */ |
| template< |
| typename T, |
| typename=is_supported_by_flagger<T>> |
| bool find(T *data) const { |
| using B = typename Flagger::template store<T>::as_type; |
| if (this->flags() == Flagger::flagFor((T*)0) || |
| Flagger::canDeleteAs(this->flags(), Flagger::flagFor((T*)0))) { |
| _AData_copier<T>::assign(data, this->get().template get<B>()); |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Checks if there is an object of type T in this container. If there is, it moves that |
| * object into the provided address and returns true. Otherwise, it does nothing and returns |
| * false. |
| * |
| * This method normally requires a flag equality between the stored and retrieved types. |
| * However, it also allows retrieving the stored object as the stored type |
| * (usually base type). |
| * |
| * \param T type of object to sought |
| * \param data address at which the object should be retrieved. |
| * |
| * \return true if the object was retrieved. false if it was not. |
| */ |
| template< |
| typename T, |
| typename=is_supported_by_flagger<T>> |
| bool remove(T *data) { |
| using B = typename Flagger::template store<T>::as_type; |
| if (this->flags() == Flagger::flagFor((T*)0) || |
| Flagger::canDeleteAs(this->flags(), Flagger::flagFor((T*)0))) { |
| _AData_mover<T>::assign(data, std::move(this->get().template get<B>())); |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Stores an object into this container by copying. If it was successful, returns true. |
| * Otherwise, (e.g. it could not destroy the already stored object) it returns false. This |
| * latter would be highly unexpected. |
| * |
| * \param T type of object to store |
| * \param data object to store |
| * |
| * \return true if the object was stored. false if it was not. |
| */ |
| template< |
| typename T, |
| typename=is_supported_by_flagger<T>, |
| typename=typename std::enable_if< |
| std::is_copy_constructible<T>::value || |
| (std::is_default_constructible<T>::value && |
| std::is_copy_assignable<T>::value)>::type> |
| bool set(const T &data) { |
| using B = typename Flagger::template store<T>::as_type; |
| |
| // if already contains an object of this type, simply assign |
| if (this->flags() == Flagger::flagFor((T*)0) && std::is_same<T, B>::value) { |
| _AData_copier<B>::assign(&this->get().template get<B>(), data); |
| return true; |
| } else if (this->used()) { |
| // destroy previous object |
| if (!this->clear()) { |
| return false; |
| } |
| } |
| this->get().template emplace<B>(data); |
| this->setFlags(Flagger::flagFor((T *)0)); |
| return true; |
| } |
| |
| /** |
| * Moves an object into this container. If it was successful, returns true. Otherwise, |
| * (e.g. it could not destroy the already stored object) it returns false. This latter |
| * would be highly unexpected. |
| * |
| * \param T type of object to store |
| * \param data object to store |
| * |
| * \return true if the object was stored. false if it was not. |
| */ |
| template< |
| typename T, |
| typename=is_supported_by_flagger<T>> |
| bool set(T &&data) { |
| using B = typename Flagger::template store<T>::as_type; |
| |
| // if already contains an object of this type, simply assign |
| if (this->flags() == Flagger::flagFor((T*)0) && std::is_same<T, B>::value) { |
| _AData_mover<B>::assign(&this->get().template get<B>(), std::forward<T&&>(data)); |
| return true; |
| } else if (this->used()) { |
| // destroy previous object |
| if (!this->clear()) { |
| return false; |
| } |
| } |
| this->get().template emplace<B>(std::forward<T&&>(data)); |
| this->setFlags(Flagger::flagFor((T *)0)); |
| return true; |
| } |
| }; |
| |
| /** |
| * Basic AData using the default type flagger and requested flag type. |
| * |
| * \param Flag desired flag type to use. Must be an unsigned and std::integral type. |
| */ |
| template<typename Flag> |
| using Strict = Custom<flagger<Flag>>; |
| |
| /** |
| * Basic AData using the default type flagger and uint32_t flag. |
| */ |
| using Basic = Strict<uint32_t>; |
| |
| /** |
| * AData using the relaxed type flagger for max size and requested flag type. |
| * |
| * \param Flag desired flag type to use. Must be an unsigned and std::integral type. |
| */ |
| template<typename Flag, size_t MaxSize = 1024, size_t Align = 4> |
| using Relaxed = Custom<relaxed_flagger<Flag, MaxSize, Align>>; |
| |
| /** |
| * Basic AData using the relaxed type flagger and uint32_t flag. |
| */ |
| using RelaxedBasic = Relaxed<uint32_t>; |
| }; |
| |
| } // namespace android |
| |
| #endif // STAGEFRIGHT_FOUNDATION_A_DATA_H_ |
| |
