Excitation.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 "bio/physical/common/Class.h"
#include "bio/physical/macros/Macros.h"
#include "bio/chemical/common/Properties.h"
#include "bio/chemical/PeriodicTable.h"
 
namespace bio {
namespace chemical {
 
class ExcitationBase :
 public physical::Class< ExcitationBase >
{
public:
 BIO_DISAMBIGUATE_ALL_CLASS_METHODS(physical,
 ExcitationBase)
 
 
 ExcitationBase()
 :
 physical::Class< ExcitationBase >(this)
 {
 
 }
 
 virtual ~ExcitationBase()
 {
 
 }
 
 static Properties GetClassProperties()
 {
 Properties ret;
 ret.push_back(property::Excitatory());
 return ret;
 }
 
 virtual Properties GetProperties() const
 {
 return GetClassProperties();
 }
 
 virtual void EditArg(
 uint8_t position,
 ByteStream& newVal
 )
 {
 //nop
 }
 
 virtual void CallDown(
 physical::Wave* wave,
 ByteStream* ret
 ) const
 {
 //nop
 }
};
 
#if BIO_CPP_VERSION >= 17
 
 #include <tuple>
 #include <functional>
 
template< class WAVE, typename RETURN, typename... ARGUMENTS >
class Excitation :
 public ExcitationBase,
 public physical::Class< Excitation< WAVE,RETURN,ARGUMENTS...> >
{
public:
 
 BIO_DISAMBIGUATE_ALL_CLASS_METHODS(physical, BIO_SINGLE_ARG(Excitation<WAVE,RETURN,ARGUMENTS...>))
 
 
 Excitation(RETURN(WAVE::*function)(ARGUMENTS...), const ARGUMENTS&... args)
 :
 physical::Class< Excitation<WAVE,RETURN,ARGUMENTS...> >(this),
 m_function(function),
 m_args(args)
 {
 }
 
 virtual Excitation()
 {
 
 }
 
 virtual Properties GetProperties() const
 {
 Properties ret = PeriodicTable::Instance().GetPropertiesOf< WAVE >();
 ret.insert(ret.end(), ExcitationBase::GetClassProperties().begin(), ExcitationBase::GetClassProperties().end());
 return ret;
 }
 
 virtual void EditArg(uint8_t position, ByteStream& newVal)
 {
 //TODO...
 }
 
 RETURN operator()(WAVE* wave) const
 {
 std::tuple allArgs = std::tuple_cat(std::make_tuple(wave), m_args);
 return std::apply(*m_function, allArgs);
 }
 
 virtual void CallDown(physical::Wave* wave, ByteStream* ret) const
 {
 ret->Set(this->operator()(ForceCast<WAVE*>(wave)));
 }
 
protected:
 RETURN (WAVE::*m_function)(ARGUMENTS...)
 std::tuple m_args;
};
 
#else
 
template < class WAVE, typename RETURN >
class ExcitationWithoutArgument :
 public ExcitationBase,
 public physical::Class< ExcitationWithoutArgument< WAVE, RETURN > >
{
public:
 
 BIO_DISAMBIGUATE_ALL_CLASS_METHODS(physical,
 BIO_SINGLE_ARG(ExcitationWithoutArgument< WAVE, RETURN >))
 
 
 ExcitationWithoutArgument(RETURN(WAVE::*function)())
 :
 physical::Class< ExcitationWithoutArgument< WAVE, RETURN > >(this),
 m_function(function)
 {
 }
 
 virtual ~ExcitationWithoutArgument()
 {
 
 }
 
 virtual Properties GetProperties() const
 {
 Properties ret = PeriodicTable::Instance().GetPropertiesOf< WAVE >();
 ret.insert(
 ret.end(),
 ExcitationBase::GetClassProperties().begin(),
 ExcitationBase::GetClassProperties().end());
 return ret;
 }
 
 
 RETURN operator()(WAVE* wave) const
 {
 return (wave->*m_function)();
 }
 
 virtual void CallDown(
 physical::Wave* wave,
 ByteStream* ret
 ) const
 {
 ret->Set(this->operator()(ForceCast< WAVE* >(wave)));
 }
 
protected:
 RETURN (WAVE::*m_function)();
};
 
template < class WAVE, typename RETURN, typename ARGUMENT >
class ExcitationWithArgument :
 public ExcitationBase,
 public physical::Class< ExcitationWithArgument< WAVE, RETURN, ARGUMENT > >
{
public:
 
 BIO_DISAMBIGUATE_ALL_CLASS_METHODS(physical,
 BIO_SINGLE_ARG(ExcitationWithArgument< WAVE, RETURN, ARGUMENT >))
 
 
 
 ExcitationWithArgument(
 RETURN(WAVE::*function)(ARGUMENT),
 ARGUMENT arg
 )
 :
 physical::Class< ExcitationWithArgument< WAVE, RETURN, ARGUMENT > >(this),
 m_function(function),
 m_arg(arg)
 {
 }
 
 virtual ~ExcitationWithArgument()
 {
 
 }
 
 virtual Properties GetProperties() const
 {
 Properties ret = PeriodicTable::Instance().GetPropertiesOf< WAVE >();
 ret.insert(
 ret.end(),
 ExcitationBase::GetClassProperties().begin(),
 ExcitationBase::GetClassProperties().end());
 return ret;
 }
 
 virtual void EditArg(
 uint8_t position,
 ByteStream& newVal
 )
 {
 BIO_SANITIZE(position,
 return,);
 m_arg = newVal;
 }
 
 RETURN operator()(WAVE* wave) const
 {
 return (wave->*m_function)(m_arg);
 }
 
 virtual void CallDown(
 physical::Wave* wave,
 ByteStream* ret
 ) const
 {
 ret->Set(this->operator()(ForceCast< WAVE* >(wave)));
 }
 
protected:
 RETURN (WAVE::*m_function)(ARGUMENT);
 
 ARGUMENT m_arg;
};
 
template < class WAVE, typename RETURN, typename ARGUMENT1, typename ARGUMENT2 >
class ExcitationWithTwoArguments :
 public ExcitationBase,
 public physical::Class< ExcitationWithTwoArguments< WAVE, RETURN, ARGUMENT1, ARGUMENT2 > >
{
public:
 
 BIO_DISAMBIGUATE_ALL_CLASS_METHODS(physical,
 BIO_SINGLE_ARG(ExcitationWithTwoArguments< WAVE, RETURN, ARGUMENT1, ARGUMENT2 >))
 
 
 
 ExcitationWithTwoArguments(
 RETURN(WAVE::*function)(
 ARGUMENT1,
 ARGUMENT2
 ),
 ARGUMENT1 arg1,
 ARGUMENT2 arg2
 )
 :
 physical::Class< ExcitationWithTwoArguments< WAVE, RETURN, ARGUMENT1, ARGUMENT2 > >(this),
 m_function(function),
 m_arg1(arg1),
 m_arg2(arg2)
 {
 }
 
 virtual ~ExcitationWithTwoArguments()
 {
 
 }
 
 virtual Properties GetProperties() const
 {
 Properties ret = PeriodicTable::Instance().GetPropertiesOf< WAVE >();
 ret.insert(
 ret.end(),
 ExcitationBase::GetClassProperties().begin(),
 ExcitationBase::GetClassProperties().end());
 return ret;
 }
 
 virtual void EditArg(
 uint8_t position,
 ByteStream& newVal
 )
 {
 switch (position)
 {
 case 0:
 m_arg1 = newVal;
 break;
 case 1:
 m_arg2 = newVal;
 break;
 }
 }
 
 RETURN operator()(WAVE* wave) const
 {
 return (wave->*m_function)(
 m_arg1,
 m_arg2
 );
 }
 
 virtual void CallDown(
 physical::Wave* wave,
 ByteStream* ret
 ) const
 {
 ret->Set(this->operator()(ForceCast< WAVE* >(wave)));
 }
 
protected:
 RETURN (WAVE::*m_function)(
 ARGUMENT1,
 ARGUMENT2
 );
 
 ARGUMENT1 m_arg1;
 ARGUMENT2 m_arg2;
};
 
 
#endif
} //chemical namespace
} //bio namespace