Final.h

Go to the documentation of this file.

/*
 * This file is a part of the Biology project by eons LLC.
 * Biology (aka Develop Biology) is a framework for approaching software
 * development from a natural sciences perspective.
 *
 * Copyright (C) 2022 Séon O'Shannon & eons LLC
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "bio/chemical/Substance.h"
 
namespace bio {
 
template < class CLASS>
class Final :
    public TransparentWrapper< CLASS >
{
public:
 
    Final() :
        TransparentWrapper< CLASS >(CLASS())
    {
    }
 
    explicit Final(const Name& name):
        TransparentWrapper< CLASS >(CLASS(name))
    {
    }
 
    explicit Final(const Id& id):
        TransparentWrapper< CLASS >(CLASS(id))
    {
    }
 
    ~Final() 
    {
 
    }
    
    //START: operators
 
    operator Id() const
    {
        return this->mT.operator Id();
    }
 
    operator Pointer< physical::Wave >()
    {
        return this->mT.operator Pointer< physical::Wave >();
    }
    
    template < typename AS >
    operator AS()
    {
        return this->mT.template As< AS >();
    }
    
    void operator|(Pointer< physical::Symmetry > symmetry)
    {
        return this->mT.operator|(symmetry);
    }
    
    Pointer< physical::Wave > operator*(Pointer< physical::Wave > signal)
    {
        return this->mT.operator*(signal);
    }
    
    Pointer< physical::Wave > operator*()
    {
        return this->mT.operator*();
    }
    
    Pointer< const physical::Wave > operator*() const
    {
        return this->mT.operator*();
    }
 
    void operator+(Pointer< const physical::Wave > other)
    {
        this->mT.operator+(other);
    }
 
    void operator-(Pointer< const physical::Wave > other)
    {
        return this->mT.operator-(other);
    }
 
    bool operator==(const Id id) const
    {
        return this->mT.operator==(id);
    }
 
    bool operator==(const Name& name) const
    {
        return this->mT.operator==(name);
    }
 
    bool operator==(const physical::Identifiable< Id >& other) const
    {
        return this->mT.operator==(other);
    }
    
    //END: operators
 
    //START: ...::Class<> methods
 
    Pointer< physical::Wave > Clone() const
    {
        return this->mT.Clone();
    }
    Pointer< physical::Wave > AsWave()
    {
        return this->mT.AsWave();
    }
    Pointer< const physical::Wave > AsWave() const
    {
        return this->mT.AsWave();
    }
    bool RegisterProperties(const Properties& properties)
    {
        return this->mT.RegisterProperties(properties);
    }
    Properties GetProperties() const 
    {
        return this->mT.GetProperties();
    }
    Pointer< chemical::Atom > AsAtom()
    {
        return this->mT.AsAtom();
    }
    Pointer< const chemical::Atom > AsAtom() const
    {
        return this->mT.AsAtom();
    }
    Pointer< physical::Wave > Modulate(Pointer< physical::Wave > signal)
    {
        return this->mT.Modulate(signal);
    }
    Pointer< physical::Wave > Demodulate()
    {
        return this->mT.Demodulate();
    }
    Pointer< const physical::Wave > Demodulate() const
    {
        return this->mT.Demodulate();
    }
    Code Attenuate(Pointer< const physical::Wave > other)
    {
        return this->mT.Attenuate(other);
    }
    Code Disattenuate(Pointer< const physical::Wave > other)
    {
        return this->mT.Disattenuate(other);
    }
    Pointer< const ::bio::log::Writer > AsLogWriter() const
    {
        return this->mT.AsLogWriter();
    }
    void Log(
        ::bio::LogLevel level,
        const char* format,
        va_list args
    ) const
    {
        return this->mT.Log(
            level,
            format,
            args
        );
}
    template < typename ENVIRONMENT >
    void SetEnvironment(Pointer< ENVIRONMENT > environment)
    {
        return this->mT.template SetEnvironment< ENVIRONMENT >(environment);
    }
    template < typename ENVIRONMENT >
    Pointer< ENVIRONMENT > GetEnvironment()
    {
        return this->mT.template GetEnvironment< ENVIRONMENT >();
    }
    template < typename ENVIRONMENT >
    const Pointer< ENVIRONMENT > GetEnvironment() const
    {
        return this->mT.template GetEnvironment< ENVIRONMENT >();
    }
 
    //END: ...::Class<> methods
 
    //START: chemical::UnorderedStructureInterface methods
 
    template < typename T >
    T Add(const T t)
    {
        return this->mT.template Add< T >(t);
    }
 
    template < typename T >
    Code Remove(const T t)
    {
        return this->mT.template Remove< T >(t);
    }
 
    template < typename T >
    void Import(Pointer< const chemical::UnorderedMotif< T > > other)
    {
        return this->mT.template Import< T >(other);
    }
 
    template < typename T >
    void Import(Pointer< const chemical::LinearMotif< T > > other)
    {
        return this->mT.template Import< T >(other);
    }
 
    template < typename T >
    void Import(const ::bio::Arrangement< T >& other)
    {
        return this->mT.template Import< T >(other);
    }
 
    Code ImportAll(Pointer< const physical::Wave > other)
    {
        return this->mT.ImportAll(other);
    }
 
    template < typename T >
    Index GetCount() const
    {
        return this->mT.template GetCount< T >();
    }
 
    template < typename T >
    Pointer< Container > GetAll()
    {
        return this->mT.template GetAll< T >();
    }
 
    template < typename T >
    Pointer< const Container > GetAll() const
    {
        return this->mT.template GetAll< T >();
    }
 
    template < typename T >
    bool Has(T content) const
    {
        return this->mT.template Has< T >(content);
    }
 
    template < typename T >
    unsigned int GetNumMatching(Pointer< const Container > other) const
    {
        return this->mT.template GetNumMatching< T >(other);
    }
 
    template < typename T >
    bool HasAll(Pointer< const Container > contents) const
    {
        return this->mT.template HasAll< T >(contents);
    }
 
    template < typename T >
    void Clear()
    {
        return this->mT.template Clear< T >();
    }
 
    template < typename T >
    std::string GetStringFrom(std::string separator = ", ")
    {
        return this->mT.template GetStringFrom< T >(separator);
    }
 
    template < typename T >
    void Log()
    {
        return this->mT.template Log< T >();
    }
 
    //END: chemical::UnorderedStructureInterface methods
 
    //START: chemical::LinearStructureInterface methods
 
    template < typename T >
    Code Insert(
        T toAdd,
        const Position position = BOTTOM,
        const Id optionalPositionArg = 0,
        const bool transferSubContents = false
    )
    {
        return this->mT.template Insert< T >(
            toAdd,
            position,
            optionalPositionArg,
            transferSubContents
        );
    }
 
    template < typename T >
    T GetById(const Id& id)
    {
        return this->mT.template GetById< T >(id);
    }
 
    template < typename T >
    const T GetById(const Id& id) const
    {
        return this->mT.template GetById< T >(id);
    }
 
    template < typename T >
    T GetByName(const Name& name)
    {
        return this->mT.template GetByName< T >(name);
    }
 
    template < typename T >
    const T GetByName(const Name& name) const
    {
        return this->mT.template GetByName< T >(name);
    }
 
    template < typename T >
    T GetOrCreateById(const Id& id)
    {
        return this->mT.template GetOrCreateById< T >(id);
    }
 
    template < typename T >
    T GetOrCreateByName(const Name& name)
    {
        return this->mT.template GetOrCreateByName< T >(name);
    }
 
    template < typename T >
    chemical::Emission ForEach(Pointer< chemical::ExcitationBase > excitation)
    {
        return this->mT.template ForEach< T >(excitation);
    }
 
    //END: chemical::LinearStructureInterface methods
 
    //START: chemical::Substance methods
 
    void Enable() 
    {
        return this->mT.Enable();
    }
    void Disable() 
    {
        return this->mT.Disable();
    }
    bool IsEnabled() const 
    {
        return this->mT.IsEnabled();
    }
 
    //END: chemical::Substance methods
 
    //START: chemical::Atom methods
 
    template < typename T >
    T As()
    {
        return this->mT.template As< T >();
    }
 
    template < typename T >
    const T As() const
    {
        return this->mT.template As< T >();
    }
 
    template < typename T >
    bool FormBond(
        T toBond,
        BondType type = bond_type::Unknown())
    {
        return this->mT.template FormBond< T >(toBond, type);
    }
 
    template < typename T >
    bool BreakBond(
        T toDisassociate,
        BondType type = bond_type::Unknown())
    {
        return this->mT.template BreakBond< T >(toDisassociate, type);
    }
 
    // Final<>::GetAllBonds is a thin shim around chemical::Atom::GetAllBonds,
    // which is BIO_DEPRECATED at v6 per RFC_ATOM_THREADSAFE_BOND_LOCK.md §5.
    // We mark the Final<> shim BIO_DEPRECATED too so external consumers
    // see one warning per call site, then suppress the diagnostic on the
    // shim body so the forwarding call itself doesn't double-warn.
    #if defined(__GNUC__) || defined(__clang__)
        #pragma GCC diagnostic push
        #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    #endif
    BIO_DEPRECATED("Use Final<>::ForEachBond / ForEachBondMutable; GetAllBonds bypasses the per-Atom lock. See RFC_ATOM_THREADSAFE_BOND_LOCK.md §5.")
    Pointer< chemical::Bonds > GetAllBonds()
    {
        return this->mT.GetAllBonds();
    }
 
    BIO_DEPRECATED("Use Final<>::ForEachBond / ForEachBondMutable; GetAllBonds bypasses the per-Atom lock. See RFC_ATOM_THREADSAFE_BOND_LOCK.md §5.")
    Pointer< const chemical::Bonds > GetAllBonds() const
    {
        return this->mT.GetAllBonds();
    }
    #if defined(__GNUC__) || defined(__clang__)
        #pragma GCC diagnostic pop
    #endif
 
    //END: chemical::Atom methods
 
    //START: log::Writer methods
 
    void Log(
        LogLevel level,
        const char* format,
        ...
    ) const
    {
        va_list args;
        va_start(args, format);
        this->mT.Log(level, format, args);
        va_end(args);
    }
 
    //END: log::Writer methods
 
    //START: physical::Identifiable< Id > methods
 
    Name GetName() const 
    {
        return this->mT.GetName();
    }
 
    Id GetId() const
    {
        return this->mT.GetId();
    }
 
    void SetName(const Name& name)
    {
        return this->mT.SetName(name);
    }
 
    void SetId(const Id& id)
    {
        return this->mT.SetId(id);
    }
    
    bool IsName(const Name& name) const
    {
        return this->mT.IsName(name);
    }
    
    bool IsNameInsensitive(const Name& name) const
    {
        return this->mT.IsNameInsensitive(name);
    }
    
    bool IsId(const Id& id) const
    {
        return this->mT.IsId(id);
    }
    
    void SetPerspective(Pointer< physical::Perspective< Id > > perspective)
    {
        return this->mT.SetPerspective(perspective);
    }
    
    void MakeWave(bool force = false) 
    {
        return this->mT.MakeWave();
    }
 
    Pointer< physical::Perspective< Id > > GetPerspective() const
    {
        return this->mT.GetPerspective();
    }
 
    //END: physical::Identifiable< Id > methods
 
    //START: physical::Wave methods (some of these defined above).
 
    Pointer< const physical::Symmetry > Spin() const
    {
        return this->mT.Spin();
    }
 
    Code Reify(Pointer< const physical::Symmetry > symmetry)
    {
        return this->mT.Reify(symmetry);
    }
 
    //END: physical::Wave methods
};
 
} //bio namespace