cif::TLSSelectionParserImplBuster Class Reference

Inheritance diagram for cif::TLSSelectionParserImplBuster:

Collaboration diagram for cif::TLSSelectionParserImplBuster:

Public Member Functions
	TLSSelectionParserImplBuster (const std::string &selection)
virtual std::unique_ptr< tls_selection >	Parse ()
Public Member Functions inherited from cif::tls_selection_parser_impl
	tls_selection_parser_impl (const std::string &selection)

Protected Types
enum	TOKEN { bt_NONE = 0, bt_IDENT = 256, bt_NUMBER, bt_EOLN }

Protected Member Functions
virtual int	get_next_token ()
virtual std::string	to_string (int token)
std::unique_ptr< tls_selection >	ParseGroup ()
std::tuple< std::string, int >	ParseAtom ()
std::unique_ptr< tls_selection >	ParseOldGroup ()
Protected Member Functions inherited from cif::tls_selection_parser_impl
virtual void	match (int token)

Protected Attributes
int	m_value_i
std::string	m_value_s
bool	m_parsing_old_style = false
Protected Attributes inherited from cif::tls_selection_parser_impl
std::string	m_selection
std::string::iterator	m_p
std::string::iterator	m_end
int	m_lookahead
std::string	m_token

Detailed Description

Definition at line 1172 of file tls.cpp.

Member Enumeration Documentation

TOKEN

enum cif::TLSSelectionParserImplBuster::TOKEN

protected

Enumerator
bt_NONE
bt_IDENT
bt_NUMBER
bt_EOLN

Definition at line 1180 of file tls.cpp.

    {
        bt_NONE = 0,
        bt_IDENT = 256,
        bt_NUMBER,
        bt_EOLN,
    };

Constructor & Destructor Documentation

TLSSelectionParserImplBuster()

cif::TLSSelectionParserImplBuster::TLSSelectionParserImplBuster

(

const std::string &

selection

)

Definition at line 1201 of file tls.cpp.

    : tls_selection_parser_impl(selection)
{
    m_lookahead = get_next_token();
}

Member Function Documentation

get_next_token()

int cif::TLSSelectionParserImplBuster::get_next_token ( )

protectedvirtual

Implements cif::tls_selection_parser_impl.

Definition at line 1207 of file tls.cpp.

{
    int result = bt_NONE;
    enum STATE
    {
        st_START,
        st_NEGATE,
        st_NUM,
        st_IDENT
    } state = st_START;

    m_value_i = 0;
    m_value_s.clear();
    bool negative = false;

    while (result == bt_NONE)
    {
        char ch = *m_p++;
        if (m_p > m_end)
            ch = 0;

        switch (state)
        {
            case st_START:
                if (ch == 0)
                    result = bt_EOLN;
                else if (isspace(ch))
                    continue;
                else if (isdigit(ch))
                {
                    m_value_i = ch - '0';
                    state = st_NUM;
                }
                else if (isalpha(ch))
                {
                    m_value_s = { ch };
                    state = st_IDENT;
                }
                else if (ch == '-')
                {
                    state = st_NEGATE;
                }
                else
                    result = ch;
                break;

            case st_NEGATE:
                if (isdigit(ch))
                {
                    m_value_i = ch - '0';
                    state = st_NUM;
                    negative = true;
                }
                else
                {
                    --m_p;
                    result = '-';
                }
                break;

            case st_NUM:
                if (isdigit(ch))
                    m_value_i = 10 * m_value_i + (ch - '0');
                else
                {
                    if (negative)
                        m_value_i = -m_value_i;

                    result = bt_NUMBER;
                    --m_p;
                }
                break;

            case st_IDENT:
                if (isalnum(ch))
                    m_value_s += ch;
                else
                {
                    --m_p;
                    result = bt_IDENT;
                }
                break;
        }
    }

    return result;
}

Parse()

std::unique_ptr< tls_selection > cif::TLSSelectionParserImplBuster::Parse ( )

virtual

Implements cif::tls_selection_parser_impl.

Definition at line 1417 of file tls.cpp.

{
    std::unique_ptr<tls_selection> result = ParseGroup();
    match(bt_EOLN);
    return result;
}

ParseAtom()

std::tuple< std::string, int > cif::TLSSelectionParserImplBuster::ParseAtom ( )

protected

Definition at line 1383 of file tls.cpp.

{
    std::string chain = m_value_s;
    int seqNr = kResidueNrWildcard;

    if (m_lookahead == '*')
        match('*');
    else
        match(bt_IDENT);

    match('|');

    if (m_lookahead == '*')
        match('*');
    else
    {
        seqNr = m_value_i;
        match(bt_NUMBER);

        if (m_lookahead == ':')
        {
            match(':');
            std::string atom = m_value_s;

            if (cif::VERBOSE > 0)
                std::cerr << "Warning: ignoring atom ID '" << atom << "' in TLS selection" << std::endl;

            match(bt_IDENT);
        }
    }

    return std::make_tuple(chain, seqNr);
}

ParseGroup()

std::unique_ptr< tls_selection > cif::TLSSelectionParserImplBuster::ParseGroup ( )

protected

Definition at line 1309 of file tls.cpp.

{
    std::unique_ptr<tls_selection> result;

    auto add = [&result](const std::string &chainID, int from, int to)
    {
        std::unique_ptr<tls_selection> sc(new tls_selection_chain(chainID));
        std::unique_ptr<tls_selection> sr(new tls_selection_range_seq(from, to));
        std::unique_ptr<tls_selection> s(new tls_selection_intersection(sc, sr));

        if (result == nullptr)
            result.reset(s.release());
        else
            result.reset(new tls_selection_union{ result, s });
    };

    match('{');

    do
    {
        std::string chain1;
        int seqNr1;
        std::tie(chain1, seqNr1) = ParseAtom();

        if (m_lookahead == '-')
        {
            std::string chain2;
            int seqNr2 = seqNr1;

            match('-');

            if (m_lookahead == bt_NUMBER)
            {
                seqNr2 = m_value_i;
                match(bt_NUMBER);
            }
            else
            {
                std::tie(chain2, seqNr2) = ParseAtom();
                if (chain1 != chain2)
                {
                    std::cerr << "Warning, ranges over multiple chains detected" << std::endl;

                    std::unique_ptr<tls_selection> sc1(new tls_selection_chain(chain1));
                    std::unique_ptr<tls_selection> sr1(new tls_selection_range_seq(seqNr1, kResidueNrWildcard));
                    std::unique_ptr<tls_selection> s1(new tls_selection_intersection(sc1, sr1));

                    std::unique_ptr<tls_selection> sc2(new tls_selection_chain(chain2));
                    std::unique_ptr<tls_selection> sr2(new tls_selection_range_seq(kResidueNrWildcard, seqNr2));
                    std::unique_ptr<tls_selection> s2(new tls_selection_intersection(sc2, sr2));

                    std::unique_ptr<tls_selection> s(new tls_selection_union(s1, s2));

                    if (result == nullptr)
                        result.reset(s.release());
                    else
                        result.reset(new tls_selection_union{ result, s });

                    chain1.clear();
                }
            }

            if (not chain1.empty())
                add(chain1, seqNr1, seqNr2);
        }
        else
            add(chain1, seqNr1, seqNr1);
    } while (m_lookahead != '}');

    match('}');

    return result;
}

ParseOldGroup()

std::unique_ptr<tls_selection> cif::TLSSelectionParserImplBuster::ParseOldGroup ( )

protected

to_string()

std::string cif::TLSSelectionParserImplBuster::to_string ( int  token )

protectedvirtual

Implements cif::tls_selection_parser_impl.

Definition at line 1295 of file tls.cpp.

{
    switch (token)
    {
        case bt_IDENT: return "identifier (" + m_value_s + ')';
        case bt_NUMBER: return "number (" + to_string(m_value_i) + ')';
        case bt_EOLN: return "end of line";

        default:
            assert(false);
            return "unknown token";
    }
}

Member Data Documentation

m_parsing_old_style

bool cif::TLSSelectionParserImplBuster::m_parsing_old_style = false

protected

Definition at line 1198 of file tls.cpp.

m_value_i

int cif::TLSSelectionParserImplBuster::m_value_i

protected

Definition at line 1196 of file tls.cpp.

m_value_s

std::string cif::TLSSelectionParserImplBuster::m_value_s

protected

Definition at line 1197 of file tls.cpp.

---

The documentation for this class was generated from the following file:

• libcifpp/src/pdb/tls.cpp