TypedPerspective.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 "Perspective.h"
#include "bio/physical/common/Class.h"
#include "bio/physical/string/TypedBrane.h"
#include "bio/physical/wave/Wave.h"
#include "bio/physical/type/IsWave.h"
 
namespace bio {
namespace physical {
 
template < typename DIMENSION >
class TypedPerspective :
    public Perspective< DIMENSION >
{
public:
    TypedPerspective()
    {
 
    }
 
    virtual ~TypedPerspective()
    {
 
    }
 
        virtual bool AssociateType(
            const DIMENSION& id,
            Pointer< physical::Wave > type
            )
            {
                BIO_SANITIZE(type, , return false)
                Pointer< TypedBrane< DIMENSION > > brane =
                    this->template GetBraneAs< Pointer< TypedBrane< DIMENSION > > >(id);
                BIO_SANITIZE(brane, , return false)
            if (brane->mType)
            {
                return false;
            }
            brane->mType = type;
            return true;
        }
 
    virtual bool DisassociateType(const DIMENSION& id)
    {
            Pointer< TypedBrane< DIMENSION > > brane =
                this->template GetBraneAs< Pointer< TypedBrane< DIMENSION > > >(id);
            BIO_SANITIZE(brane, , return false)
            if (brane->mType)
            {
                Delete(brane->mType);
                brane->mType = NULL;
            }
        return true;
    }
 
    virtual bool IsTypeAssociated(const DIMENSION& id) const
    {
        const SmartIterator brn = this->Find(id);
        return brn.IsValid();
    }
 
        virtual Pointer< const Wave > GetTypeFromId(const DIMENSION& id) const
        {
            Pointer< const TypedBrane< DIMENSION > > brane =
                this->template GetBraneAs< Pointer< const TypedBrane< DIMENSION > > >(id);
            BIO_SANITIZE(brane, , return NULL)
            return brane->mType;
        }
 
        virtual Pointer< const Wave > GetTypeFromName(const Name& name) const
    {
        const DIMENSION id = this->GetIdWithoutCreation(name);
        if (id == Perspective< DIMENSION >::InvalidId())
        {
            return NULL;
        }
        return this->GetTypeFromId(id);
    }
 
    template < typename T >
    const T GetTypeFromIdAs(const DIMENSION& id) const
    {
        BIO_STATIC_ASSERT(type::IsPointer< T >())
            BIO_SANITIZE_WITH_CACHE(this->GetTypeFromId(id),
                BIO_SINGLE_ARG(return ForceCast< T >(RESULT)),
                return NULL
            )
    }
 
    template < typename T >
    const T GetTypeFromNameAs(const Name& name) const
    {
        BIO_STATIC_ASSERT(type::IsPointer< T >())
            BIO_SANITIZE_WITH_CACHE(this->GetTypeFromName(name),
                BIO_SINGLE_ARG(return ForceCast< T >(RESULT)),
                return NULL
            )
    }
 
        virtual Pointer< Wave > GetNewObjectFromId(const DIMENSION& id) const
        {
            Pointer< const Wave > type = this->GetTypeFromId(id);
            BIO_SANITIZE(type, , return NULL)
            return type->Clone();
        }
 
        virtual Pointer< Wave > GetNewObjectFromName(const Name& name)
        {
            Pointer< const Wave > type = this->GetTypeFromName(name);
            BIO_SANITIZE(type, , return NULL)
            return type->Clone();
        }
 
    template < typename T >
    T GetNewObjectFromIdAs(const DIMENSION& id)
    {
        BIO_STATIC_ASSERT(type::IsPointer< T >())
        BIO_STATIC_ASSERT(type::IsWave< T >())
        BIO_SANITIZE_WITH_CACHE(this->GetNewObjectFromId(id),
            BIO_SINGLE_ARG(
                    return *(ForceCast< Pointer< physical::Class< T > > >(RESULT)->GetWaveObject()) //GetWaveObject gives T, which, if T is a pointer-wrapper, is a nested pointer handle.
                ),
            return NULL
        )
    }
 
    template < typename T >
    T GetNewObjectFromNameAs(const Name& name)
    {
        return this->GetNewObjectFromIdAs< T >(this->GetIdWithoutCreation(name));
    }
 
 
protected:
    
        virtual Pointer< Brane< DIMENSION > > CreateBrane(DIMENSION id, const Name& name)
        {
            return new TypedBrane< DIMENSION >(id, name, NULL);
        }
};
 
} //physical namespace
} //bio namespace