ref_any.h

/*******************************************************************************
 * Copyright (C) 2015-2021 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_sptr m_type;
        
        int m_owners;
        
        Referenced_data(Referenced_buffer* buffer, void* data, Datatype_sptr 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_sptr type, bool readable, bool writable):
            m_data{data},
            m_type{type},
            m_owners{0}
        {
            assert(data);
            m_buffer = new Referenced_buffer{[data, freefunc, type]()
            {
                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:
    Datatype_sptr 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:
    template<bool OR, bool OW>
    friend class Ref_any;
    
    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_sptr 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()
    {
        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
    {
        return this->operator[](member_name.c_str());
    }
    
    Ref operator[] (const char* member_name) const
    {
        if (is_null()) {
            throw Type_error{"Cannot access member from empty Ref: `{}'", member_name};
        }
        std::pair<void*, Datatype_sptr> subref_info = type()->member(member_name, m_content->m_data);
        Ref result;
        result.link(new Referenced_data(
                m_content->m_buffer,
                subref_info.first,
                std::move(subref_info.second)));
        return result;
    }
    
    template<class T>
    std::enable_if_t<std::is_integral<T>::value, Ref> operator[] (T index) const
    {
        if (is_null()) {
            throw Type_error{"Cannot access array index from empty Ref: `{}'", index};
        }
        std::pair<void*, Datatype_sptr> subref_info = type()->index(index, m_content->m_data);
        Ref result;
        result.link(new Referenced_data(
                m_content->m_buffer,
                subref_info.first,
                std::move(subref_info.second)));
        return result;
    }
    
    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: `{}:{}'", slice.first, slice.second);
        }
        std::pair<void*, Datatype_sptr> subref_info = type()->slice(slice.first, slice.second, m_content->m_data);
        Ref result;
        result.link(new Referenced_data(
                m_content->m_buffer,
                subref_info.first,
                std::move(subref_info.second)));
        return result;
    }
    
    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() const
    {
        static_assert(R, "Cannot get scalar_value from Ref without read access");
        if (auto&& scalar_type = std::dynamic_pointer_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 || W && content->m_buffer->m_write_locks) {
            if (content->m_owners == 0) delete content;
            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_