property_holder.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.TXT for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 * or you may search the http://www.gnu.org website for the version 32 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef PROPERTY_HOLDER_H
#define PROPERTY_HOLDER_H
 
#include <any>
#include <string>
#include <unordered_map>
#include <type_traits>
#include <optional>
#include <concepts>
#include <cstdint>
 
 
template<typename T>
concept PropertyValueType = std::copy_constructible<T> && std::destructible<T>;
 
class PROPERTY_HOLDER
{
public:
    static constexpr uint64_t MAGIC_VALUE = 0x50524F5048444C52ULL;
 
    PROPERTY_HOLDER() :
            m_magic( MAGIC_VALUE )
    {
    }
 
    PROPERTY_HOLDER( const PROPERTY_HOLDER& other ) :
            m_magic( MAGIC_VALUE ),
            m_properties( other.m_properties )
    {
    }
 
    PROPERTY_HOLDER( PROPERTY_HOLDER&& other ) noexcept :
            m_magic( MAGIC_VALUE ),
            m_properties( std::move( other.m_properties ) )
    {
    }
 
    PROPERTY_HOLDER& operator=( const PROPERTY_HOLDER& other )
    {
        if( this != &other )
            m_properties = other.m_properties;
 
        return *this;
    }
 
    PROPERTY_HOLDER& operator=( PROPERTY_HOLDER&& other ) noexcept
    {
        if( this != &other )
            m_properties = std::move( other.m_properties );
 
        return *this;
    }
 
    ~PROPERTY_HOLDER()
    {
        m_magic = 0xDEADBEEFDEADBEEFULL; // Clear magic to detect use-after-free
    }
 
    bool IsValid() const noexcept { return m_magic == MAGIC_VALUE; }
 
    static PROPERTY_HOLDER* SafeCast( void* aPtr ) noexcept
    {
        if( !aPtr )
            return nullptr;
 
        try
        {
            PROPERTY_HOLDER* aCandidate = reinterpret_cast<PROPERTY_HOLDER*>( aPtr );
            if( aCandidate->m_magic == MAGIC_VALUE )
            {
                return aCandidate;
            }
        }
        catch( ... )
        {
            // Any exception means invalid memory
        }
        return nullptr;
    }
 
    static const PROPERTY_HOLDER* SafeCast( const void* aPtr ) noexcept
    {
        if( !aPtr )
            return nullptr;
 
        try
        {
            const PROPERTY_HOLDER* aCandidate = reinterpret_cast<const PROPERTY_HOLDER*>( aPtr );
            if( aCandidate->m_magic == MAGIC_VALUE )
            {
                return aCandidate;
            }
        }
        catch( ... )
        {
            // Any exception means invalid memory
        }
        return nullptr;
    }
 
    static bool SafeDelete( void* aPtr ) noexcept
    {
        PROPERTY_HOLDER* aHolder = SafeCast( aPtr );
 
        if( aHolder )
        {
            delete aHolder;
            return true;
        }
 
        return false;
    }
 
    static bool SafeDelete( PROPERTY_HOLDER* aHolder ) noexcept
    {
        if( aHolder )
        {
            delete aHolder;
            return true;
        }
 
        return false;
    }
 
    template <typename T>
    bool SetProperty( const std::string& aKey, T&& aValue )
    {
        if( !IsValid() )
            return false;
 
        m_properties[aKey] = std::forward<T>( aValue );
        return true;
    }
 
    template <typename T>
    std::optional<T> GetProperty( const std::string& aKey ) const
    {
        if( !IsValid() )
            return std::nullopt;
 
        auto it = m_properties.find( aKey );
        if( it == m_properties.end() )
        {
            return std::nullopt;
        }
 
        try
        {
            return std::any_cast<T>( it->second );
        }
        catch( const std::bad_any_cast& )
        {
            return std::nullopt;
        }
    }
 
    template<typename T>
    T GetPropertyOr(const std::string& aKey, T&& aDefaultValue) const
    {
        if( auto aValue = GetProperty<T>( aKey ) )
            return *aValue;
 
        return std::forward<T>(aDefaultValue);
    }
 
    bool HasProperty( const std::string& aKey ) const
    {
        if( !IsValid() )
            return false;
 
        return m_properties.find( aKey ) != m_properties.end();
    }
 
    bool RemoveProperty( const std::string& aKey )
    {
        if( !IsValid() )
            return false;
 
        return m_properties.erase( aKey ) > 0;
    }
 
    bool Clear()
    {
        if( !IsValid() )
            return false;
 
        m_properties.clear();
        return true;
    }
 
    size_t Size() const
    {
        if( !IsValid() )
            return 0;
        return m_properties.size();
    }
 
    bool Empty() const
    {
        if( !IsValid() )
            return true;
        return m_properties.empty();
    }
 
    std::vector<std::string> GetKeys() const
    {
        if( !IsValid() )
            return {};
 
        std::vector<std::string> keys;
        keys.reserve( m_properties.size() );
 
        for( const auto& [key, value] : m_properties )
            keys.push_back( key );
 
        return keys;
    }
 
    std::optional<std::reference_wrapper<const std::type_info>> GetPropertyType( const std::string& aKey ) const
    {
        if( !IsValid() )
            return std::nullopt;
 
        auto it = m_properties.find( aKey );
 
        if( it == m_properties.end() )
            return std::nullopt;
 
        return std::cref( it->second.type() );
    }
 
    template <typename T>
    bool HasPropertyOfType( const std::string& aKey ) const
    {
        if( !IsValid() )
            return false;
 
        auto it = m_properties.find( aKey );
 
        if( it == m_properties.end() )
            return false;
 
        return it->second.type() == typeid( T );
    }
 
    template<PropertyValueType T>
    bool SetTypedProperty(const std::string& aKey, T&& aValue)
    {
        return SetProperty(aKey, std::forward<T>(aValue));
    }
 
private:
    uint64_t m_magic; 
    std::unordered_map<std::string, std::any> m_properties;
};
 
class PROPERTY_MIXIN
{
public:
    PROPERTY_HOLDER& GetPropertyHolder() { return m_propertyHolder; }
    const PROPERTY_HOLDER& GetPropertyHolder() const { return m_propertyHolder; }
 
    // Convenience methods that delegate to the property holder
    template<typename T>
    void SetProperty(const std::string& aKey, T&& aValue)
    {
        m_propertyHolder.SetProperty(aKey, std::forward<T>(aValue));
    }
 
    template<typename T>
    std::optional<T> GetProperty(const std::string& aKey) const
    {
        return m_propertyHolder.GetProperty<T>(aKey);
    }
 
    template<typename T>
    T GetPropertyOr(const std::string& aKey, T&& aDefaultValue) const
    {
        return m_propertyHolder.GetPropertyOr(aKey, std::forward<T>(aDefaultValue));
    }
 
    bool HasProperty(const std::string& aKey) const
    {
        return m_propertyHolder.HasProperty(aKey);
    }
 
    bool RemoveProperty(const std::string& aKey)
    {
        return m_propertyHolder.RemoveProperty(aKey);
    }
 
    template<typename T>
    bool HasPropertyOfType(const std::string& aKey) const
    {
        return m_propertyHolder.HasPropertyOfType<T>(aKey);
    }
 
private:
    PROPERTY_HOLDER m_propertyHolder;
};
 
#endif // PROPERTY_HOLDER_H