Plug.h

//  trax track library
//  AD 2014 
//
//  "If you have a message - go to the post office."
//
//                              Alfred Hitchcock
//
// Copyright (c) 2025 Trend Redaktions- und Verlagsgesellschaft mbH
// Copyright (c) 2019 Marc-Michael Horstmann
//
// Permission is hereby granted to any person obtaining a copy of this software 
// and associated source code (the "Software"), to use, view, and study the 
// Software for personal or internal business purposes, subject to the following 
// conditions:
//
// 1. Redistribution, modification, sublicensing, or commercial use of the 
// Software is NOT permitted without prior written consent from the copyright 
// holder.
//
// 2. The Software is provided "AS IS", without warranty of any kind, express 
// or implied.
//
// 3. All copies of the Software must retain this license notice.
//
// For further information, please contact: horstmann.marc@trendverlag.de
 
#pragma once
 
#include "Identified.h"
#include "Jack.h"
#include "Units.h"
 
#include <vector>
#include <algorithm>
#include <sstream>
 
#if defined(_MSC_VER)
#   pragma warning(disable: 4250) // virtual inheritance of methods via dominance
#endif
 
namespace trax{
 
    struct PlugEnumerator;
    struct SocketRegistry;

    struct Plug : Identified<Plug>
    {
        virtual const char* TypeName() const noexcept = 0;
 

        virtual Jack* Plugged() const noexcept = 0;
 

        virtual bool IsCyclic() const noexcept = 0;
 

        virtual const Plug& Tail() const = 0;
 

        virtual Plug& Tail() = 0;
 

        virtual Jack& JackOnPulse() noexcept = 0;
 

        virtual const Jack& JackOnPulse() const noexcept = 0;
 

        virtual PlugEnumerator& Parent() const noexcept = 0;
 

        virtual void Remove() noexcept = 0;
    protected:
        friend class Jack_Imp;
 
        virtual void Pulse( bool /*bForewardToJack*/ ) noexcept{}
 
        virtual void Release() noexcept{}
 
        virtual void ConnectTo( Jack& /*jack*/ ) noexcept{}
    };
 
    dclspc const Plug* GetFirstNonZeroIDPlugInChain( const Plug& plug );
 

    struct PlugEnumerator{

        typedef PlugEnumerator  collection_type;
        typedef Plug            value_type;
 

        Plug& GetPlug( int idx ){
            return const_cast<Plug&>(_GetPlug( idx ));
        }
 
        const Plug& GetPlug( int idx ) const{
            return _GetPlug( idx );
        }
 

        virtual int CountPlugs() const = 0;
 
        virtual ~PlugEnumerator() = default;
    protected:
        PlugEnumerator( const PlugEnumerator& ) = default;
        PlugEnumerator( PlugEnumerator&& ) = default;
        PlugEnumerator& operator=( const PlugEnumerator& ) = default;
        PlugEnumerator& operator=( PlugEnumerator&& ) = default;
        PlugEnumerator() = default;
 

        virtual const Plug& _GetPlug( int idx ) const = 0;
    };
 
 
    template<   class EnumeratorType,
                class PointerType = Plug*,
                class ReferenceType = Plug&>
    class PlugIterator{// : public std::iterator<std::random_access_iterator_tag, Plug, ptrdiff_t, PointerType, ReferenceType>{
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = Plug;
        using difference_type = ptrdiff_t;
        using pointer = PointerType;
        using reference = ReferenceType;

        PlugIterator( EnumeratorType& Container, bool bEnd = false )
            :   m_Container( Container ),
                m_IndexCurrent( bEnd ? Container.CountPlugs() : 0 )
        {}

        PlugIterator& operator++() noexcept{
            ++m_IndexCurrent;
            return *this;
        }
 
        PlugIterator operator++( int ) noexcept{
            PlugIterator retval( *this );
            operator++();
            return retval;
        }
 
        ReferenceType operator*() const{
            return m_Container.GetPlug( m_IndexCurrent );
        }
 
        PlugIterator& operator--() noexcept{
            --m_IndexCurrent;
            return *this;
        }
 
        PlugIterator operator--( int ) noexcept{
            PlugIterator retval( *this );
            operator--();
            return retval;
        }
 
        ReferenceType operator[]( int n ) const{
            return m_Container.GetPlug( m_IndexCurrent + n );
        }
 
        ReferenceType operator->() const{
            return m_Container.GetPlug( m_IndexCurrent );
        }
 
        bool operator==( const PlugIterator& iter ) const noexcept{
            assert( &m_Container == &iter.m_Container );
            return m_IndexCurrent == iter.m_IndexCurrent;
        }
 
        bool operator!=( const PlugIterator& iter ) const noexcept{
            assert( &m_Container == &iter.m_Container );
            return m_IndexCurrent != iter.m_IndexCurrent;
        }
 
        bool operator<( const PlugIterator& iter ) const noexcept{
            assert( &m_Container == &iter.m_Container );
            return m_IndexCurrent < iter.m_IndexCurrent;
        }
 
        bool operator<=( const PlugIterator& iter ) const noexcept{
            assert( &m_Container == &iter.m_Container );
            return m_IndexCurrent <= iter.m_IndexCurrent;
        }
 
        bool operator>( const PlugIterator& iter ) const noexcept{
            assert( &m_Container == &iter.m_Container );
            return m_IndexCurrent > iter.m_IndexCurrent;
        }
 
        bool operator>=( const PlugIterator& iter ) const noexcept{
            assert( &m_Container == &iter.m_Container );
            return m_IndexCurrent >= iter.m_IndexCurrent;
        }
 
        void operator+=( int n ) noexcept{
            m_IndexCurrent += n;
        }
 
        void operator-=( int n ) noexcept{
            m_IndexCurrent -= n;
        }
 
        PlugIterator operator+( int n ) const noexcept{
            PlugIterator iter( *this );
            iter.m_IndexCurrent += n;
        }
 
        PlugIterator operator-( int n ) const noexcept{
            PlugIterator iter( *this );
            iter.m_IndexCurrent -= n;
        }
    private:
        EnumeratorType& m_Container;
        int m_IndexCurrent;
    };
 
    inline PlugIterator<PlugEnumerator> begin( PlugEnumerator& plugEnumerator ){
        return PlugIterator<PlugEnumerator>( plugEnumerator );
    }
 
    inline PlugIterator<const PlugEnumerator, const Plug*, const Plug&> begin( const PlugEnumerator& plugEnumerator ){
        return PlugIterator<const PlugEnumerator, const Plug*, const Plug&>( plugEnumerator );
    }
 
    inline PlugIterator<PlugEnumerator> end( PlugEnumerator& plugEnumerator ){
        return PlugIterator<PlugEnumerator>( plugEnumerator, true );
    }
 
    inline PlugIterator<const PlugEnumerator, const Plug*, const Plug&> end( const PlugEnumerator& plugEnumerator ){
        return PlugIterator<const PlugEnumerator, const Plug*, const Plug&>( plugEnumerator, true );
    }
 

    struct MultiPlug :  virtual Plug,
                        PlugEnumerator
    {
        using Plug::ID;
 
        using Plug::Reference;

        virtual Plug& Make( SocketRegistry* pRegistry = nullptr ) = 0;
 

        virtual Plug& Unplugged( SocketRegistry* pRegistry = nullptr ) = 0;
 

        virtual void Release( Plug& plug ) = 0;
 

        virtual void Clear() = 0;
    protected:
        using Plug::Release;
    };  
 
 
    class Plug_Imp : public ObjectID_Imp<Plug>,
                     public JackEnumerator {
    public:
        Plug_Imp() = delete;
        Plug_Imp(const Plug_Imp& plug) = delete;
        dclspc Plug_Imp(Plug_Imp&& plug) noexcept;
        dclspc Plug_Imp(PlugEnumerator& parent);
        dclspc Plug_Imp(PlugEnumerator& parent, Plug_Imp&& plug);
 
        dclspc ~Plug_Imp() noexcept;    // TODO: if the user defines his own Plug_Imp derived Plug
                                        // and assigns a string by Reference() without using Reference 
                                        // again to delete it, the destructor will crash on trying to
                                        // delete the string in a different module.
                                        // User framework should be supplied independently from trax 
                                        // library implementation.  
 
        //~Plug_Imp() noexcept{
        //  Remove();
        //}
 
 
        Plug_Imp& operator=(Plug_Imp&) = delete;
        Plug_Imp& operator=(Plug_Imp&& plug) = delete;
 
        const char* TypeName() const noexcept override {
            return "Plug";
        }
 
        using ObjectID_Imp<Plug>::Reference;
 
        const std::string& Reference(const std::string& name) const override {
            return ObjectID_Imp<Plug>::Reference(name);
        }
 
        using ObjectID_Imp<Plug>::ID;
 
        IDType ID() const noexcept override {
            return ObjectID_Imp<Plug>::ID();
        }
 
        dclspc Jack* Plugged() const noexcept override;
 
        dclspc bool IsCyclic() const noexcept override;
 
        dclspc const Plug& Tail() const override;
 
        dclspc Plug& Tail() override;
 
        dclspc Jack& JackOnPulse() noexcept override;
 
        dclspc const Jack& JackOnPulse() const noexcept override;
 
        dclspc PlugEnumerator& Parent() const noexcept override;
 
        dclspc void Remove() noexcept;
 
        dclspc int CountJacks() const noexcept override;
    protected:
        dclspc void Pulse(bool bForewardToJack) noexcept override;
 
        dclspc const Jack& _GetJack(int idx) const override;
    private:
        friend class Jack_Imp;
        // Plug_Imp:
        dclspc void Release() noexcept override;
 
        dclspc void ConnectTo(Jack& jack) noexcept override;
 
        Jack* m_pPlugged;
        Jack_Imp m_JackOnPulse{ "JackOnPulse" };
        PlugEnumerator& m_Parent;
    };
 
 
    template<class ParentType>
    class Plug_Imp_Parent : public Plug_Imp {
    protected:
        ParentType& m_Parent;
    public:
        Plug_Imp_Parent() = delete;
        Plug_Imp_Parent(const Plug_Imp_Parent& plug) = delete;
        Plug_Imp_Parent(Plug_Imp_Parent&& plug) = default;
        Plug_Imp_Parent(ParentType& parent)
            : Plug_Imp{ parent },
            m_Parent{ parent }
        {}
        Plug_Imp_Parent(ParentType& parent, Plug_Imp_Parent&& plug)
            : Plug_Imp{ parent,std::move(plug) },
            m_Parent{ parent }
        {}
    };
 

    template<class ParentType>
    class Plug_Imp_ParentPointer : public Plug_Imp_Parent<ParentType> {
#if defined(_MSC_VER) && !defined(_WIN64)
#   pragma pack(push, 4) // alignment of a member was sensitive to packing
#endif
        void (ParentType::* m_pPulseFunction)() = nullptr;
#if defined(_MSC_VER) && !defined(_WIN64)
#   pragma pack(pop)
#endif
    public:
        using TargetType = ParentType;
 
        Plug_Imp_ParentPointer() = delete;
        Plug_Imp_ParentPointer(const Plug_Imp_ParentPointer& plug) = delete;
        Plug_Imp_ParentPointer(Plug_Imp_ParentPointer&& plug) = default;
 
        Plug_Imp_ParentPointer(ParentType& parent, void (ParentType::* pPulseFunction)() noexcept )
            : Plug_Imp_Parent<ParentType>{ parent },
            m_pPulseFunction{ pPulseFunction }
        {
            //static_assert( std::is_convertible<Plug_Imp_ParentPointer*,PlugEnumerator*>::value );
            assert(m_pPulseFunction);
        }
        Plug_Imp_ParentPointer(ParentType& parent, void (ParentType::* pPulseFunction)() noexcept, Plug_Imp_ParentPointer&& plug)
            : Plug_Imp_Parent<ParentType>{ parent, std::move(plug) },
            m_pPulseFunction{ pPulseFunction }
        {
            //static_assert( std::is_convertible<Plug_Imp_ParentPointer*,PlugEnumerator*>::value );
            assert(m_pPulseFunction);
        }
 
        Plug_Imp_ParentPointer& operator=(const Plug_Imp_ParentPointer&) = delete;
        Plug_Imp_ParentPointer& operator=(Plug_Imp_ParentPointer&&) = delete;
 
        void Pulse(bool bForewardToJack) noexcept override {
            (Plug_Imp_Parent<ParentType>::m_Parent.*m_pPulseFunction)();
            Plug_Imp_Parent<ParentType>::Pulse(bForewardToJack);
        }
    };
 
 
}