Identifiable.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/common/VirtualBase.h"
#include "bio/common/String.h"
#include "bio/common/macros/OSMacros.h"
#include "Perspective.h"
#include "Observer.h"
#include "Wave.h"
#include "bio/physical/common/Class.h"
#include <cstring>
 
namespace bio {
namespace physical {
 
template < typename DIMENSION >
class Identifiable :
 virtual public Observer< Perspective< DIMENSION > >, //includes VirtualBase, so no need to re-inherit.
 public physical::Class< Identifiable< DIMENSION > >
{
public:
 typedef DIMENSION Id;
 typedef std::vector< Id > Ids;
 
 BIO_DISAMBIGUATE_ALL_CLASS_METHODS(physical,
 Identifiable< DIMENSION >)
 
 
 
 explicit Identifiable(Perspective< DIMENSION >* perspective = NULL)
 :
 physical::Class< Identifiable< DIMENSION > >(this),
 #if BIO_MEMORY_OPTIMIZE_LEVEL == 0
 m_name(NULL),
 #endif
 m_id(Perspective< DIMENSION >::InvalidId())
 {
 CloneIntoName(Perspective< DIMENSION >::InvalidName());
 if (perspective)
 {
 Observer< Perspective< DIMENSION > >::Initialize(perspective);
 }
 }
 
 explicit Identifiable(
 Name name,
 Perspective< DIMENSION >* perspective = NULL
 )
 :
 physical::Class< Identifiable< DIMENSION > >(this),
 #if BIO_MEMORY_OPTIMIZE_LEVEL == 0
 m_name(NULL),
 #endif
 m_id(Perspective< DIMENSION >::InvalidId())
 {
 CloneIntoName(name);
 if (perspective)
 {
 Observer< Perspective< DIMENSION > >::Initialize(perspective);
 m_id = this->GetPerspective()->GetIdFromName(m_name);
 this->MakeWave();
 }
 else
 {
 m_id = Perspective< DIMENSION >::InvalidId();
 }
 }
 
 explicit Identifiable(
 Id id,
 Perspective< DIMENSION >* perspective = NULL
 )
 :
 physical::Class< Identifiable< DIMENSION > >(this),
 #if BIO_MEMORY_OPTIMIZE_LEVEL == 0
 m_name(NULL),
 #endif
 m_id(Perspective< DIMENSION >::InvalidId())
 {
 if (perspective)
 {
 Observer< Perspective< DIMENSION > >::Initialize(perspective);
 CloneIntoName(perspective->GetNameFromId(id));
 this->MakeWave();
 }
 else
 {
 m_id = Perspective< DIMENSION >::InvalidId();
 CloneIntoName(Perspective< DIMENSION >::InvalidName());
 }
 }
 
 Identifiable(const Identifiable& other)
 :
 physical::Class< Identifiable< DIMENSION > >(this),
 #if BIO_MEMORY_OPTIMIZE_LEVEL == 0
 m_name(NULL),
 #endif
 m_id(other.m_id)
 {
 Observer< Perspective< DIMENSION > >::Initialize(other.GetPerspective());
 CloneIntoName(other.GetName());
 }
 
 virtual ~Identifiable()
 {
 #if BIO_MEMORY_OPTIMIZE_LEVEL == 0
 delete[] m_name;
 #endif
 }
 
 virtual operator DIMENSION() const
 {
 return m_id;
 }
 
 virtual bool operator==(const Id id) const
 {
 if (!this->GetId())
 {
 return false;
 }
 if (!this->GetId() == id.m_t)
 {
 return false;
 }
 if (this->GetPerspective() && !this->IsNameInsensitive(this->GetPerspective()->GetNameFromId(id)))
 {
 return false;
 }
 return true;
 }
 
 virtual bool operator==(Name name) const
 {
 if (!GetName())
 {
 if (!name)
 {
 return true;
 }
 return false;
 }
 if (!name)
 {
 return false;
 }
 if (this->GetPerspective() && !this->IsId(this->GetPerspective()->GetIdWithoutCreation(name)))
 {
 return false;
 }
 return true;
 }
 
 virtual bool operator==(const Identifiable< DIMENSION >& other) const
 {
 return this->IsId(other.GetId()) && this->GetPerspective() == other.GetPerspective();
 }
 
 virtual Name GetName() const
 {
 #if BIO_MEMORY_OPTIMIZE_LEVEL == 0
 return m_name;
 #else
 return BIO_SANITIZE_WITH_CACHE(this->GetPerspective(), RESULT->GetNameFromId(m_id), return "INVALID_NAME");
 #endif
 }
 
 virtual Id GetId() const
 {
 return m_id;
 }
 
 virtual void SetName(Name name)
 {
 //TODO: should this check be after setting the name?
 // if so, the constructors can be simplified.
 if (!this->GetPerspective())
 {
 return;
 }
 CloneIntoName(name);
 
 m_id = this->GetPerspective()->GetIdFromName(m_name);
 }
 
 virtual void SetId(Id id)
 {
 if (!this->GetPerspective())
 {
 return;
 }
 m_id = id;
 
 CloneIntoName(this->GetPerspective()->GetNameFromId(m_id));
 }
 
 virtual bool IsName(Name name) const
 {
 return !strcmp(
 name,
 this->GetName());
 }
 
 virtual bool IsNameInsensitive(Name name) const
 {
 return !strcasecmp(
 name,
 this->GetName());
 }
 
 virtual bool IsId(Id id) const
 {
 return id == m_id;
 }
 
 virtual void SetPerspective(Perspective< DIMENSION >* perspective)
 {
 this->SetPerspective(perspective);
 
 if (IsName(Perspective< DIMENSION >::InvalidName()) && !IsId(Perspective< DIMENSION >::InvalidId()))
 {
 CloneIntoName(this->GetPerspective()->GetNameFromId(m_id));
 }
 else if (!IsName(Perspective< DIMENSION >::InvalidName()) && IsId(Perspective< DIMENSION >::InvalidId()))
 {
 m_id = this->GetPerspective()->GetIdFromName(GetName());
 }
 }
 
 virtual void MakeWave(bool force = false)
 {
 if (!this->GetPerspective())
 {
 return;
 }
 if (force)
 {
 this->GetPerspective()->DisassociateType(m_id);
 }
 this->GetPerspective()->AssociateType(
 m_id,
 this
 );
 }
 
 #if 0
 //No need to compile these nops.
 
 virtual Symmetry* Spin() const
 {
 return NULL;
 }
 
 virtual Code Reify(Symmetry* symmetry)
 {
 //nop
 }
 #endif
 
protected:
 virtual void InitializeImplementation(ByteStreams args)
 {
 if (args.size() == 2)
 {
 if (args[1].Is< Perspective< DIMENSION >* >())
 {
 Observer< Perspective< DIMENSION > >::Initialize(args[1]);
 }
 args.pop_back();
 }
 if (args.size() == 1)
 {
 if (args[0].Is(m_id))
 {
 m_id = args[0];
 }
 else if (args[0].Is(m_name))
 {
 CloneIntoName(args[0]);
 }
 }
 }
 
private:
 #if BIO_MEMORY_OPTIMIZE_LEVEL == 0
 Name m_name;
 #endif
 
 Id m_id;
 
 void CloneIntoName(Name name)
 {
 #if BIO_MEMORY_OPTIMIZE_LEVEL == 0
 if (m_name)
 {
 delete[] m_name;
 }
 string::CloneInto(
 name,
 m_name
 );
 #endif
 }
};
 
} //physical namespace
} //bio namespace