DependentMotif.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 "LinearMotif.h"
#include "bio/chemical/EnvironmentDependent.h"
#include "bio/chemical/common/BondTypes.h"
 
namespace bio {
namespace chemical {
 
template < typename CONTENT_TYPE, typename ENVIRONMENT >
class DependentMotif :
    public chemical::Class< DependentMotif< CONTENT_TYPE, ENVIRONMENT > >,
    public LinearMotif< CONTENT_TYPE >,
    public EnvironmentDependent< ENVIRONMENT >
{
private:
    typedef Pointer< CONTENT_TYPE > ContentPointer;
    typedef Pointer< ENVIRONMENT > EnvironmentPointer;
 
    void BondLinearMotif()
    {
        const AtomicNumber bondedId = Atom::GetBondId< LinearMotif< CONTENT_TYPE > >();
        BIO_SANITIZE(bondedId, , return)
        if (this->GetBondPosition(bondedId))
        {
            return;
        }
        physical::Wave* bonded = this->LinearMotif< CONTENT_TYPE >::AsWave();
        this->FormBondImplementation(bonded, bondedId, bond_type::Virtual());
    }
 
public:
    BIO_DISAMBIGUATE_REQUIRED_CLASS_METHODS(chemical, BIO_SINGLE_ARG(DependentMotif< CONTENT_TYPE, ENVIRONMENT >))
    BIO_DISAMBIGUATE_OPTIONAL_CLASS_METHODS(physical, BIO_SINGLE_ARG(DependentMotif< CONTENT_TYPE, ENVIRONMENT >))
    virtual Code Attenuate(Pointer< const physical::Wave > other)
    {
        return this->LinearMotif< CONTENT_TYPE >::Attenuate(other);
    }
    virtual Code Disattenuate(Pointer< const physical::Wave > other)
    {
        return this->LinearMotif< CONTENT_TYPE >::Disattenuate(other);
    }
 
    explicit DependentMotif(
        EnvironmentPointer environment = NULL
    )
        :
        chemical::Class< DependentMotif< CONTENT_TYPE, ENVIRONMENT > >(this),
        EnvironmentDependent< ENVIRONMENT >(environment),
        LinearMotif< CONTENT_TYPE >()
    {
        BondLinearMotif();
 
    }
 
    explicit DependentMotif(
        const typename LinearMotif< CONTENT_TYPE >::Contents* contents,
        EnvironmentPointer environment = NULL
    )
        :
        chemical::Class< DependentMotif< CONTENT_TYPE, ENVIRONMENT > >(this),
        EnvironmentDependent< ENVIRONMENT >(environment),
        LinearMotif< CONTENT_TYPE >(contents)
    {
        BondLinearMotif();
 
    }
 
    DependentMotif(const DependentMotif< CONTENT_TYPE, ENVIRONMENT >& toCopy)
        :
        chemical::Class< DependentMotif< CONTENT_TYPE, ENVIRONMENT > >(this),
        EnvironmentDependent< ENVIRONMENT >(toCopy),
        LinearMotif< CONTENT_TYPE >(toCopy)
    {
        BondLinearMotif();
 
    }
 
    virtual ~DependentMotif()
    {
 
    }
 
    virtual void SetEnvironment(EnvironmentPointer environment)
    {
        this->EnvironmentDependent< ENVIRONMENT >::SetEnvironment(environment);
        // lazy-NULL backing store (LinearMotif defers allocation to first write):
        // no contents to propagate the environment into.
        BIO_SANITIZE_AT_SAFETY_LEVEL_1(!this->mContents.IsNull(), , return)
        for (
            SmartIterator cnt = this->mContents.Mutable()->End();
            !cnt.IsBeforeBeginning();
            --cnt
            )
        {
            cnt.template As< ContentPointer >()->chemical::template EnvironmentDependent< ENVIRONMENT >::SetEnvironment(environment);
        }
    }
 
 
    virtual ContentPointer AddImplementation(ContentPointer content)
    {
        BIO_SANITIZE(content,,return NULL)
        EnvironmentPointer environment =
            this->template As< ENVIRONMENT >();
        content->chemical::template EnvironmentDependent< ENVIRONMENT >::SetEnvironment(environment);
        return LinearMotif< CONTENT_TYPE >::AddImplementation(content);
    }
 
    virtual Code InsertImplementation(
        ContentPointer toAdd,
        const Position position = BOTTOM,
        const Id optionalPositionArg = 0, //i.e. invalid.
        const bool transferSubContents = false
    )
    {
        BIO_SANITIZE(toAdd, , return code::MissingArgument1())
        toAdd->chemical::template EnvironmentDependent< ENVIRONMENT >::SetEnvironment(this->GetEnvironment());
        return chemical::LinearMotif< CONTENT_TYPE >::InsertImplementation(
            toAdd,
            position,
            optionalPositionArg,
            transferSubContents);
    }
};
} //chemical namespace
} //bio namespace