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