immutable.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
 
namespace mbgl {
 
template <class T>
class Mutable {
public:
    Mutable(Mutable&&) noexcept = default;
    Mutable& operator=(Mutable&&) noexcept = default;
 
    Mutable(const Mutable&) = delete;
    Mutable& operator=(const Mutable&) = delete;
 
    T* get() { return ptr.get(); }
    T* operator->() { return ptr.get(); }
    T& operator*() { return *ptr; }
 
private:
    Mutable(std::shared_ptr<T>&& s)
        : ptr(std::move(s)) {}
 
    std::shared_ptr<T> ptr;
 
    template <class S> friend class Immutable;
    // NOLINTNEXTLINE(readability-redundant-declaration)
    template <class S, class... Args> friend Mutable<S> makeMutable(Args&&...);
    // NOLINTNEXTLINE(readability-redundant-declaration)
    template <class S, class U> friend Mutable<S> staticMutableCast(const Mutable<U>&);
};
 
template <class T, class... Args>
Mutable<T> makeMutable(Args&&... args) {
    return Mutable<T>(std::make_shared<T>(std::forward<Args>(args)...));
}
 
template <class S, class U>
Mutable<S> staticMutableCast(const Mutable<U>& u) {
    return Mutable<S>(std::static_pointer_cast<S>(u.ptr));
}
 
template <class T>
class Immutable {
public:
    template <class S>
    Immutable(Mutable<S>&& s)
        : ptr(std::const_pointer_cast<const S>(std::move(s.ptr))) {}
 
    template <class S>
    Immutable(Immutable<S> s)
        : ptr(std::move(s.ptr)) {}
 
    Immutable(Immutable&&) noexcept = default;
    Immutable(const Immutable&) = default;
 
    template <class S>
    Immutable& operator=(Mutable<S>&& s) {
        ptr = std::const_pointer_cast<const S>(std::move(s.ptr));
        return *this;
    }
 
    Immutable& operator=(Immutable&&) noexcept = default;
    Immutable& operator=(const Immutable&) = default;
 
    const T* get() const { return ptr.get(); }
    const T* operator->() const { return ptr.get(); }
    const T& operator*() const { return *ptr; }
 
    friend bool operator==(const Immutable<T>& lhs, const Immutable<T>& rhs) {
        return lhs.ptr == rhs.ptr;
    }
 
    friend bool operator!=(const Immutable<T>& lhs, const Immutable<T>& rhs) {
        return lhs.ptr != rhs.ptr;
    }
 
private:
    Immutable(std::shared_ptr<const T>&& s)
        : ptr(std::move(s)) {}
 
    std::shared_ptr<const T> ptr;
 
    template <class S> friend class Immutable;
 
    // NOLINTNEXTLINE(readability-redundant-declaration)
    template <class S, class U> friend Immutable<S> staticImmutableCast(const Immutable<U>&);
};
 
template <class S, class U>
Immutable<S> staticImmutableCast(const Immutable<U>& u) {
    return Immutable<S>(std::static_pointer_cast<const S>(u.ptr));
}
 
template <class T, class Fn>
void mutate(Immutable<T>& immutable, Fn&& fn) {
    Mutable<T> mut = makeMutable<T>(*immutable);
    std::forward<Fn>(fn)(*mut);
    immutable = std::move(mut);
}
 
} // namespace mbgl