Memory.h

Go to the documentation of this file.

// Copyright 2024 libsese
//
// 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 <memory>
 
#ifdef _WIN32
#pragma warning(disable : 4819)
#endif
 
namespace sese {
 
template<typename T>
using SharedType = std::shared_ptr<T>;
 
template<typename T>
using UniqueType = std::unique_ptr<T>;
 
template<typename T>
using WeakType = std::weak_ptr<T>;
 
template<typename RETURN_TYPE, typename... ARGS>
inline SharedType<RETURN_TYPE> makeShared(ARGS &&...args) {
    return std::make_shared<RETURN_TYPE>(args...);
}
 
template<typename RETURN_TYPE, typename... ARGS>
inline SharedType<RETURN_TYPE> makeUnique(ARGS &&...args) {
    return std::make_unique<RETURN_TYPE>(args...);
}
 
#define MAKE_SHARED_PRIVATE(RETURN_TYPE, ...) sese::SharedType<RETURN_TYPE>(new RETURN_TYPE(__VA_ARGS__))
 
#define MAKE_UNIQUE_PRIVATE(RETURN_TYPE, ...) sese::UniqueType<RETURN_TYPE>(new RETURN_TYPE(__VA_ARGS__))
 
template<typename RETURN_TYPE, typename INIT_TYPE>
SharedType<RETURN_TYPE> makeSharedFromList(std::initializer_list<INIT_TYPE> list) {
    return std::make_shared<RETURN_TYPE>(std::move(list));
}
 
template<typename RETURN_TYPE, typename INIT_TYPE>
UniqueType<RETURN_TYPE> makeUniqueFromList(std::initializer_list<INIT_TYPE> list) {
    return std::make_unique<RETURN_TYPE>(std::move(list));
}
 
template<typename RETURN_TYPE, typename RAW_TYPE>
inline SharedType<RETURN_TYPE> dynamicPointerCast(SharedType<RAW_TYPE> raw_type) {
    return std::dynamic_pointer_cast<RETURN_TYPE>(raw_type);
}
 
template<typename RETURN_TYPE, typename RAW_TYPE>
UniqueType<RETURN_TYPE> dynamicPointerCast(UniqueType<RAW_TYPE> &raw_type) {
    RAW_TYPE *pointer = raw_type.release();
    RETURN_TYPE *newPointer = dynamic_cast<RETURN_TYPE *>(pointer); // NOLINT
    return std::unique_ptr<RETURN_TYPE>(newPointer);
}
} // namespace sese