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