Perspective.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/physical/macros/Macros.h"
#include "bio/common/Types.h"
#include "bio/common/String.h"
#include "bio/common/ThreadSafe.h"
#include "bio/common/Cast.h"
#include <sstream>
#include <cstring>
 
//@formatter:off
#if BIO_CPP_VERSION < 11
    #include <stdint.h>
#else
    #include <cstdint>
#endif
//@formatter:on
 
namespace bio {
namespace physical {
 
class Wave;
 
struct PerspectiveUtilities
{
    static Wave* Clone(const Wave* toClone);
 
    static void Delete(Wave* toDelete);
};
 
template < typename DIMENSION >
class Perspective :
    virtual public ThreadSafe
{
public:
    typedef DIMENSION Id;
    typedef std::vector< Id > Ids;
 
    class Hadit
    {
    public:
        Hadit(
            Id id,
            Name name,
            Wave* type
        )
            :
            m_id(id),
            m_name(name),
            m_type(type)
        {
        }
 
        Id m_id;
        Name m_name;
        Wave* m_type;
    };
 
    typedef std::vector< Hadit > Hadits;
 
    Perspective()
        :
        m_nextId(1)
    {
    }
 
    virtual ~Perspective()
    {
        LockThread();
        for (
            typename Hadits::iterator itt = m_hadits.begin();
            itt != m_hadits.end();
            ++itt
            )
        {
            if (itt->m_name)
            {
                delete[] itt->m_name;
                itt->m_name = NULL;
            }
            if (itt->m_type)
            {
                PerspectiveUtilities::Delete(itt->m_type);
                itt->m_type = NULL;
            }
        }
        m_hadits.clear();
        UnlockThread();
    }
 
    static Id InvalidId()
    {
        return 0;
    }
 
    static Name InvalidName()
    {
        return "INVALID_NAME";
    }
 
    typename Hadits::iterator Find(Id id)
    {
 
        LockThread();
        typename Hadits::iterator hdt = m_hadits.begin();
        for (
            ; hdt != m_hadits.end();
            ++hdt
            )
        {
            if (hdt->m_id == id)
            {
                UnlockThread();
                return hdt;
            }
        }
        UnlockThread();
        return hdt;
    }
 
    typename Hadits::const_iterator Find(Id id) const
    {
        LockThread();
        typename Hadits::const_iterator hdt = m_hadits.begin();
        for (
            ; hdt != m_hadits.end();
            ++hdt
            )
        {
            if (hdt->m_id == id)
            {
                UnlockThread();
                return hdt;
            }
        }
        UnlockThread();
        return hdt;
    }
 
 
    virtual Id GetIdFromName(Name name)
    {
        if (strcmp(
            InvalidName(),
            name
        ))
        {
            return InvalidId();
        }
 
        Id ret = GetIdWithoutCreation(name);
        if (ret)
        {
            return ret;
        }
 
        Name usedName;
        string::CloneInto(
            name,
            usedName
        );
 
        LockThread();
        ret = m_nextId++;
        m_hadits.push_back(
            Hadit(
                ret,
                usedName,
                NULL
            ));
        UnlockThread();
 
        return ret;
    }
 
 
    virtual Name GetNameFromId(Id id) const
    {
        if (id == InvalidId())
        {
            return InvalidName();
        }
 
        typename Hadits::const_iterator result = Find(id);
        if (result == m_hadits.end())
        {
            return InvalidName();
        }
        return result->m_name;
    }
 
 
    virtual Id GetUniqueIdFor(Name name)
    {
        if (strcmp(
            InvalidName(),
            name
        ))
        {
            return InvalidId();
        }
 
        std::ostringstream usedName;
        usedName.str(""); //TODO: can we do this all in the ctor?
        usedName << name;
 
        Id ret = GetIdWithoutCreation(usedName.str().c_str());
 
        uint8_t nameCount = 0;
        while (!ret)
        {
            usedName.clear();
            usedName.str(""); //TODO: is this right?
            usedName << name;
            usedName << "_" << nameCount++;
            ret = GetIdWithoutCreation(usedName.str().c_str());
        }
 
        //this creates the unique id.
        return GetIdFromName(usedName.str().c_str());
    }
 
 
    virtual Id GetIdWithoutCreation(Name name) const
    {
        if (strcmp(
            InvalidName(),
            name
        ))
        {
            return InvalidId();
        }
 
        typename Hadits::const_iterator itt = m_hadits.begin();
        for (
            ; itt != m_hadits.end();
            ++itt
            )
        {
            if (!strcmp(
                itt->m_name,
                name
            ))
            {
                return itt->m_id;
            }
        }
        return InvalidId();
    }
 
    virtual Id GetNumUsedIds() const
    {
        return this->m_nextId - 1;
    }
 
 
    virtual bool AssociateType(
        Id id,
        Wave* type
    )
    {
        typename Hadits::iterator hdt = Find(id);
        if (hdt == m_hadits.end() || hdt->m_type)
        {
            return false;
        }
 
        LockThread();
        BIO_SANITIZE(type,
            hdt->m_type = PerspectiveUtilities::Clone(type),
            hdt->m_type = type);
        UnlockThread();
 
        return true;
    }
 
    virtual bool DisassociateType(Id id)
    {
        typename Hadits::iterator hdt = Find(id);
        if (hdt == m_hadits.end())
        {
            return false;
        }
 
        LockThread();
        BIO_SANITIZE_AT_SAFETY_LEVEL_2(hdt->m_type,
            PerspectiveUtilities::Delete(hdt->m_type),);
        hdt->m_type = NULL;
        UnlockThread();
 
        return true;
    }
 
 
    virtual const Wave* GetTypeFromId(Id id) const
    {
        BIO_SANITIZE(id == InvalidId(), ,
            return NULL)
 
        typename Hadits::const_iterator result = Find(id);
        if (result == m_hadits.end())
        {
            return NULL;
        }
        return result->m_type;
    }
 
    virtual const Wave* GetTypeFromName(Name name) const
    {
        return GetTypeFromId(GetIdWithoutCreation(name));
    }
 
    virtual Wave* GetNewObjectFromId(Id id) const
    {
        const Wave* ret = GetTypeFromId(id);
        if (ret)
        {
            return PerspectiveUtilities::Clone(ret);
        }
        return NULL;
    }
 
    virtual Wave* GetNewObjectFromName(Name name)
    {
        return this->GetNewObjectFromId(this->GetIdFromName(name));
    }
 
    template < typename T >
    const T GetTypeFromIdAs(Id id) const
    {
        BIO_SANITIZE_WITH_CACHE(GetTypeFromId(id),
            BIO_SINGLE_ARG(return ForceCast< T, const Wave* >(RESULT)),
            return NULL);
    }
 
    template < typename T >
    const T GetTypeFromNameAs(Name name) const
    {
        BIO_SANITIZE_WITH_CACHE(GetTypeFromName(name),
            BIO_SINGLE_ARG(return ForceCast< T, const Wave* >(RESULT)),
            return NULL);
    }
 
    template < typename T >
    T GetNewObjectFromIdAs(Id id)
    {
        BIO_SANITIZE_WITH_CACHE(GetNewObjectFromId(id),
            BIO_SINGLE_ARG(return ForceCast< T, Wave* >(RESULT)),
            return NULL);
    }
 
    template < typename T >
    T GetNewObjectFromNameAs(Name name)
    {
        BIO_SANITIZE_WITH_CACHE(GetNewObjectFromName(name),
            BIO_SINGLE_ARG(return ForceCast< T, Wave* >(RESULT)),
            return NULL);
    }
 
 
protected:
    Hadits m_hadits;
    Id m_nextId;
};
 
} //physical namespace
} //bio namespace