Solute.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) 2023 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/physical/Periodic.h"
#include "bio/chemical/common/Types.h"
#include "bio/chemical/common/Diffusion.h"
#include "bio/chemical/common/Filters.h"
#include "bio/chemical/macro/Macros.h"
#include "bio/chemical/Substance.h"
#include "bio/chemical/EnvironmentDependent.h"
#include "bio/common/wrapper/Pointer.h"
 
namespace bio {
namespace chemical {
 
class Solution;
 
class Solute :
    public chemical::Class< Solute >,
    public chemical::EnvironmentDependent< Solution >,
    public Arrangement< Pointer< Solute > >,
    virtual public physical::Periodic
{
public:
    BIO_DISAMBIGUATE_ALL_CLASS_METHODS(chemical, Solute)
 
    BIO_DEFAULT_IDENTIFIABLE_CONSTRUCTORS_WITH_COMMON_CONSTRUCTOR(
        chemical,
        Solute,
        filter::Chemical()
    )
 
    Solute(const Solute& other);
 
    Solute(
        Pointer< Substance > dissolvedSubstance,
        const DiffusionTime& diffusionTime = diffusion::time::Destruction(),
        const DiffusionEffort& diffusionEffort = diffusion::effort::Active()
    );
 
    virtual ~Solute();
 
    Solute& operator=(const Solute& other);
 
    operator Pointer< Substance >()
    {
        return GetDissolvedSubstance();
    }
 
    operator Pointer< const Substance >() const
    {
        return GetDissolvedSubstance();
    }
 
    Pointer< Substance > GetDissolvedSubstance();
 
    Pointer< const Substance > GetDissolvedSubstance() const;
 
    virtual Concentration GetConcentration() const;
 
    virtual void Diffuse() const;
 
    virtual Code Crest();
 
    virtual Code MixWith(const Solute& other);
 
    virtual Code MixWith(Pointer< const Substance > other);
 
    virtual void SetEnvironment(Pointer< Solution > environment);
 
    virtual Index GetIndexInParentSolution() const;
 
    virtual void SetIndexInParentSolution(Index indexInParentSolution);
 
    virtual void SetDiffusionTime(const DiffusionTime& diffusionTime);
 
    virtual DiffusionTime GetDiffusionTime() const;
 
    virtual void SetDiffusionEffort(const DiffusionEffort& diffusionEffort);
 
    virtual DiffusionEffort GetDiffusionEffort() const;
 
protected:
 
    Pointer< Substance > mDissolvedSubstance;
 
    //Mutable for use in Increment & Decrement
    mutable Pointer< Solute > mParentSolute;
    mutable Index mIndexInParent;
 
    DiffusionTime mDiffusionTime;
    DiffusionEffort mDiffusionEffort;
 
    virtual void Destructor();
 
private:
    void CommonConstructor();
 
    //For creation & deletion.
    friend class Solution;
};
 
} //chemical namespace
} //bio namespace