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