LinearMotif.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 "UnorderedMotif.h"
#include "bio/chemical/common/Cast.h"
#include "bio/chemical/common/Class.h"
#include "bio/chemical/common/Properties.h"
#include "bio/chemical/Elementary.h"
#include "bio/chemical/reaction/Excitation.h"
#include "bio/physical/arrangement/Line.h"
 
#if BIO_CPP_VERSION >= 11
    #include <type_traits>
#endif
 
namespace bio {
namespace chemical {
 
template < typename CONTENT_TYPE >
class LinearMotif :
    public Elementary< LinearMotif< CONTENT_TYPE > >,
    public chemical::Class< LinearMotif< CONTENT_TYPE > >,
    public UnorderedMotif< CONTENT_TYPE >
{
public:
 
    typedef typename physical::Line Contents;
 
    BIO_DISAMBIGUATE_REQUIRED_CLASS_METHODS(chemical,
        LinearMotif< CONTENT_TYPE >)
 
    BIO_DISAMBIGUATE_OPTIONAL_CLASS_METHODS(physical,
        LinearMotif< CONTENT_TYPE >)
 
    
    static Properties GetClassProperties()
    {
        Properties ret = AbstractMotif::GetClassProperties();
        ret.push_back(property::Linear());
        return ret;
    }
 
    explicit LinearMotif(physical::Perspective< StandardDimension >* perspective = NULL)
        :
        Elementary< LinearMotif< CONTENT_TYPE > >(GetClassProperties()),
        chemical::Class< LinearMotif< CONTENT_TYPE > >(this),
        m_perspective(perspective)
    {
        CtorCommon();
    }
 
    explicit LinearMotif(
        const Contents* contents,
        physical::Perspective< StandardDimension >* perspective = NULL
    )
        :
        Elementary< LinearMotif< CONTENT_TYPE > >(GetClassProperties()),
        chemical::Class< LinearMotif< CONTENT_TYPE > >(this),
        m_perspective(perspective)
    {
        CtorCommon();
        this->m_contents->Import(contents);
    }
 
    LinearMotif(const LinearMotif< CONTENT_TYPE >& toCopy)
        :
        Elementary< LinearMotif< CONTENT_TYPE > >(toCopy.GetClassProperties()),
        chemical::Class< LinearMotif< CONTENT_TYPE > >(this),
        m_perspective(toCopy.m_perspective)
    {
        CtorCommon();
        this->m_contents->Import(toCopy.GetAllImplementation());
    }
 
    virtual ~LinearMotif()
    {
        this->m_contents->Clear();
    }
 
    physical::Perspective< StandardDimension >* m_perspective;
 
    physical::Perspective< StandardDimension >* GetStructuralPerspective()
    {
        return m_perspective;
    }
 
    const physical::Perspective< StandardDimension >* GetStructuralPerspective() const
    {
        return m_perspective;
    }
 
    virtual CONTENT_TYPE AddImplementation(CONTENT_TYPE content)
    {
        return ChemicalCast< CONTENT_TYPE >(Cast< physical::Line* >(this->m_contents)->LinearAccess(this->m_contents->Add(content)));
    }
 
    virtual Code InsertImplementation(
        CONTENT_TYPE toAdd,
        const Position position = BOTTOM,
        const StandardDimension optionalPositionArg = 0, //i.e. invalid.
        const bool transferSubContents = false
    )
    {
        BIO_SANITIZE(toAdd, ,
            return code::MissingArgument1())
 
        Code ret = code::Success();
 
        SmartIterator toReplace(
            this->m_contents,
            InvalidIndex());
 
        //Remove conflicts
        for (
            SmartIterator cnt = this->m_contents->End();
            !cnt.IsAtBeginning();
            --cnt
            )
        {
            if (cnt.template As< CONTENT_TYPE >()->IsId(toAdd->GetId()))
            {
                //Not an error, but potentially worth noting.
                ret = code::SuccessfullyReplaced();
 
                toReplace = cnt;
                break; //Only find 1 conflict, as no others should exist.
            }
        }
 
        CONTENT_TYPE addition = CloneAndCast< CONTENT_TYPE >(toAdd);
        BIO_SANITIZE(addition, ,
            return code::GeneralFailure())
 
        if (this->m_contents->IsAllocated(toReplace.GetIndex())) //i.e. GetIndex() != 0.
        {
            if (transferSubContents)
            {
                //NOTE: THIS REMOVES ALL STRUCTURAL COMPONENTS IN toReplace
                // WHICH ARE NOT EXPLICITLY IN addition
                //This makes sense but is bound to be a bug at some point...
 
                CONTENT_TYPE toReplaceCasted = toReplace.template As< CONTENT_TYPE >();
                //addition->ImportAll(toReplaceCasted); //<- inaccessible, so we replicate the function here.
 
                Bond* bondBuffer;
                for (
                    SmartIterator bnd = addition->AsAtom()->GetAllBonds()->End();
                    !bnd.IsAtBeginning();
                    --bnd
                    )
                {
                    bondBuffer = bnd;
                    if (bondBuffer->IsEmpty())
                    {
                        continue;
                    }
                    if (physical::Wave::GetResonanceBetween(
                        bondBuffer->GetBonded(),
                        AbstractMotif::GetClassProperties()).size() == 0)
                    {
                        continue;
                    }
                    const physical::Wave* otherBond = toReplaceCasted->AsAtom()->GetBonded(toReplaceCasted->AsAtom()->GetBondPosition(bondBuffer->GetId()));
                    Cast< AbstractMotif* >(bondBuffer->GetBonded())->ImportImplementation(otherBond); //actual work
                }
            }
            this->m_contents->Erase(toReplace);
        }
 
        switch (position)
        {
            case TOP:
            {
                this->m_contents->Insert(
                    addition,
                    this->m_contents->GetBeginIndex());
                break;
            }
            case BEFORE:
            {
                Index placement = Cast< physical::Line* >(this->m_contents)->SeekToId(optionalPositionArg);
                if (!placement)
                {
                    return code::GeneralFailure();
                }
                BIO_SANITIZE(Cast< physical::Line* >(this->m_contents)->LinearAccess(placement)->GetPerspective() == addition->GetPerspective(), ,
                    return code::GeneralFailure());
 
                this->m_contents->Insert(
                    addition,
                    placement
                );
                break;
            }
            case AFTER:
            {
                Index placement = Cast< physical::Line* >(this->m_contents)->SeekToId(optionalPositionArg);
                if (!placement)
                {
                    return code::GeneralFailure();
                }
                BIO_SANITIZE(Cast< physical::Line* >(this->m_contents)->LinearAccess(placement)->GetPerspective() == addition->GetPerspective(), ,
                    return code::GeneralFailure());
 
                this->m_contents->Insert(
                    addition,
                    ++placement
                );
                break;
            }
            case BOTTOM:
            {
                this->m_contents->Insert(
                    addition,
                    this->m_contents->GetEndIndex());
                break;
            }
            default:
            {
                this->m_contents->Add(addition);
                break;
            }
        } //switch
 
        return ret;
    }
 
    virtual CONTENT_TYPE GetByIdImplementation(
        StandardDimension id
    )
    {
        Index ret = Cast< physical::Line* >(this->m_contents)->SeekToId(id);
        BIO_SANITIZE_AT_SAFETY_LEVEL_2(ret, ,
            return NULL) //level 2 for GetOrCreate.
 
        return ChemicalCast< CONTENT_TYPE >(Cast< physical::Line* >(this->m_contents)->LinearAccess(ret));
    }
 
    virtual const CONTENT_TYPE GetByIdImplementation(
        StandardDimension id
    ) const
    {
        Index ret = Cast< physical::Line* >(this->m_contents)->SeekToId(id);
        BIO_SANITIZE_AT_SAFETY_LEVEL_2(ret, ,
            return NULL) //level 2 for GetOrCreate.
 
        return ChemicalCast< CONTENT_TYPE >(Cast< physical::Line* >(this->m_contents)->LinearAccess(ret));
    }
 
 
    virtual CONTENT_TYPE GetByNameImplementation(
        Name name
    )
    {
        Index ret = Cast< physical::Line* >(this->m_contents)->SeekToName(name);
        BIO_SANITIZE_AT_SAFETY_LEVEL_2(ret, ,
            return NULL) //level 2 for GetOrCreate.
 
        return ChemicalCast< CONTENT_TYPE >(Cast< physical::Line* >(this->m_contents)->LinearAccess(ret));
    }
 
    virtual const CONTENT_TYPE GetByNameImplementation(
        Name name
    ) const
    {
        Index ret = Cast< physical::Line* >(this->m_contents)->SeekToName(name);
        BIO_SANITIZE_AT_SAFETY_LEVEL_2(ret, ,
            return NULL) //level 2 for GetOrCreate.
 
        return ChemicalCast< CONTENT_TYPE >(Cast< physical::Line* >(this->m_contents)->LinearAccess(ret));
    }
 
    virtual CONTENT_TYPE CreateImplementation(
        StandardDimension id
    )
    {
        BIO_SANITIZE(this->GetStructuralPerspective(), ,
            return NULL);
        return this->AddImplementation((this->GetStructuralPerspective()->template GetTypeFromIdAs< CONTENT_TYPE >(id)));
    }
 
    virtual CONTENT_TYPE GetOrCreateByIdImplementation(
        StandardDimension id
    )
    {
        CONTENT_TYPE ret = this->GetByIdImplementation(
            id
        );
        if (ret)
        {
            return ret;
        }
        return this->CreateImplementation(id);
    }
 
    virtual CONTENT_TYPE GetOrCreateByNameImplementation(
        Name name
    )
    {
        BIO_SANITIZE(this->GetStructuralPerspective(), ,
            return NULL);
        //We convert to Id in case the Name is not already registered in the desired Perspective.
        StandardDimension id = this->GetStructuralPerspective()->GetIdFromName(name);
        CONTENT_TYPE ret = this->GetByIdImplementation(id);
        if (ret)
        {
            return ret;
        }
        return this->CreateImplementation(id);
    }
 
    virtual bool HasImplementation(const CONTENT_TYPE& content) const
    {
        return this->m_contents->Has(content);
    }
 
    virtual void ImportImplementation(const LinearMotif< CONTENT_TYPE >* other)
    {
        BIO_SANITIZE(other, ,
            return);
 
        this->m_contents->Import(other->m_contents);
    }
 
    virtual Code Attenuate(const physical::Wave* other)
    {
        if (physical::Wave::GetResonanceBetween(
            other,
            ExcitationBase::GetClassProperties()).size())
        {
            ForEachImplementation(ChemicalCast< ExcitationBase* >(other));
            return code::Success();
        }
 
        Code ret = code::Success();
        for (
            SmartIterator cnt = this->m_contents;
            !cnt.IsAtBeginning();
            --cnt
            )
        {
            if (cnt.template As< physical::Identifiable< StandardDimension >* >()->Attenuate(other) != code::Success())
            {
                ret = code::UnknownError();
            }
        }
        return ret;
    }
 
    virtual Code Disattenuate(const physical::Wave* other)
    {
        Code ret = code::Success();
        for (
            SmartIterator cnt = this->m_contents;
            !cnt.IsAtBeginning();
            --cnt
            )
        {
            if (cnt.template As< physical::Identifiable< StandardDimension >* >()->Disattenuate(other) != code::Success())
            {
                ret = code::UnknownError();
            }
        }
        return ret;
    }
 
 
    virtual Emission ForEachImplementation(
        ExcitationBase* excitation
    )
    {
        Emission ret;
        for (
            SmartIterator cnt = this->m_contents;
            !cnt.IsAtBeginning();
            --cnt
            )
        {
            ByteStream result;
            excitation->CallDown(
                cnt.template As< physical::Identifiable< StandardDimension >* >()->AsWave(),
                &result
            );
            ret.push_back(result);
        }
        return ret;
    }
 
    virtual std::string GetStringFromImplementation(std::string separator = ", ")
    {
        std::string ret = "";
 
        for (
            SmartIterator cnt(
                this->m_contents,
                this->m_contents->GetBeginIndex());
            !cnt.IsAtEnd();
            ++cnt
            )
        {
            ret += cnt.template As< physical::Identifiable< StandardDimension >* >()->GetName();
            if (cnt.GetIndex() != this->m_contents->GetEndIndex() - 1)
            {
                ret += separator;
            }
        }
        return ret;
    }
 
    virtual void ClearImplementation()
    {
        //No need to delete anything, since our Linear wrapper handles that for us.
        this->m_contents->Clear();
    }
 
private:
 
    void CtorCommon()
    {
        #if BIO_CPP_VERSION >= 11
        BIO_ASSERT(std::is_base_of<Substance, CONTENT_TYPE>::value);
        #else
        CONTENT_TYPE ct;
        BIO_ASSERT(Cast< Substance* >(&ct) != NULL);
        #endif
 
        if (this->m_contents)
        {
            delete this->m_contents;
        }
        this->m_contents = new physical::Line(4);
    }
 
};
} //chemical namespace
} //bio namespace