ref_any.h

/*******************************************************************************
 * Copyright (C) 2015-2019 Commissariat a l'energie atomique et aux energies alternatives (CEA)
 * Copyright (C) 2020-2021 Institute of Bioorganic Chemistry Polish Academy of Science (PSNC)
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * * Neither the name of CEA nor the names of its contributors may be used to
 *   endorse or promote products derived from this software without specific
 *   prior written permission.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 ******************************************************************************/

#ifndef PDI_REF_ANY_H_
#define PDI_REF_ANY_H_

#include <algorithm>
#include <cassert>
#include <functional>
#include <memory>
#include <new>
#include <unordered_map>

#include <pdi/array_datatype.h>
#include <pdi/pdi_fwd.h>
#include <pdi/datatype.h>
#include <pdi/error.h>
#include <pdi/record_datatype.h>
#include <pdi/scalar_datatype.h>


namespace PDI {

namespace {

template<bool R, bool W>
struct Ref_access {
    typedef void type;
};

template<bool R>
struct Ref_access<R, true> {
    typedef void* type;
};

template<>
struct Ref_access<true, false> {
    typedef const void* type;
};

} //namespace <anonymous>


class PDI_EXPORT Reference_base
{
protected:

    struct PDI_NO_EXPORT Referenced_buffer {
    
        std::function<void()> m_delete;
        
        int m_owners;
        
        int m_read_locks;
        
        int m_write_locks;
        
        std::unordered_map<const Reference_base*, std::function<void(Ref)> > m_notifications;
        
        Referenced_buffer(std::function<void()> deleter, bool readable, bool writable) noexcept:
            m_delete{deleter},
                 m_owners{0},
                 m_read_locks{readable ? 0 : 1},
                 m_write_locks{writable ? 0 : 1}
        {}
        
        
        Referenced_buffer() = delete;
        
        Referenced_buffer(const Referenced_buffer&) = delete;
        
        Referenced_buffer(Referenced_buffer&&) = delete;
        
        ~Referenced_buffer()
        {
            m_delete();
            assert(!m_owners);
            assert(m_read_locks == 0 || m_read_locks == 1);
            assert(m_write_locks == 0 || m_write_locks == 1);
            assert(m_notifications.empty());
        }
        
    };
    
    struct PDI_NO_EXPORT Referenced_data {
    
        mutable Referenced_buffer* m_buffer;
        
        void* m_data;
        
        Datatype_uptr m_type;
        
        int m_owners;
        
        Referenced_data(Referenced_buffer* buffer, void* data, Datatype_uptr type):
            m_buffer{buffer},
            m_data{data},
            m_type{std::move(type)},
            m_owners{0}
        {
            assert(buffer);
            assert(data);
            m_buffer->m_owners++;
        }
        
        Referenced_data(void* data, std::function<void(void*)> freefunc, Datatype_uptr type, bool readable, bool writable):
            m_data{data},
            m_type{std::move(type)},
            m_owners{0}
        {
            assert(data);
            std::shared_ptr<Datatype> cloned_type = m_type->clone_type(); // cannot use uptr, because std::function must be CopyConstructible
            m_buffer = new Referenced_buffer{[data, freefunc, cloned_type]() mutable {
                    cloned_type->destroy_data(data);
                    freefunc(data);
                }, readable, writable};
            m_buffer->m_owners++;
        }
        
        Referenced_data() = delete;
        
        Referenced_data(const Referenced_data&) = delete;
        
        Referenced_data(Referenced_data&&) = delete;
        
        ~Referenced_data()
        {
            m_buffer->m_owners--;
            if (m_buffer->m_owners == 0) {
                delete m_buffer;
            }
        }
    };
    
    
    mutable Referenced_data* m_content;
    
    
    static Referenced_data PDI_NO_EXPORT* get_content(const Reference_base& other) noexcept
    {
        if ( !other.m_content ) return NULL;
        if ( !other.m_content->m_data ) return NULL;
        return other.m_content;
    }
    
    // Symbol should not be exported, but it required to force
    // generation of all 4 variants of `Ref_any::copy`
    static Ref do_copy(Ref_r ref);
    
    Reference_base() noexcept:
        m_content(nullptr)
    {}
    
    Reference_base(const Reference_base&) = delete;
    
    Reference_base(Reference_base&&) = delete;
    
    Reference_base& operator = (const Reference_base&) = delete;
    
    Reference_base& operator = (Reference_base&&) = delete;
    
public:
    const Datatype& type() const noexcept;
    
    size_t hash() const noexcept
    {
        return std::hash<Referenced_data*>()(get_content(*this));
    }
    
}; // class Data_ref_base


template<bool R, bool W>
class PDI_EXPORT Ref_any:
    public Reference_base
{
public:
    Ref_any() = default;
    
    Ref_any(const Ref_any& other) noexcept:
        Reference_base()
    {
        link(get_content(other));
    }
    
    template<bool OR, bool OW>
    Ref_any(const Ref_any<OR, OW>& other) noexcept:
        Reference_base()
    {
        link(get_content(other));
    }
    
    Ref_any(Ref_any&& other) noexcept:
        Reference_base()
    {
        if (!other.m_content) return;
        // the other ref notification disappears
        other.m_content->m_buffer->m_notifications.erase(&other);
        // since we get the same privileges as those we release we can just steal the content
        m_content = other.m_content;
        other.m_content = nullptr;
    }
    
    Ref_any(void* data, std::function<void(void*)> freefunc, Datatype_uptr type, bool readable, bool writable):
        Reference_base()
    {
        if (type->datasize() && !data && (readable||writable)) {
            throw Type_error{"Referencing null data with non-null size"};
        }
        if (data) {
            link(new Referenced_data(data, freefunc, std::move(type), readable,  writable));
        }
    }
    
    Ref_any(Ref other, const Datatype::Accessor_base& accessor):
        Reference_base()
    {
        if (other) {
            std::pair<void*, Datatype_uptr> subref_info = other.type().subaccess(get_content(other)->m_data, accessor);
            link(new Referenced_data(
                    get_content(other)->m_buffer,
                    subref_info.first,
                    std::move(subref_info.second)));
        }
    }
    
    Ref_any(Ref other, const std::vector<std::unique_ptr<Datatype::Accessor_base>>& accessors):
        Reference_base()
    {
        if (other) {
            std::pair<void*, Datatype_uptr> subref_info = other.type().subaccess(get_content(other)->m_data, accessors);
            link(new Referenced_data(
                    get_content(other)->m_buffer,
                    subref_info.first,
                    std::move(subref_info.second)));
        }
    }
    
    ~Ref_any()
    {
        reset();
    }
    
    Ref_any& operator= (Ref_any&& other) noexcept
    {
        // self-copy: nothing to do
        if (&other ==  this) return *this;
        // we'll be copied into, start nullifying ourselves first
        reset();
        // if the other is null also, we're done
        if (other.is_null()) return *this;
        // the other ref notification disappears
        other.m_content->m_buffer->m_notifications.erase(&other);
        // since we get the same privileges as those we release we can just steal the content
        m_content = other.m_content;
        other.m_content = nullptr;
        return *this;
    }
    
    Ref_any& operator= (const Ref_any& other) const noexcept
    {
        // self-copy: nothing to do
        if (&other ==  this) return *this;
        // we'll be copied into, start nullifying ourselves first
        reset();
        // and copy the content from the other
        link(get_content(other));
        return *this;
    }
    
    bool operator== (const Reference_base& o) const noexcept
    {
        is_null();
        return m_content == get_content(o);
    }
    
    bool operator!= (const Reference_base& o) const noexcept
    {
        is_null();
        return m_content != get_content(o);
    }
    
    bool operator<  (const Reference_base& o) const noexcept
    {
        is_null();
        return m_content < get_content(o);
    }
    
    bool operator>  (const Reference_base& o) const noexcept
    {
        is_null();
        return m_content > get_content(o);
    }
    
    bool operator<= (const Reference_base& o) const noexcept
    {
        is_null();
        return m_content <= get_content(o);
    }
    
    bool operator>= (const Reference_base& o) const noexcept
    {
        is_null();
        return m_content >= get_content(o);
    }
    
    Ref operator[] (const std::string& member_name) const
    {
        if (is_null()) {
            throw Type_error{"Cannot access member from empty Ref: `{}'", member_name};
        }
        return Ref{*this, Record_datatype::Member_accessor{member_name}};
    }
    
    Ref operator[] (const char* member_name) const
    {
        return this->operator[](std::string(member_name));
    }
    
    Ref operator[] (std::size_t index) const
    {
        if (is_null()) {
            throw Type_error{"Cannot access array index from empty Ref: `{}'", index};
        }
        return Ref{*this, Array_datatype::Index_accessor{index}};
    }
    
    Ref operator[] (std::pair<std::size_t, std::size_t> slice) const
    {
        if (is_null()) {
            throw Type_error{"Cannot access array slice from empty Ref: `{}'", index};
        }
        return Ref{*this, Array_datatype::Slice_accessor{slice.first, slice.second}};
    }
    
    operator typename Ref_access<R, W>::type() const
    {
        return get();
    }
    
    typename Ref_access<R, W>::type get() const
    {
        if (is_null()) throw Right_error{"Trying to dereference a null reference"};
        return m_content->m_data;
    }
    
    typename Ref_access<R, W>::type get(std::nothrow_t) const noexcept
    {
        if (is_null()) return nullptr;
        return m_content->m_data;
    }
    
    template<class T>
    T scalar_value()
    {
        static_assert(R, "Cannot get scalar_value from Ref without read access");
        if (const Scalar_datatype* scalar_type = dynamic_cast<const Scalar_datatype*>(&type())) {
            if (scalar_type->kind() == PDI::Scalar_kind::UNSIGNED) {
                switch (scalar_type->buffersize()) {
                case 1L:
                    return *static_cast<const uint8_t*>(m_content->m_data);
                case 2L:
                    return *static_cast<const uint16_t*>(m_content->m_data);
                case 4L:
                    return *static_cast<const uint32_t*>(m_content->m_data);
                case 8L:
                    return *static_cast<const uint64_t*>(m_content->m_data);
                default:
                    throw Type_error{"Unknown size of unsigned integer datatype"};
                }
            } else if (scalar_type->kind() == PDI::Scalar_kind::SIGNED) {
                switch (scalar_type->buffersize()) {
                case 1L:
                    return *static_cast<const int8_t*>(m_content->m_data);
                case 2L:
                    return *static_cast<const int16_t*>(m_content->m_data);
                case 4L:
                    return *static_cast<const int32_t*>(m_content->m_data);
                case 8L:
                    return *static_cast<const int64_t*>(m_content->m_data);
                default:
                    throw Type_error{"Unknown size of integer datatype"};
                }
            } else if (scalar_type->kind() == PDI::Scalar_kind::FLOAT) {
                switch (type().buffersize()) {
                case 4L: {
                    return *static_cast<const float*>(m_content->m_data);
                }
                case 8L: {
                    return *static_cast<const double*>(m_content->m_data);
                }
                default:
                    throw Type_error{"Unknown size of float datatype"};
                }
            } else {
                throw Type_error{"Unknown datatype to get value"};
            }
        }
        throw Type_error{"Expected scalar, found invalid type instead: {}", type().debug_string()};
    }
    
    operator bool () const noexcept
    {
        return !is_null();
    }
    
    void reset() noexcept
    {
        if (m_content) unlink();
    }
    
    Ref copy() const
    {
        return do_copy(*this);
    }
    
    void* release() noexcept
    {
        if (is_null()) return nullptr;
        
        // notify everybody of the nullification
        while (!m_content->m_buffer->m_notifications.empty()) {
            // get the key of a notification
            const Reference_base* key = m_content->m_buffer->m_notifications.begin()->first;
            // call this notification, this might invalidate any iterator
            m_content->m_buffer->m_notifications.begin()->second(*this);
            // remove the notification we just called
            m_content->m_buffer->m_notifications.erase(key);
        }
        
        void* result = m_content->m_data;
        m_content->m_data = nullptr;
        m_content->m_buffer->m_delete = []() {}; // Referenced_metadata won't delete data
        
        unlink();
        
        return result;
    }
    
    void on_nullify(std::function<void(Ref)> notifier) const noexcept
    {
        if (!is_null()) m_content->m_buffer->m_notifications[this] = notifier;
    }
    
private:
    bool PDI_NO_EXPORT is_null() const noexcept
    {
        if (!m_content) return true;
        if (!m_content->m_data) {
            unlink();
            return true;
        }
        return false;
    }
    
    void PDI_NO_EXPORT unlink() const noexcept
    {
        assert(m_content);
        m_content->m_buffer->m_notifications.erase(this);
        if (R || W) --m_content->m_buffer->m_write_locks;
        if (W) --m_content->m_buffer->m_read_locks;
        --m_content->m_owners;
        if (!m_content->m_owners) delete m_content;
        m_content = nullptr;
    }
    
    void PDI_NO_EXPORT link(Referenced_data* content) noexcept
    {
        assert(!m_content);
        if (!content || !content->m_data) return; // null ref
        if (R && content->m_buffer->m_read_locks) return;
        if (W && content->m_buffer->m_write_locks) return;
        m_content = content;
        ++m_content->m_owners;
        if (R || W) ++m_content->m_buffer->m_write_locks;
        if (W) ++m_content->m_buffer->m_read_locks;
    }
    
};

} // namespace PDI

namespace std {

template<bool R, bool W>
struct hash<PDI::Ref_any<R,W>> {
    size_t operator() (const PDI::Ref_any<R,W>& r) const noexcept
    {
        return r.hash();
    }
};

} // namespace std

#endif //  PDI_REF_ANY_H_