UnorderedMotif.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 "AbstractMotif.h"
#include "bio/chemical/macros/Macros.h"
#include "bio/chemical/common/Class.h"
#include "bio/physical/common/Filters.h"
#include "bio/physical/arrangement/Arrangement.h"
#include <vector>
#include <algorithm>
 
namespace bio {
namespace chemical {
 
template < typename CONTENT_TYPE >
class UnorderedMotif :
    public chemical::Class< UnorderedMotif< CONTENT_TYPE > >,
    public AbstractMotif
{
public:
 
    typedef physical::Arrangement< CONTENT_TYPE > Contents;
 
    BIO_DISAMBIGUATE_ALL_CLASS_METHODS(chemical,
        UnorderedMotif< CONTENT_TYPE >)
 
    
    UnorderedMotif()
        :
        chemical::Class< UnorderedMotif< CONTENT_TYPE > >(this) //TODO: Define Symmetry.
    {
        this->m_contents = new Contents(4);
    }
 
    UnorderedMotif(const Contents* contents)
        :
        chemical::Class< UnorderedMotif< CONTENT_TYPE > >(this) //TODO: Define Symmetry.
    {
        this->m_contents = new Contents(*contents);
    }
 
    UnorderedMotif(const UnorderedMotif< CONTENT_TYPE >* toCopy)
        :
        chemical::Class< UnorderedMotif< CONTENT_TYPE > >(this) //TODO: Define Symmetry.
    {
        this->m_contents = new Contents(*toCopy->m_contents);
    }
 
    virtual ~UnorderedMotif()
    {
        //NOTE: Children are responsible for clearing m_contents (e.g. through ClearImplementation()).
    }
 
    virtual void ClearImplementation()
    {
        this->m_contents->Clear();
    }
 
    virtual unsigned long GetCountImplementation() const
    {
        return this->m_contents->GetNumberOfElements();
    }
 
    virtual CONTENT_TYPE AddImplementation(const CONTENT_TYPE content)
    {
        CONTENT_TYPE ret = this->m_contents->Access(this->m_contents->Add(content));
        return ret;
    }
 
    virtual CONTENT_TYPE RemoveImplementation(const CONTENT_TYPE content)
    {
        Index toErase = this->m_contents->SeekTo(content);
        CONTENT_TYPE ret = this->m_contents->Access(toErase);
        this->m_contents->Erase(toErase);
        return ret;
    }
 
    virtual bool HasImplementation(const CONTENT_TYPE content) const
    {
        return this->m_contents->Has(content);
    }
 
    virtual void ImportImplementation(const UnorderedMotif< CONTENT_TYPE >* other)
    {
        BIO_SANITIZE(other, ,
            return);
 
        this->m_contents->Import(other->GetAllImplementation());
    }
 
    virtual unsigned int GetNumMatchingImplementation(const Container* other) const
    {
        BIO_SANITIZE(other, ,
            return 0);
 
        unsigned int ret = 0;
        for (
            SmartIterator otr = other->End();
            !otr.IsAtBeginning();
            --otr
            )
        {
            if (this->HasImplementation(*otr))
            {
                ++ret;
            }
        }
        return ret;
    }
 
    virtual bool HasAllImplementation(const Container* contents) const
    {
        BIO_SANITIZE(contents, ,
            return false);
        return this->GetNumMatchingImplementation(contents) == contents->GetNumberOfElements();
    }
 
    virtual std::string GetStringFromImplementation(std::string separator = ", ")
    {
        std::string ret = "";
        SmartIterator cnt = this->m_contents->Begin();
        while (true)
        {
            ret += string::From< CONTENT_TYPE >(*cnt);
            ++cnt;
            if (cnt.IsAtEnd())
            {
                break;
            }
            ret += separator;
        }
        return ret;
    }
};
 
} //chemical namespace
} //bio namespace