WildcardLinearString.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <ext/algorithm>
 
#include <alib/set>
#include <alib/vector>
 
#include <core/components.hpp>
 
#include <alphabet/WildcardSymbol.h>
#include <common/DefaultSymbolType.h>
 
#include <exception/CommonException.h>
 
#include <core/normalize.hpp>
#include <alphabet/common/SymbolNormalize.h>
 
#include "LinearString.h"
 
namespace string {
 
class GeneralAlphabet;
class WildcardSymbol;
 
template < class SymbolType = DefaultSymbolType >
class WildcardLinearString final : public core::Components < WildcardLinearString < SymbolType >, ext::set < SymbolType >, component::Set, GeneralAlphabet, SymbolType, component::Value, WildcardSymbol > {
    ext::vector < SymbolType > m_Data;
 
public:
 
    explicit WildcardLinearString ( ext::set < SymbolType > alphabet, ext::vector < SymbolType > str, SymbolType wildcard );
 
    explicit WildcardLinearString ( ext::vector < SymbolType > str, SymbolType wildcard );
 
    explicit WildcardLinearString ( const std::string & str, char wildcard );
 
    explicit WildcardLinearString ( const std::string & str );
 
    explicit WildcardLinearString ( const char * str , char wildcard );
 
    explicit WildcardLinearString ( const LinearString < SymbolType > & string, SymbolType wildcard );
 
    explicit WildcardLinearString ( const LinearString < SymbolType > & string );
 
    const ext::set < SymbolType > & getAlphabet ( ) const & {
        return this->template accessComponent < GeneralAlphabet > ( ).get ( );
    }
 
    ext::set < SymbolType > && getAlphabet ( ) && {
        return std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) );
    }
 
    void extendAlphabet ( const ext::set < SymbolType > & symbols ) {
        this->template accessComponent < GeneralAlphabet > ( ).add( symbols );
    }
 
    const SymbolType & getWildcardSymbol ( ) const & {
        return this->template accessComponent < WildcardSymbol > ( ).get ( );
    }
 
    SymbolType && getWildcardSymbol ( ) && {
        return std::move ( this->template accessComponent < WildcardSymbol > ( ).get ( ) );
    }
 
    bool setWildcardSymbol ( SymbolType wildcard ) {
        return this-> template accessComponent < WildcardSymbol > ( ).set ( std::move ( wildcard ) );
    }
 
    void appendSymbol ( SymbolType symbol );
 
    const ext::vector < SymbolType > & getContent ( ) const &;
 
    ext::vector < SymbolType > && getContent ( ) &&;
 
    void setContent ( ext::vector < SymbolType > str );
 
    bool isEmpty ( ) const;
 
    auto operator <=> ( const WildcardLinearString & other ) const {
        return std::tie ( m_Data, getAlphabet ( ), getWildcardSymbol ( ) ) <=> std::tie ( other.m_Data, other.getAlphabet ( ), other.getWildcardSymbol ( ) );
    }
 
    bool operator == ( const WildcardLinearString & other ) const {
        return std::tie ( m_Data, getAlphabet ( ), getWildcardSymbol ( ) ) == std::tie ( other.m_Data, other.getAlphabet ( ), other.getWildcardSymbol ( ) );
    }
 
    friend ext::ostream & operator << ( ext::ostream & out, const WildcardLinearString & instance ) {
        out << "(WildcardLinearString";
        out << " content = " << instance.getContent ( );
        out << " wildcard = " << instance.getWildcardSymbol ( );
        out << " alphabet = " << instance.getAlphabet ( );
        out << ")";
        return out;
    }
 
};
 
template < class SymbolType >
WildcardLinearString < SymbolType >::WildcardLinearString(ext::set<SymbolType> alphabet, ext::vector<SymbolType> str, SymbolType wildcard) : core::Components < WildcardLinearString, ext::set < SymbolType >, component::Set, GeneralAlphabet, SymbolType, component::Value, WildcardSymbol > ( std::move ( alphabet ), std::move(wildcard) ) {
    setContent(std::move(str));
}
 
template < class SymbolType >
WildcardLinearString < SymbolType >::WildcardLinearString(ext::vector<SymbolType> str, SymbolType wildcard) : WildcardLinearString ( ext::set < SymbolType > ( str.begin(), str.end() ) + ext::set < SymbolType > { wildcard }, str, wildcard ) {
}
 
template < class SymbolType >
WildcardLinearString < SymbolType >::WildcardLinearString(const std::string & str, char wildcard) : WildcardLinearString ( ext::vector < SymbolType > ( str.begin ( ), str.end ( ) ), SymbolType ( wildcard ) ) {
}
 
template < class SymbolType >
WildcardLinearString < SymbolType >::WildcardLinearString(const std::string & str) : WildcardLinearString ( str, alphabet::WildcardSymbol::instance < char > ( ) ) {
}
 
template < class SymbolType >
WildcardLinearString < SymbolType >::WildcardLinearString(const char* str, char wildcard) : WildcardLinearString ( std::string ( str ), wildcard ) {
}
 
template < class SymbolType >
WildcardLinearString < SymbolType >::WildcardLinearString(const LinearString < SymbolType > & string, SymbolType wildcard) : WildcardLinearString ( string.getAlphabet( ) + ext::set < SymbolType > { wildcard }, string.getContent ( ), wildcard ) {
}
 
template < class SymbolType >
WildcardLinearString < SymbolType >::WildcardLinearString(const LinearString < SymbolType > & string) : WildcardLinearString ( string, alphabet::WildcardSymbol::instance < SymbolType > ( ) ) {
}
 
template < class SymbolType >
void WildcardLinearString < SymbolType >::appendSymbol ( SymbolType symbol ) {
    if ( getAlphabet().count ( symbol ) == 0 )
        throw exception::CommonException ( "Input symbol \"" + ext::to_string ( symbol ) + "\" not in the alphabet." );
 
    m_Data.push_back ( std::move ( symbol ) );
}
 
template < class SymbolType >
const ext::vector < SymbolType > & WildcardLinearString < SymbolType >::getContent ( ) const & {
    return this->m_Data;
}
 
template < class SymbolType >
ext::vector < SymbolType > && WildcardLinearString < SymbolType >::getContent ( ) && {
    return std::move ( this->m_Data );
}
 
template < class SymbolType >
void WildcardLinearString < SymbolType >::setContent ( ext::vector < SymbolType > str ) {
    ext::set < SymbolType > minimalAlphabet ( str.begin ( ), str.end ( ) );
    std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), getAlphabet ( ).begin ( ), getAlphabet ( ).end ( ), ext::callback_iterator ( [ ] ( const SymbolType & ) {
            throw exception::CommonException("Input symbols not in the alphabet.");
        } ) );
 
    this->m_Data = std::move ( str );
}
 
template < class SymbolType >
bool WildcardLinearString < SymbolType >::isEmpty ( ) const {
    return this->m_Data.empty ( );
}
 
} /* namespace string */
 
namespace core {
 
template < class SymbolType >
class SetConstraint< string::WildcardLinearString < SymbolType >, SymbolType, string::GeneralAlphabet > {
public:
    static bool used ( const string::WildcardLinearString < SymbolType > & str, const SymbolType & symbol ) {
        const ext::vector<SymbolType>& content = str.getContent ( );
        return std::find(content.begin(), content.end(), symbol) != content.end();
    }
 
    static bool available ( const string::WildcardLinearString < SymbolType > &, const SymbolType & ) {
        return true;
    }
 
    static void valid ( const string::WildcardLinearString < SymbolType > &, const SymbolType & ) {
    }
};
 
template<class SymbolType >
class ElementConstraint< string::WildcardLinearString < SymbolType >, SymbolType, string::WildcardSymbol > {
public:
    static bool available ( const string::WildcardLinearString < SymbolType > & string, const SymbolType & symbol ) {
        return string.getAlphabet ( ).count ( symbol );
    }
 
    static void valid ( const string::WildcardLinearString < SymbolType > &, const SymbolType & ) {
    }
 
};
 
template < class SymbolType >
struct normalize < string::WildcardLinearString < SymbolType > > {
    static string::WildcardLinearString < > eval ( string::WildcardLinearString < SymbolType > && value ) {
        ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
        ext::vector < DefaultSymbolType > content = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( value ).getContent ( ) );
        DefaultSymbolType wildcard = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( value ).getWildcardSymbol ( ) );
        return string::WildcardLinearString < > ( std::move ( alphabet ), std::move ( content ), std::move ( wildcard ) );
    }
};
 
} /* namespace core */
 
extern template class string::WildcardLinearString < >;