Atom.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) 2021 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/common/Cast.h"
#include "bio/common/macros/Macros.h"
#include "bio/common/IsPrimitive.h"
#include "bio/common/macros/OSMacros.h"
#include "bio/physical/Quantum.h"
#include "bio/physical/common/Class.h"
#include "bio/chemical/common/BondTypes.h"
#include "PeriodicTable.h"
#include "Bond.h"
 
namespace bio {
namespace chemical {
 
class Symmetry;
 
class Atom :
 public physical::Class< Atom >
{
public:
 
 BIO_DISAMBIGUATE_ALL_CLASS_METHODS(physical,
 Atom)
 
 
 explicit Atom();
 
 explicit Atom(const Atom& other);
 
 virtual ~Atom();
 
 virtual physical::Symmetry* Spin() const;
 
 virtual Code Reify(physical::Symmetry* symmetry);
 
 virtual Code Attenuate(const Wave* other);
 
 virtual Code Disattenuate(const Wave* other);
 
 Wave* GetBonded(Valence position);
 
 const Wave* GetBonded(Valence position) const;
 
 template < typename T >
 T AsBonded()
 {
 Valence position = GetBondPosition< T >();
 BIO_SANITIZE(position, ,
 return NULL);
 return ForceCast< T >(m_bonds.OptimizedAccess(position)->GetBonded());
 }
 
 template < typename T >
 const T AsBonded() const
 {
 Valence position = GetBondPosition< T >();
 
 BIO_SANITIZE(position, ,
 return NULL);
 return ForceCast< const T >(m_bonds.OptimizedAccess(position)->GetBonded());
 }
 
 template < typename T >
 T AsBondedQuantum()
 {
 return Cast< T >(AsBonded< physical::Quantum< T >* >());
 }
 
 template < typename T >
 const T AsBondedQuantum() const
 {
 return *AsBonded< physical::Quantum< T >* >();
 }
 
 template < typename T >
 T As()
 {
 #if BIO_CPP_VERSION < 11
 return AsBondedQuantum< T >();
 #else
 if (IsPrimitive< T >())
 {
 return AsBondedQuantum< T >();
 }
 else
 {
 return AsBonded< T >();
 }
 #endif
 }
 
 template < typename T >
 const T As() const
 {
 #if BIO_CPP_VERSION < 11
 return AsBondedQuantum< T >();
 #else
 if (IsPrimitive< T >())
 {
 return AsBondedQuantum< T >();
 }
 else
 {
 return AsBonded< T >();
 }
 #endif
 }
 
 
 template < typename T >
 operator T()
 {
 return As< T >();
 }
 
 template < typename T >
 bool FormBond(
 T toBond,
 BondType type = bond_type::Unknown())
 {
 #if BIO_CPP_VERSION < 11
 AtomicNumber bondedId = PeriodicTable::Instance().GetIdFromType< physical::Quantum< T >* >();
 return FormBondImplementation((new physical::Quantum< T >(toBond))->AsWave(),
 bondedId,
 type
 );
 #else
 if (IsPrimitive< T >())
 {
 AtomicNumber bondedId = PeriodicTable::Instance().GetIdFromType< physical::Quantum< T >* >();
 return FormBondImplementation(
 (new physical::Quantum< T >(toBond))->AsWave(),
 bondedId,
 type
 );
 }
 else
 {
 AtomicNumber bondedId = PeriodicTable::Instance().GetIdFromType< T >();
 return FormBondImplementation(
 toBond->AsWave(),
 bondedId,
 type
 );
 }
 #endif
 }
 
 template < typename T >
 bool BreakBond(
 T toDisassociate,
 BondType type = bond_type::Unknown())
 {
 #if BIO_CPP_VERSION < 11
 return BreakBond< physical::Quantum< T >* >(
 NULL,
 type
 );
 #else
 if (IsPrimitive< T >())
 {
 return BreakBond< physical::Quantum< T >* >(NULL, type); //T matters, toDisassociate does not.
 }
 
 AtomicNumber bondedId = PeriodicTable::Instance().GetIdFromType< T >();
 return BreakBondImplementation(
 toDisassociate,
 bondedId,
 type
 );
 #endif
 }
 
 
 Valence GetBondPosition(AtomicNumber bondedId) const;
 
 Valence GetBondPosition(Name typeName) const;
 
 
 template < typename T >
 Valence GetBondPosition() const
 {
 #if BIO_CPP_VERSION < 11
 return GetBondPosition(PeriodicTable::Instance().GetIdFromType< physical::Quantum< T >* >());
 #else
 if (IsPrimitive< T >())
 {
 return GetBondPosition(PeriodicTable::Instance().GetIdFromType< physical::Quantum< T >* >());
 }
 return GetBondPosition(PeriodicTable::Instance().GetIdFromType< T >());
 #endif
 }
 
 BondType GetBondType(Valence position) const;
 
 template < typename T >
 BondType GetBondType() const
 {
 #if BIO_CPP_VERSION < 11
 return GetBondType(GetBondPosition< physical::Quantum< T > >());
 #else
 if (IsPrimitive< T >())
 {
 return GetBondType(GetBondPosition< physical::Quantum< T > >());
 }
 return GetBondType(GetBondPosition< T >());
 #endif
 }
 
 Bonds* GetAllBonds();
 
 const Bonds* GetAllBonds() const;
 
protected:
 Bonds m_bonds;
 
 virtual bool FormBondImplementation(
 Wave* toBond,
 AtomicNumber id,
 BondType type
 );
 
 virtual bool BreakBondImplementation(
 Wave* toDisassociate,
 AtomicNumber id,
 BondType type
 );
};
 
} //chemical namespace
} //bio namespace