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 16 #ifndef CPP_ABCKIT_BASE_CLASSES_H 17 #define CPP_ABCKIT_BASE_CLASSES_H 18 19 #include "./config.h" 20 21 #include <memory> 22 #include <type_traits> 23 24 namespace abckit { 25 26 // Interface to provide global API-related features, 27 // a base for every API class defined 28 /** 29 * @brief Entity 30 */ 31 class Entity { 32 public: 33 /** 34 * @brief Copy constructor allowed 35 */ 36 Entity(const Entity &) = default; 37 38 /** 39 * @brief Copy assignment allowed 40 * @return Entity 41 */ 42 Entity &operator=(const Entity &) = default; 43 44 /** 45 * @brief Move constructor allowed 46 */ 47 Entity(Entity &&) = default; 48 49 /** 50 * @brief Move assignment allowed 51 * @return Entity 52 */ 53 Entity &operator=(Entity &&) = default; 54 55 /** 56 * @brief Default constructor 57 */ 58 Entity() = default; 59 60 /** 61 * @brief Destructor 62 */ 63 virtual ~Entity() = default; 64 65 /** 66 * @brief Get api config 67 * @return ApiConfig 68 */ 69 virtual const ApiConfig *GetApiConfig() const = 0; 70 }; 71 72 /** 73 * @brief View 74 */ 75 template <typename T, typename = std::enable_if_t<std::is_pointer_v<T>>> 76 class View : public Entity { 77 public: 78 /** 79 * @brief Operator == 80 * @param rhs 81 * @return bool 82 */ 83 bool operator==(const View<T> &rhs) const 84 { 85 return GetView() == rhs.GetView(); 86 } 87 88 /** 89 * @brief Operator != 90 * @param rhs 91 * @return bool 92 */ 93 bool operator!=(const View<T> &rhs) const 94 { 95 return GetView() != rhs.GetView(); 96 } 97 98 /** 99 * @brief Operator bool 100 * @return bool 101 */ 102 explicit operator bool() const 103 { 104 return view_ != nullptr; 105 } 106 107 protected: 108 /** 109 * @brief Constructor 110 * @param ...a 111 */ 112 template <typename... Args> View(Args &&...a)113 explicit View(Args &&...a) : view_(std::forward<Args>(a)...) 114 { 115 } 116 // Can move and copy views 117 118 /** 119 * @brief Copy constructor 120 */ 121 View(const View &) = default; 122 123 /** 124 * @brief Copy assignment 125 * @return View 126 */ 127 View &operator=(const View &) = default; 128 129 /** 130 * @brief Move constructor 131 */ 132 View(View &&) = default; 133 134 /** 135 * @brief Move assignment 136 * @return View 137 */ 138 View &operator=(View &&) = default; 139 140 protected: 141 ~View() override = default; 142 143 /** 144 * @brief Get view 145 * @return T 146 */ GetView()147 T GetView() const 148 { 149 return view_; 150 } 151 152 /** 153 * @brief Set view 154 * @param newView 155 */ SetView(T newView)156 void SetView(T newView) 157 { 158 view_ = newView; 159 } 160 161 private: 162 T view_; 163 }; 164 165 /** 166 * @brief ViewInResource 167 */ 168 template <typename T, typename R, typename = std::enable_if_t<std::is_pointer_v<R>>> 169 class ViewInResource : public View<T> { 170 public: 171 /** 172 * @brief Operator bool 173 * @return bool 174 */ 175 explicit operator bool() const 176 { 177 return resource_ != nullptr && *static_cast<const View<T> *>(this); 178 } 179 180 protected: 181 /** 182 * @brief Constructor 183 * @param ...a 184 */ 185 template <typename... Args> ViewInResource(Args &&...a)186 explicit ViewInResource(Args &&...a) : View<T>(std::forward<Args>(a)...) 187 { 188 } 189 190 // Can move and copy views in resource 191 192 /** 193 * @brief Copy constructor 194 */ 195 ViewInResource(const ViewInResource &) = default; 196 197 /** 198 * @brief Copy assignment 199 * @return ViewInResource 200 */ 201 ViewInResource &operator=(const ViewInResource &) = default; 202 203 /** 204 * @brief Move constructor 205 */ 206 ViewInResource(ViewInResource &&) = default; 207 208 /** 209 * @brief Move assignment 210 * @return ViewInResource 211 */ 212 ViewInResource &operator=(ViewInResource &&) = default; 213 214 /** 215 * @brief Destructor 216 */ 217 ~ViewInResource() override = default; 218 219 /** 220 * @brief Get resource 221 * @return R 222 */ GetResource()223 R GetResource() const 224 { 225 return resource_; 226 } 227 228 /** 229 * @brief Set resource 230 * @param newResource 231 */ SetResource(R newResource)232 void SetResource(R newResource) 233 { 234 resource_ = newResource; 235 } 236 237 /** 238 * @brief Struct for using in callbacks 239 */ 240 template <typename D> 241 struct Payload { 242 /** 243 * @brief data 244 */ 245 D data; 246 /** 247 * @brief config 248 */ 249 const ApiConfig *config; 250 /** 251 * @brief resource 252 */ 253 R resource; 254 }; 255 256 private: 257 R resource_; 258 }; 259 260 // Resource - ptr semantics 261 /** 262 * @brief Resource 263 */ 264 template <typename T> 265 class Resource : public Entity { 266 public: 267 // No copy for resources 268 /** 269 * @brief Deleted copy constructor 270 */ 271 Resource(const Resource &) = delete; 272 273 /** 274 * @brief Deleted copy assignment 275 * @return Resource& 276 */ 277 Resource &operator=(const Resource &) = delete; 278 279 /** 280 * @brief Operator == 281 * @param rhs 282 * @return bool 283 */ 284 bool operator==(const Resource &rhs) const 285 { 286 return GetResource() == rhs.GetResource(); 287 } 288 289 protected: 290 /** 291 * @brief Constructor 292 * @param d 293 * @param ...a 294 */ 295 template <typename... Args> Resource(std::unique_ptr<IResourceDeleter> d,Args &&...a)296 explicit Resource(std::unique_ptr<IResourceDeleter> d, Args &&...a) 297 : deleter_(std::move(d)), resource_(std::forward<Args>(a)...) 298 { 299 } 300 301 /** 302 * @brief Constructor 303 * @param ...a 304 */ 305 template <typename... Args> Resource(Args &&...a)306 explicit Resource(Args &&...a) : resource_(std::forward<Args>(a)...) 307 { 308 } 309 310 // Resources are movable 311 /** 312 * @brief Move constructor 313 * @param other 314 */ Resource(Resource && other)315 Resource(Resource &&other) 316 { 317 released_ = false; 318 resource_ = other.ReleaseResource(); 319 }; 320 321 /** 322 * @brief Move assignment 323 * @param other 324 * @return Resource& 325 */ 326 Resource &operator=(Resource &&other) 327 { 328 released_ = false; 329 resource_ = other.ReleaseResource(); 330 return *this; 331 }; 332 333 /** 334 * @brief Release resource 335 * @return `T` 336 */ ReleaseResource()337 T ReleaseResource() 338 { 339 released_ = true; 340 return resource_; 341 } 342 343 /** 344 * @brief Get resource 345 * @return `T` 346 */ GetResource()347 T GetResource() const 348 { 349 return resource_; 350 } 351 352 /** 353 * @brief Destructor 354 */ ~Resource()355 ~Resource() override 356 { 357 if (!released_) { 358 deleter_->DeleteResource(); 359 } 360 }; 361 362 /** 363 * @brief Set deleter 364 * @param deleter 365 */ SetDeleter(std::unique_ptr<IResourceDeleter> deleter)366 void SetDeleter(std::unique_ptr<IResourceDeleter> deleter) 367 { 368 deleter_ = std::move(deleter); 369 } 370 371 private: 372 T resource_; 373 std::unique_ptr<IResourceDeleter> deleter_ = std::make_unique<DefaultResourceDeleter>(); 374 bool released_ = false; 375 }; 376 377 } // namespace abckit 378 379 #endif // CPP_ABCKIT_BASE_CLASSES_H 380