wehub-resource-sync
117 lines
3.8 KiB
C++
117 lines
3.8 KiB
C++
// Copyright (c) 2021 CINN Authors. All Rights Reserved.
|
|
//
|
|
// 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.
|
|
|
|
#pragma once
|
|
#include <cstring>
|
|
|
|
#include "paddle/cinn/common/shared.h"
|
|
|
|
namespace cinn {
|
|
namespace common {
|
|
|
|
template <typename T>
|
|
class Shared;
|
|
/**
|
|
* Object is the basic element in the CINN, with `Shared` wrapper, the object
|
|
* can be shared across the system.
|
|
*/
|
|
struct Object {
|
|
//! Get the type representation of this object.
|
|
virtual const char* type_info() const = 0;
|
|
|
|
//! Cast to a derived type.
|
|
template <typename T>
|
|
T* as() {
|
|
return static_cast<T*>(this);
|
|
}
|
|
|
|
//! Cast to a derived type.
|
|
template <typename T>
|
|
const T* as() const {
|
|
return static_cast<const T*>(this);
|
|
}
|
|
|
|
//! Type safe cast.
|
|
template <typename T>
|
|
T* safe_as() {
|
|
if (std::strcmp(type_info(), T::__type_info__) == 0) {
|
|
return static_cast<T*>(this);
|
|
}
|
|
return nullptr;
|
|
}
|
|
//! Type safe cast.
|
|
template <typename T>
|
|
const T* safe_as() const {
|
|
if (std::strcmp(type_info(), T::__type_info__) == 0) {
|
|
return static_cast<const T*>(this);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//! Check if the type is right.
|
|
template <typename T>
|
|
bool is_type() const {
|
|
if (std::strcmp(type_info(), T::__type_info__) == 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//! The reference count, which make all the derived type able to share.
|
|
mutable RefCount __ref_count__;
|
|
};
|
|
|
|
using object_ptr = Object*;
|
|
using shared_object = Shared<Object>;
|
|
|
|
/*
|
|
* \brief Delete the default copy/move constructor and assign operator
|
|
* \param TypeName The class typename.
|
|
*/
|
|
#define CINN_DELETE_COPY_MOVE_AND_ASSIGN_FOR_OBJECT_NODE(TypeName) \
|
|
TypeName(const TypeName& other) = delete; \
|
|
TypeName(TypeName&& other) = delete; \
|
|
TypeName& operator=(const TypeName& other) = delete; \
|
|
TypeName& operator=(TypeName&& other) = delete;
|
|
|
|
/*
|
|
* \brief Define the default copy/move constructor and assign operator
|
|
* \param TypeName The class typename.
|
|
*/
|
|
#define CINN_DEFINE_COPY_MOVE_AND_ASSIGN_FOR_OBJECT_REF(TypeName) \
|
|
TypeName(const TypeName& other) = default; \
|
|
TypeName(TypeName&& other) = default; \
|
|
TypeName& operator=(const TypeName& other) = default; \
|
|
TypeName& operator=(TypeName&& other) = default;
|
|
|
|
/*
|
|
* \brief Define object reference methods
|
|
* \param TypeName The object type name
|
|
* \param ParentType The parent type of the objectref
|
|
* \param ObjectName The type name of the object
|
|
*/
|
|
#define CINN_DEFINE_OBJECT_REF_METHODS(TypeName, ParentType, ObjectName) \
|
|
TypeName() = default; \
|
|
explicit TypeName(ObjectName* n) : ParentType(n) {} \
|
|
explicit TypeName(const cinn::common::Shared<Object>& ref) \
|
|
: ParentType(ref) {} \
|
|
CINN_DEFINE_COPY_MOVE_AND_ASSIGN_FOR_OBJECT_REF(TypeName); \
|
|
const ObjectName* operator->() const { \
|
|
return static_cast<const ObjectName*>(this->p_); \
|
|
} \
|
|
ObjectName* operator->() { return static_cast<ObjectName*>(this->p_); }
|
|
|
|
} // namespace common
|
|
} // namespace cinn
|