Metallic.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 "Atom.h"
#include "Bond.h"
#include "bio/chemical/common/BondTypes.h"
#include "bio/chemical/common/Helpers.h"
#include "bio/common/wrapper/Pointer.h"
 
#include <cstddef>
#include <vector>
 
namespace bio {
//not chemical.
 
template < class T >
class Metallic :
    virtual public chemical::Atom
{
public:
    Metallic() :
        //@formatter:off
        #if BIO_COMPACT_POINTER_STORAGE
        mT(::bio::pointer_arena::New< T >())
        #else
        mT(new T())
        #endif
        //@formatter:on
    {
        DonateBonds(mT, this);
        DonateBonds(this, mT);
    }
 
    Metallic(const Metallic& other) :
        mT(NULL)
    {
        if (other.mT)
        {
            //@formatter:off
            #if BIO_COMPACT_POINTER_STORAGE
            mT = ::bio::pointer_arena::NewCopy< T >(*other.mT);
            #else
            mT = new T(*other.mT);
            #endif
            //@formatter:on
            DonateBonds(mT, this);
            DonateBonds(this, mT);
        }
    }
 
    virtual ~Metallic()
    {
        if (mT)
        {
            BreakDonatedBonds(this);
            BreakDonatedBonds(mT);
            //@formatter:off
            #if BIO_COMPACT_POINTER_STORAGE
            ::bio::pointer_arena::Delete(mT.Get());
            #else
            delete mT;
            #endif
            //@formatter:on
            mT = NULL;
        }
    }
 
    Metallic& operator=(const Metallic& other)
    {
        if (this == &other)
        {
            return *this;
        }
        if (mT)
        {
            BreakDonatedBonds(this);
            BreakDonatedBonds(mT);
            //@formatter:off
            #if BIO_COMPACT_POINTER_STORAGE
            ::bio::pointer_arena::Delete(mT.Get());
            #else
            delete mT;
            #endif
            //@formatter:on
            mT = NULL;
        }
        if (other.mT)
        {
            //@formatter:off
            #if BIO_COMPACT_POINTER_STORAGE
            mT = ::bio::pointer_arena::NewCopy< T >(*other.mT);
            #else
            mT = new T(*other.mT);
            #endif
            //@formatter:on
            DonateBonds(mT, this);
            DonateBonds(this, mT);
        }
        return *this;
    }
 
    Pointer< T > Object()
    {
        return mT;
    }
 
    Pointer< const T > Object() const
    {
        return mT;
    }
 
    struct BondIdentity
    {
        chemical::AtomicNumber id;
        Pointer< physical::Wave > bonded;
        BondIdentity() : id(0), bonded(NULL) {}
        BondIdentity(chemical::AtomicNumber i, Pointer< physical::Wave > b) : id(i), bonded(b) {}
    };
 
    struct DonateCollect
    {
        std::vector< BondIdentity > entries;
    };
 
    static void DonateCollectVisitor(const chemical::Bond& bond, void* ctx)
    {
        DonateCollect* collect = static_cast< DonateCollect* >(ctx);
        // const Bond& -> non-const GetBonded(): the original (pre-RFC-§5)
        // donor walk operated on a non-const Bond*, and downstream we
        // hand the bonded Wave* to FormBondImplementation which wants
        // non-const. ForEachBond hands us const Bond& to advertise
        // "read-only metadata"; the GetBonded() pointer escape is the
        // caller's responsibility (RFC §6).
        Pointer< physical::Wave > bonded = const_cast< chemical::Bond& >(bond).GetBonded();
        collect->entries.push_back(BondIdentity(bond.GetId(), bonded));
    }
 
    static void DonateBonds(
        Pointer< chemical::Atom > donor,
        Pointer< chemical::Atom > receiver
    )
    {
        // Snapshot under donor's shared lock, then mutate receiver without
        // nesting locks. RFC §5 step 3.
        DonateCollect collect;
        donor->ForEachBond(&DonateCollectVisitor, &collect);
 
        for (std::size_t i = 0; i < collect.entries.size(); ++i)
        {
            const BondIdentity& entry = collect.entries[i];
 
            //Skip already Bonded objects.
            if (receiver->GetBondPosition(entry.id))
            {
                continue;
            }
 
            //Nuke the BondType, since it could lead to deleting the same pointer twice.
            //We also want to keep track of where the Bonds came from.
            receiver->FormBondImplementation(
                entry.bonded,
                entry.id,
                GetBondType()
            );
        }
    }
 
    struct BreakDonatedCollect
    {
        BondType expectedType;
        std::vector< chemical::AtomicNumber > ids;
    };
 
    static void BreakDonatedCollectVisitor(const chemical::Bond& bond, void* ctx)
    {
        BreakDonatedCollect* collect = static_cast< BreakDonatedCollect* >(ctx);
        if (bond.GetType() != collect->expectedType)
        {
            return;
        }
        collect->ids.push_back(bond.GetId());
    }
 
    static void BreakDonatedBonds(Pointer< chemical::Atom > receiver)
    {
        // Snapshot under receiver's shared lock, then break without
        // nesting receiver's exclusive lock inside the visitor.
        // RFC §5 step 3.
        BreakDonatedCollect collect;
        collect.expectedType = GetBondType();
        receiver->ForEachBond(&BreakDonatedCollectVisitor, &collect);
 
        for (std::size_t i = 0; i < collect.ids.size(); ++i)
        {
            const chemical::AtomicNumber id = collect.ids[i];
            if (!receiver->GetBondPosition(id))
            {
                continue;
            }
            receiver->BreakBondImplementation(id, GetBondType());
        }
    }
 
    static BondType GetBondType()
    {
        static const BondType bondId = BondTypePerspective::Instance().GetIdFromName(type::TypeName< Metallic< T > >());
        chemical::atom_detail::RegisterMetallicBondType(bondId);
        return bondId;
    }
 
protected:
    Pointer< T > mT;
};
 
} //bio namespace