checked_ptr.hh

Go to the documentation of this file.

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  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.
 */
/*
 * Copyright (C) 2017 ScyllaDB
 */
 
#pragma once
 
#ifndef SEASTAR_MODULE
#include <exception>
#include <memory>
#include <seastar/util/concepts.hh>
#include <seastar/util/modules.hh>
#endif
 
namespace seastar {
 
SEASTAR_MODULE_EXPORT_BEGIN
 
class checked_ptr_is_null_exception : public std::exception {};
 
struct default_null_deref_action {
    void operator()() const {
        throw checked_ptr_is_null_exception();
    }
};
SEASTAR_MODULE_EXPORT_END
 
namespace internal {
 
 
template <typename T>
SEASTAR_CONCEPT( requires requires (T ptr) {
    ptr.get();
})
inline typename std::pointer_traits<std::remove_const_t<T>>::element_type* checked_ptr_do_get(T& ptr) {
    return ptr.get();
}
 
template <typename T>
inline T* checked_ptr_do_get(T* ptr) noexcept {
    return ptr;
}
}
 
SEASTAR_MODULE_EXPORT
template<typename Ptr, typename NullDerefAction = default_null_deref_action>
SEASTAR_CONCEPT( requires std::is_default_constructible<NullDerefAction>::value && requires (NullDerefAction action) {
    NullDerefAction();
})
class checked_ptr {
public:
    using element_type = typename std::pointer_traits<Ptr>::element_type;
 
    using pointer = element_type*;
 
private:
    Ptr _ptr = nullptr;
 
private:
    void check() const {
        if (!_ptr) {
            NullDerefAction()();
        }
    }
 
public:
    checked_ptr() noexcept(noexcept(Ptr(nullptr))) = default;
    checked_ptr(std::nullptr_t) noexcept(std::is_nothrow_default_constructible<checked_ptr<Ptr, NullDerefAction>>::value) : checked_ptr() {}
    checked_ptr(Ptr&& ptr) noexcept(std::is_nothrow_move_constructible<Ptr>::value) : _ptr(std::move(ptr)) {}
    checked_ptr(const Ptr& p) noexcept(std::is_nothrow_copy_constructible<Ptr>::value) : _ptr(p) {}
 
 
    pointer get() const {
        check();
        return internal::checked_ptr_do_get(_ptr);
    }
 
    const Ptr& operator->() const {
        check();
        return _ptr;
    }
 
    Ptr& operator->() {
        check();
        return _ptr;
    }
 
    const element_type& operator*() const {
        check();
        return *_ptr;
    }
 
    element_type& operator*() {
        check();
        return *_ptr;
    }
 
 
    explicit operator bool() const { return bool(_ptr); }
 
    bool operator==(const checked_ptr& other) const { return _ptr == other._ptr; }
    bool operator!=(const checked_ptr& other) const { return _ptr != other._ptr; }
 
    size_t hash() const {
        return std::hash<Ptr>()(_ptr);
    }
};
 
}
 
namespace std {
SEASTAR_MODULE_EXPORT
template<typename T>
struct hash<seastar::checked_ptr<T>> {
    size_t operator()(const seastar::checked_ptr<T>& p) const {
        return p.hash();
    }
};
}