1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #ifndef META_SRC_BASE_OBJECT_H
16 #define META_SRC_BASE_OBJECT_H
17
18 #include <base/containers/array_view.h>
19 #include <base/containers/vector.h>
20
21 #include <meta/base/types.h>
22 #include <meta/ext/implementation_macros.h>
23 #include <meta/ext/metadata_helpers.h>
24 #include <meta/ext/object_factory.h>
25 #include <meta/interface/builtin_objects.h>
26 #include <meta/interface/interface_helpers.h>
27 #include <meta/interface/intf_derived.h>
28 #include <meta/interface/intf_lifecycle.h>
29 #include <meta/interface/intf_object.h>
30 #include <meta/interface/intf_object_flags.h>
31 #include <meta/interface/intf_object_registry.h>
32 #include <meta/interface/object_type_info.h>
33
META_BEGIN_NAMESPACE()34 META_BEGIN_NAMESPACE()
35
36 namespace Internal {
37
38 class BaseObject : public IntroduceInterfaces<IObjectInstance, IObjectFlags, IDerived, ILifecycle> {
39 protected:
40 BaseObject() = default;
41 ~BaseObject() override = default;
42
43 // IObject
44 // BASE_NS::Uid GetClassId() const override; //Must be implemented by derived class
45 // BASE_NS::string_view GetClassName() const override; //Must be implemented by derived class
46 InstanceId GetInstanceId() const override;
47 BASE_NS::string GetName() const override;
48 IObject::Ptr Resolve(const RefUri& uri) const override;
49 IObject::Ptr GetSelf() const override;
50 BASE_NS::vector<BASE_NS::Uid> GetInterfaces() const override;
51 // IObjectFlags
52 ObjectFlagBitsValue GetObjectFlags() const override;
53 void SetObjectFlags(const ObjectFlagBitsValue& value) override;
54 ObjectFlagBitsValue GetObjectDefaultFlags() const override;
55
56 template<typename Interface>
57 typename Interface::Ptr GetSelf() const
58 {
59 return interface_pointer_cast<Interface>(GetSelf());
60 }
61
62 // IDerived
63 void SetSuperInstance(const IObject::Ptr&, const IObject::Ptr&) override;
64 BASE_NS::Uid GetSuperClassUid() const override;
65
66 // ILifecycle
67 bool Build(const IMetadata::Ptr& data) override;
68 void SetInstanceId(InstanceId uid) override;
69 void Destroy() override;
70
71 protected:
72 IObjectRegistry& GetObjectRegistry() const;
73
74 protected:
75 static StaticObjectMetadata& StaticObjectMeta()
76 {
77 static StaticObjectMetadata meta { META_NS::ClassId::BaseObject, nullptr };
78 return meta;
79 }
80
81 public:
82 static const META_NS::StaticObjectMetadata& GetStaticObjectMetadata()
83 {
84 return StaticObjectMeta();
85 }
86
87 private:
88 InstanceId instanceId_;
89 IObjectInstance::WeakPtr me_;
90 ObjectFlagBitsValue flags_ { ObjectFlagBits::DEFAULT_FLAGS };
91 };
92
93 template<class FinalClass, const META_NS::ClassInfo& ClassInfo, class ConcreteBaseClass, class... Interfaces>
94 class ConcreteBaseFwd : public IntroduceInterfaces<Interfaces...>, public ConcreteBaseClass {
95 STATIC_METADATA_MACHINERY(ClassInfo, ConcreteBaseClass)
96 STATIC_INTERFACES_WITH_CONCRETE_BASE(IntroduceInterfaces<Interfaces...>, ConcreteBaseClass)
97 META_DEFINE_OBJECT_TYPE_INFO(FinalClass, ClassInfo)
98 public:
99 using ConcreteBaseClass::GetInterfacesVector;
100
101 protected:
102 ObjectId GetClassId() const override
103 {
104 return ClassInfo.Id();
105 }
106 BASE_NS::string_view GetClassName() const override
107 {
108 return ClassInfo.Name();
109 }
110 BASE_NS::vector<BASE_NS::Uid> GetInterfaces() const override
111 {
112 return GetStaticInterfaces();
113 }
114
115 public:
116 const CORE_NS::IInterface* GetInterface(const BASE_NS::Uid& uid) const override
117 {
118 auto* me = const_cast<ConcreteBaseFwd*>(this);
119 return me->ConcreteBaseFwd::GetInterface(uid);
120 }
121 CORE_NS::IInterface* GetInterface(const BASE_NS::Uid& uid) override
122 {
123 CORE_NS::IInterface* ret = ConcreteBaseClass::GetInterface(uid);
124 if (!ret) {
125 ret = IntroduceInterfaces<Interfaces...>::GetInterface(uid);
126 }
127 return ret;
128 }
129
130 protected:
131 void Ref() override
132 {
133 ConcreteBaseClass::Ref();
134 }
135 void Unref() override
136 {
137 ConcreteBaseClass::Unref();
138 }
139 };
140
141 template<class FinalClass, const META_NS::ClassInfo& ClassInfo, class... Interfaces>
142 class BaseObjectFwd : public ConcreteBaseFwd<FinalClass, ClassInfo, META_NS::Internal::BaseObject, Interfaces...> {
143 using Impl = META_NS::Internal::BaseObject;
144
145 public:
146 virtual IObjectRegistry& GetObjectRegistry() const
147 {
148 return BaseObject::GetObjectRegistry();
149 }
150
151 protected:
152 BaseObjectFwd() = default;
153 ~BaseObjectFwd() override = default;
154 };
155
156 } // namespace Internal
157
158 class BaseObject : public Internal::BaseObjectFwd<BaseObject, META_NS::ClassId::BaseObject> {
159 using Super = Internal::BaseObjectFwd<BaseObject, META_NS::ClassId::BaseObject>;
160
161 public:
162 using Super::Super;
163 };
164
165 META_END_NAMESPACE()
166
167 #endif
168