cif Namespace Reference

Namespaces
	data
	detail
	mm
	pdb

Classes
class	category_index
class	CCD_compound_factory_impl
class	CCP4_compound_factory_impl
struct	compound_atom_less
struct	compound_bond_less
class	compound_factory_impl
class	dictionary_parser
class	IdentityMatrix
class	Matrix
class	MatrixExpression
class	MatrixMultiplication
class	MatrixSubtraction
struct	my_from_chars
struct	ProgressImpl
struct	regex_impl
class	ResourcePool
class	row_comparator
class	save_value
struct	std_from_chars
class	SymmetricMatrix
struct	tls_residue
struct	tls_selection_all
struct	tls_selection_by_element
struct	tls_selection_by_name
struct	tls_selection_chain
struct	tls_selection_intersection
struct	tls_selection_not
class	tls_selection_parser_impl
struct	tls_selection_range_id
struct	tls_selection_range_seq
struct	tls_selection_res_id
struct	tls_selection_union
class	TLSSelectionParser
class	TLSSelectionParserBase
class	TLSSelectionParserImplBuster
class	TLSSelectionParserImplBusterOld
class	TLSSelectionParserImplPhenix

Enumerations
enum	LineBreakClass {   kLBC_OpenPunctuation, kLBC_ClosePunctuation, kLBC_CloseParenthesis, kLBC_Quotation,   kLBC_NonBreaking, kLBC_Nonstarter, kLBC_Exlamation, kLBC_SymbolAllowingBreakAfter,   kLBC_InfixNumericSeparator, kLBC_PrefixNumeric, kLBC_PostfixNumeric, kLBC_Numeric,   kLBC_Alphabetic, kLBC_Ideographic, kLBC_Inseperable, kLBC_Hyphen,   kLBC_BreakAfter, kLBC_BreakBefor, kLBC_BreakOpportunityBeforeAndAfter, kLBC_ZeroWidthSpace,   kLBC_CombiningMark, kLBC_WordJoiner, kLBC_HangulLVSyllable, kLBC_HangulLVTSyllable,   kLBC_HangulLJamo, kLBC_HangulVJamo, kLBC_HangulTJamo, kLBC_MandatoryBreak,   kLBC_CarriageReturn, kLBC_LineFeed, kLBC_NextLine, kLBC_Surrogate,   kLBC_Space, kLBC_ContigentBreakOpportunity, kLBC_Ambiguous, kLBC_ComplexContext,   kLBC_Unknown }

Functions
std::string	to_string (bond_type bondType)
bond_type	from_string (const std::string &bondType)
iset	get_category_fields (const category &cat)
uint16_t	get_column_ix (const category &cat, std::string_view col)
bool	is_column_type_uchar (const category &cat, std::string_view col)
validator	parse_dictionary (std::string_view name, std::istream &is)
void	dump_selection (const std::vector< tls_residue > &selected, size_t indentLevel)
std::unique_ptr< tls_selection >	parse_tls_selection_details (const std::string &program, const std::string &selection)
template<typename M1 , typename M2 >
MatrixSubtraction< M1, M2 >	operator- (const MatrixExpression< M1 > &m1, const MatrixExpression< M2 > &m2)
template<typename M >
MatrixMultiplication< M >	operator* (const MatrixExpression< M > &m, double v)
template<class M1 >
Matrix	Cofactors (const M1 &m)
template<typename T >
quaternion_type< T >	normalize (quaternion_type< T > q)
quaternion	construct_from_angle_axis (float angle, point axis)
std::tuple< double, point >	quaternion_to_angle_axis (quaternion q)
point	center_points (std::vector< point > &Points)
quaternion	construct_for_dihedral_angle (point p1, point p2, point p3, point p4, float angle, float esd)
point	centroid (const std::vector< point > &pts)
double	RMSd (const std::vector< point > &a, const std::vector< point > &b)
double	LargestDepressedQuarticSolution (double a, double b, double c)
quaternion	align_points (const std::vector< point > &pa, const std::vector< point > &pb)
point	nudge (point p, float offset)
int	get_space_group_number (std::string spacegroup)
int	get_space_group_number (std::string spacegroup, space_group_name type)
bool	iequals (std::string_view a, std::string_view b)
bool	iequals (const char *a, const char *b)
int	icompare (std::string_view a, std::string_view b)
int	icompare (const char *a, const char *b)
void	to_lower (std::string &s)
std::string	to_lower_copy (std::string_view s)
void	to_upper (std::string &s)
void	replace_all (std::string &s, std::string_view what, std::string_view with)
bool	icontains (std::string_view s, std::string_view q)
void	trim_right (std::string &s)
std::string	trim_right_copy (std::string_view s)
std::string	trim_left_copy (std::string_view s)
void	trim_left (std::string &s)
void	trim (std::string &s)
std::string	trim_copy (std::string_view s)
std::tuple< std::string, std::string >	split_tag_name (std::string_view tag)
std::string	cif_id_for_number (int number)
std::string::const_iterator	nextLineBreak (std::string::const_iterator text, std::string::const_iterator end)
std::vector< std::string >	wrapLine (const std::string &text, size_t width)
std::vector< std::string >	word_wrap (const std::string &text, size_t width)
std::string	get_version_nr ()
uint32_t	get_terminal_width ()
std::string	get_executable_path ()
void	add_data_directory (std::filesystem::path dataDir)
void	add_file_resource (const std::string &name, std::filesystem::path dataFile)
std::unique_ptr< std::istream >	load_resource (std::filesystem::path name)
DDL_PrimitiveType	map_to_primitive_type (std::string_view s)

Variables
const uint32_t	kMaxLineLength = 132
row_handle	s_null_row_handle
const int	kResidueNrWildcard = std::numeric_limits<int>::min()
const int	kNoSeqNum = std::numeric_limits<int>::max() - 1
const uint8_t	kCharToLowerMap [256]
const LineBreakClass	kASCII_LBTable [128]
int	VERBOSE = 0

Enumeration Type Documentation

LineBreakClass

enum cif::LineBreakClass

Enumerator
kLBC_OpenPunctuation
kLBC_ClosePunctuation
kLBC_CloseParenthesis
kLBC_Quotation
kLBC_NonBreaking
kLBC_Nonstarter
kLBC_Exlamation
kLBC_SymbolAllowingBreakAfter
kLBC_InfixNumericSeparator
kLBC_PrefixNumeric
kLBC_PostfixNumeric
kLBC_Numeric
kLBC_Alphabetic
kLBC_Ideographic
kLBC_Inseperable
kLBC_Hyphen
kLBC_BreakAfter
kLBC_BreakBefor
kLBC_BreakOpportunityBeforeAndAfter
kLBC_ZeroWidthSpace
kLBC_CombiningMark
kLBC_WordJoiner
kLBC_HangulLVSyllable
kLBC_HangulLVTSyllable
kLBC_HangulLJamo
kLBC_HangulVJamo
kLBC_HangulTJamo
kLBC_MandatoryBreak
kLBC_CarriageReturn
kLBC_LineFeed
kLBC_NextLine
kLBC_Surrogate
kLBC_Space
kLBC_ContigentBreakOpportunity
kLBC_Ambiguous
kLBC_ComplexContext
kLBC_Unknown

Definition at line 268 of file text.cpp.

{
    kLBC_OpenPunctuation,
    kLBC_ClosePunctuation,
    kLBC_CloseParenthesis,
    kLBC_Quotation,
    kLBC_NonBreaking,
    kLBC_Nonstarter,
    kLBC_Exlamation,
    kLBC_SymbolAllowingBreakAfter,
    kLBC_InfixNumericSeparator,
    kLBC_PrefixNumeric,
    kLBC_PostfixNumeric,
    kLBC_Numeric,
    kLBC_Alphabetic,
    kLBC_Ideographic,
    kLBC_Inseperable,
    kLBC_Hyphen,
    kLBC_BreakAfter,
    kLBC_BreakBefor,
    kLBC_BreakOpportunityBeforeAndAfter,
    kLBC_ZeroWidthSpace,
    kLBC_CombiningMark,
    kLBC_WordJoiner,
    kLBC_HangulLVSyllable,
    kLBC_HangulLVTSyllable,
    kLBC_HangulLJamo,
    kLBC_HangulVJamo,
    kLBC_HangulTJamo,

    kLBC_MandatoryBreak,
    kLBC_CarriageReturn,
    kLBC_LineFeed,
    kLBC_NextLine,
    kLBC_Surrogate,
    kLBC_Space,
    kLBC_ContigentBreakOpportunity,
    kLBC_Ambiguous,
    kLBC_ComplexContext,
    kLBC_Unknown
};

Function Documentation

add_data_directory()

void cif::add_data_directory

(

std::filesystem::path

dataDir

)

Definition at line 933 of file utilities.cpp.

{
    ResourcePool::instance().pushDir(dataDir);
}

add_file_resource()

void cif::add_file_resource	(	const std::string &	name,
		std::filesystem::path	dataFile
	)

Definition at line 938 of file utilities.cpp.

{
    ResourcePool::instance().pushAlias(name, dataFile);
}

align_points()

quaternion cif::align_points	(	const std::vector< point > &	pa,
		const std::vector< point > &	pb
	)

Definition at line 467 of file point.cpp.

{
    // First calculate M, a 3x3 Matrix containing the sums of products of the coordinates of A and B
    Matrix M(3, 3, 0);

    for (uint32_t i = 0; i < pa.size(); ++i)
    {
        const point &a = pa[i];
        const point &b = pb[i];

        M(0, 0) += a.m_x * b.m_x;
        M(0, 1) += a.m_x * b.m_y;
        M(0, 2) += a.m_x * b.m_z;
        M(1, 0) += a.m_y * b.m_x;
        M(1, 1) += a.m_y * b.m_y;
        M(1, 2) += a.m_y * b.m_z;
        M(2, 0) += a.m_z * b.m_x;
        M(2, 1) += a.m_z * b.m_y;
        M(2, 2) += a.m_z * b.m_z;
    }

    // Now calculate N, a symmetric 4x4 Matrix
    SymmetricMatrix N(4);

    N(0, 0) = M(0, 0) + M(1, 1) + M(2, 2);
    N(0, 1) = M(1, 2) - M(2, 1);
    N(0, 2) = M(2, 0) - M(0, 2);
    N(0, 3) = M(0, 1) - M(1, 0);

    N(1, 1) = M(0, 0) - M(1, 1) - M(2, 2);
    N(1, 2) = M(0, 1) + M(1, 0);
    N(1, 3) = M(0, 2) + M(2, 0);

    N(2, 2) = -M(0, 0) + M(1, 1) - M(2, 2);
    N(2, 3) = M(1, 2) + M(2, 1);

    N(3, 3) = -M(0, 0) - M(1, 1) + M(2, 2);

    // det(N - λI) = 0
    // find the largest λ (λm)
    //
    // Aλ4 + Bλ3 + Cλ2 + Dλ + E = 0
    // A = 1
    // B = 0
    // and so this is a so-called depressed quartic
    // solve it using Ferrari's algorithm

    double C = -2 * (M(0, 0) * M(0, 0) + M(0, 1) * M(0, 1) + M(0, 2) * M(0, 2) +
                        M(1, 0) * M(1, 0) + M(1, 1) * M(1, 1) + M(1, 2) * M(1, 2) +
                        M(2, 0) * M(2, 0) + M(2, 1) * M(2, 1) + M(2, 2) * M(2, 2));

    double D = 8 * (M(0, 0) * M(1, 2) * M(2, 1) +
                       M(1, 1) * M(2, 0) * M(0, 2) +
                       M(2, 2) * M(0, 1) * M(1, 0)) -
               8 * (M(0, 0) * M(1, 1) * M(2, 2) +
                       M(1, 2) * M(2, 0) * M(0, 1) +
                       M(2, 1) * M(1, 0) * M(0, 2));

    // E is the determinant of N:
    double E =
        (N(0, 0) * N(1, 1) - N(0, 1) * N(0, 1)) * (N(2, 2) * N(3, 3) - N(2, 3) * N(2, 3)) +
        (N(0, 1) * N(0, 2) - N(0, 0) * N(2, 1)) * (N(2, 1) * N(3, 3) - N(2, 3) * N(1, 3)) +
        (N(0, 0) * N(1, 3) - N(0, 1) * N(0, 3)) * (N(2, 1) * N(2, 3) - N(2, 2) * N(1, 3)) +
        (N(0, 1) * N(2, 1) - N(1, 1) * N(0, 2)) * (N(0, 2) * N(3, 3) - N(2, 3) * N(0, 3)) +
        (N(1, 1) * N(0, 3) - N(0, 1) * N(1, 3)) * (N(0, 2) * N(2, 3) - N(2, 2) * N(0, 3)) +
        (N(0, 2) * N(1, 3) - N(2, 1) * N(0, 3)) * (N(0, 2) * N(1, 3) - N(2, 1) * N(0, 3));

    // solve quartic
    double lambda = LargestDepressedQuarticSolution(C, D, E);

    // calculate t = (N - λI)
    Matrix t = N - IdentityMatrix(4) * lambda;

    // calculate a Matrix of cofactors for t
    Matrix cf = Cofactors(t);

    int maxR = 0;
    for (int r = 1; r < 4; ++r)
    {
        if (std::abs(cf(r, 0)) > std::abs(cf(maxR, 0)))
            maxR = r;
    }

    quaternion q(
        static_cast<float>(cf(maxR, 0)), 
        static_cast<float>(cf(maxR, 1)), 
        static_cast<float>(cf(maxR, 2)), 
        static_cast<float>(cf(maxR, 3)));
    q = normalize(q);

    return q;
}

center_points()

point cif::center_points

(

std::vector< point > &

Points

)

Definition at line 334 of file point.cpp.

{
    point t;

    for (point &pt : Points)
    {
        t.m_x += pt.m_x;
        t.m_y += pt.m_y;
        t.m_z += pt.m_z;
    }

    t.m_x /= Points.size();
    t.m_y /= Points.size();
    t.m_z /= Points.size();

    for (point &pt : Points)
    {
        pt.m_x -= t.m_x;
        pt.m_y -= t.m_y;
        pt.m_z -= t.m_z;
    }

    return t;
}

centroid()

point cif::centroid

(

const std::vector< point > &

pts

)

Definition at line 397 of file point.cpp.

{
    point result;

    for (auto &pt : pts)
        result += pt;

    result /= static_cast<float>(pts.size());

    return result;
}

cif_id_for_number()

std::string cif::cif_id_for_number

(

int

number

)

Definition at line 235 of file text.cpp.

{
    std::string result;

    if (number >= 26 * 26 * 26)
        result = 'L' + std::to_string(number);
    else
    {
        if (number >= 26 * 26)
        {
            int v = number / (26 * 26);
            result += char('A' - 1 + v);
            number %= (26 * 26);
        }

        if (number >= 26)
        {
            int v = number / 26;
            result += char('A' - 1 + v);
            number %= 26;
        }

        result += char('A' + number);
    }

    assert(not result.empty());
    return result;
}

Cofactors()

template<class M1 >

Matrix cif::Cofactors

(

const M1 &

m

)

Definition at line 240 of file point.cpp.

{
    Matrix cf(m.dim_m(), m.dim_m());

    const size_t ixs[4][3] = {
        { 1, 2, 3 },
        { 0, 2, 3 },
        { 0, 1, 3 },
        { 0, 1, 2 }
    };

    for (size_t x = 0; x < 4; ++x)
    {
        const size_t *ix = ixs[x];

        for (size_t y = 0; y < 4; ++y)
        {
            const size_t *iy = ixs[y];

            cf(x, y) =
                m(ix[0], iy[0]) * m(ix[1], iy[1]) * m(ix[2], iy[2]) +
                m(ix[0], iy[1]) * m(ix[1], iy[2]) * m(ix[2], iy[0]) +
                m(ix[0], iy[2]) * m(ix[1], iy[0]) * m(ix[2], iy[1]) -
                m(ix[0], iy[2]) * m(ix[1], iy[1]) * m(ix[2], iy[0]) -
                m(ix[0], iy[1]) * m(ix[1], iy[0]) * m(ix[2], iy[2]) -
                m(ix[0], iy[0]) * m(ix[1], iy[2]) * m(ix[2], iy[1]);

            if ((x + y) % 2 == 1)
                cf(x, y) *= -1;
        }
    }

    return cf;
}

construct_for_dihedral_angle()

quaternion cif::construct_for_dihedral_angle	(	point	p1,
		point	p2,
		point	p3,
		point	p4,
		float	angle,
		float	esd
	)

Definition at line 359 of file point.cpp.

{
    p1 -= p3;
    p2 -= p3;
    p4 -= p3;
    p3 -= p3;

    quaternion q;
    auto axis = p2;

    float dh = dihedral_angle(p1, p2, p3, p4);
    for (int iteration = 0; iteration < 100; ++iteration)
    {
        float delta = std::fmod(angle - dh, 360.0f);

        if (delta < -180)
            delta += 360;
        if (delta > 180)
            delta -= 360;

        if (std::abs(delta) < esd)
            break;

        // if (iteration > 0)
        //  std::cout << cif::coloured(("iteration " + std::to_string(iteration)).c_str(), cif::scBLUE, cif::scBLACK) << " delta: " << delta << std::endl;

        auto q2 = construct_from_angle_axis(delta, axis);
        q = iteration == 0 ? q2 : q * q2;
            
        p4.rotate(q2);

        dh = dihedral_angle(p1, p2, p3, p4);
    }

    return q;
}

construct_from_angle_axis()

quaternion cif::construct_from_angle_axis	(	float	angle,
		point	axis
	)

Definition at line 301 of file point.cpp.

{
    auto q = std::cos((angle * kPI / 180) / 2);
    auto s = std::sqrt(1 - q * q);

    axis.normalize();

    return normalize(quaternion{
        static_cast<float>(q),
        static_cast<float>(s * axis.m_x),
        static_cast<float>(s * axis.m_y),
        static_cast<float>(s * axis.m_z) });
}

dump_selection()

void cif::dump_selection	(	const std::vector< tls_residue > &	selected,
		size_t	indentLevel
	)

Definition at line 69 of file tls.cpp.

{
    std::string indent(indentLevel * 2, ' ');

    auto i = selected.begin();
    bool first = true;

    // First print in PDB space
    while (i != selected.end())
    {
        auto b = find_if(i, selected.end(), [](auto s) -> bool
            { return s.selected; });
        if (b == selected.end())
            break;

        if (first)
            std::cout << indent << "PDB:" << std::endl;
        first = false;

        auto e = find_if(b, selected.end(), [b](auto s) -> bool
            { return s.chainID != b->chainID or not s.selected; });

        std::cout << indent << " >> " << b->chainID << ' ' << b->seqNr << ':' << (e - 1)->seqNr << std::endl;
        i = e;
    }

    // Then in mmCIF space

    if (not first)
        std::cout << indent << "mmCIF:" << std::endl;

    i = selected.begin();
    while (i != selected.end())
    {
        auto b = find_if(i, selected.end(), [](auto s) -> bool
            { return s.selected; });
        if (b == selected.end())
            break;

        auto e = find_if(b, selected.end(), [b](auto s) -> bool
            { return s.asymID != b->asymID or not s.selected; });

        std::string asymID = b->asymID;
        int from = b->seqID, to = from;

        for (auto j = b + 1; j != e; ++j)
        {
            if (j->seqID == to + 1)
                to = j->seqID;
            else if (j->seqID != to) // probably an insertion code
            {
                if (from == kNoSeqNum or to == kNoSeqNum)
                    std::cout << indent << " >> " << asymID << std::endl;
                else
                    std::cout << indent << " >> " << asymID << ' ' << from << ':' << to << std::endl;
                asymID = b->asymID;
                from = to = b->seqID;
            }
        }

        if (from == kNoSeqNum or to == kNoSeqNum)
            std::cout << indent << " >> " << asymID << std::endl;
        else
            std::cout << indent << " >> " << asymID << ' ' << from << ':' << to << std::endl;

        i = e;
    }

    if (first)
    {
        if (isatty(STDOUT_FILENO))
            std::cout << indent << cif::coloured("Empty selection") << std::endl;
        else
            std::cout << indent << "Empty selection" << std::endl;
    }
}

from_string()

bond_type cif::from_string

(

const std::string &

bondType

)

Definition at line 59 of file compound.cpp.

{
    if (cif::iequals(bondType, "sing"))
        return bond_type::sing;
    if (cif::iequals(bondType, "doub"))
        return bond_type::doub;
    if (cif::iequals(bondType, "trip"))
        return bond_type::trip;
    if (cif::iequals(bondType, "quad"))
        return bond_type::quad;
    if (cif::iequals(bondType, "arom"))
        return bond_type::arom;
    if (cif::iequals(bondType, "poly"))
        return bond_type::poly;
    if (cif::iequals(bondType, "delo"))
        return bond_type::delo;
    if (cif::iequals(bondType, "pi"))
        return bond_type::pi;
    throw std::invalid_argument("Invalid bondType: " + bondType);
}

get_category_fields()

iset cif::get_category_fields

(

const category &

cat

)

Definition at line 34 of file condition.cpp.

{
    return cat.key_fields();
}

get_column_ix()

uint16_t cif::get_column_ix	(	const category &	cat,
		std::string_view	col
	)

Definition at line 39 of file condition.cpp.

{
    return cat.get_column_ix(col);
}

get_executable_path()

std::string cif::get_executable_path

(

)

Definition at line 123 of file utilities.cpp.

{
    using namespace std::literals;

    // This used to be PATH_MAX, but lets simply assume 1024 is enough...
    char path[1024] = "";
    if (readlink("/proc/self/exe", path, sizeof(path)) == -1)
        throw std::runtime_error("could not get exe path "s + strerror(errno));
    return {path};
}

get_space_group_number() [1/2]

int cif::get_space_group_number

(

std::string

spacegroup

)

Definition at line 43 of file symmetry.cpp.

{
    if (spacegroup == "P 21 21 2 A")
        spacegroup = "P 21 21 2 (a)";
    else if (spacegroup.empty())
        throw std::runtime_error("No spacegroup, cannot continue");

    int result = 0;

    const size_t N = kNrOfSpaceGroups;
    int32_t L = 0, R = static_cast<int32_t>(N - 1);
    while (L <= R)
    {
        int32_t i = (L + R) / 2;

        int d = spacegroup.compare(kSpaceGroups[i].name);

        if (d > 0)
            L = i + 1;
        else if (d < 0)
            R = i - 1;
        else
        {
            result = kSpaceGroups[i].nr;
            break;
        }
    }

    // not found, see if we can find a match based on xHM name
    if (result == 0)
    {
        for (size_t i = 0; i < kNrOfSpaceGroups; ++i)
        {
            auto& sp = kSpaceGroups[i];
            if (sp.xHM == spacegroup)
            {
                result = sp.nr;
                break;
            }
        }
    }

    if (result == 0)
        throw std::runtime_error("Spacegroup name " + spacegroup + " was not found in table");
    
    return result;
}

get_space_group_number() [2/2]

int cif::get_space_group_number	(	std::string	spacegroup,
		space_group_name	type
	)

Definition at line 93 of file symmetry.cpp.

{
    if (spacegroup == "P 21 21 2 A")
        spacegroup = "P 21 21 2 (a)";
    else if (spacegroup.empty())
        throw std::runtime_error("No spacegroup, cannot continue");

    int result = 0;

    if (type == space_group_name::full)
    {
        const size_t N = kNrOfSpaceGroups;
        int32_t L = 0, R = static_cast<int32_t>(N - 1);
        while (L <= R)
        {
            int32_t i = (L + R) / 2;

            int d = spacegroup.compare(kSpaceGroups[i].name);

            if (d > 0)
                L = i + 1;
            else if (d < 0)
                R = i - 1;
            else
            {
                result = kSpaceGroups[i].nr;
                break;
            }
        }
    }
    else if (type == space_group_name::xHM)
    {
        for (auto &sg : kSpaceGroups)
        {
            if (sg.xHM == spacegroup)
            {
                result = sg.nr;
                break;
            }
        }
    }
    else
    {
        for (auto &sg : kSpaceGroups)
        {
            if (sg.Hall == spacegroup)
            {
                result = sg.nr;
                break;
            }
        }
    }

    // not found, see if we can find a match based on xHM name
    if (result == 0)
        throw std::runtime_error("Spacegroup name " + spacegroup + " was not found in table");
    
    return result;
}

get_terminal_width()

uint32_t cif::get_terminal_width

(

)

Definition at line 110 of file utilities.cpp.

{
    uint32_t result = 80;

    if (isatty(STDOUT_FILENO))
    {
        struct winsize w;
        ioctl(0, TIOCGWINSZ, &w);
        result = w.ws_col;
    }
    return result;
}

get_version_nr()

std::string cif::get_version_nr

(

)

Definition at line 62 of file utilities.cpp.

{
    std::ostringstream s;
    write_version_string(s, false);
    return s.str();
}

icompare() [1/2]

int cif::icompare	(	std::string_view	a,
		std::string_view	b
	)

Definition at line 77 of file text.cpp.

{
    int d = 0;
    auto ai = a.begin(), bi = b.begin();

    for (; d == 0 and ai != a.end() and bi != b.end(); ++ai, ++bi)
        d = tolower(*ai) - tolower(*bi);

    if (d == 0)
    {
        if (ai != a.end())
            d = 1;
        else if (bi != b.end())
            d = -1;
    }

    return d;
}

icompare() [2/2]

int cif::icompare	(	const char *	a,
		const char *	b
	)

Definition at line 96 of file text.cpp.

{
    int d = 0;

    for (; d == 0 and *a != 0 and *b != 0; ++a, ++b)
        d = tolower(*a) - tolower(*b);

    if (d == 0)
    {
        if (*a != 0)
            d = 1;
        else if (*b != 0)
            d = -1;
    }

    return d;
}

icontains()

bool cif::icontains	(	std::string_view	s,
		std::string_view	q
	)

Definition at line 143 of file text.cpp.

{
    return contains(to_lower_copy(s), to_lower_copy(q));
}

iequals() [1/2]

bool cif::iequals	(	std::string_view	a,
		std::string_view	b
	)

Definition at line 59 of file text.cpp.

{
    bool result = a.length() == b.length();
    for (auto ai = a.begin(), bi = b.begin(); result and ai != a.end(); ++ai, ++bi)
        result = kCharToLowerMap[uint8_t(*ai)] == kCharToLowerMap[uint8_t(*bi)];
    // result = tolower(*ai) == tolower(*bi);
    return result;
}

iequals() [2/2]

bool cif::iequals	(	const char *	a,
		const char *	b
	)

Definition at line 68 of file text.cpp.

{
    bool result = true;
    for (; result and *a and *b; ++a, ++b)
        result = tolower(*a) == tolower(*b);

    return result and *a == *b;
}

is_column_type_uchar()

bool cif::is_column_type_uchar	(	const category &	cat,
		std::string_view	col
	)

Definition at line 44 of file condition.cpp.

{
    bool result = false;

    auto cv = cat.get_cat_validator();
    if (cv)
    {
        auto iv = cv->get_validator_for_item(col);
        if (iv != nullptr and iv->m_type != nullptr)
        {
            auto type = iv->m_type;
            result = type->m_primitive_type == DDL_PrimitiveType::UChar;
        }
    }

    return result;
}

LargestDepressedQuarticSolution()

double cif::LargestDepressedQuarticSolution	(	double	a,
		double	b,
		double	c
	)

Definition at line 437 of file point.cpp.

{
    std::complex<double> P = -(a * a) / 12 - c;
    std::complex<double> Q = -(a * a * a) / 108 + (a * c) / 3 - (b * b) / 8;
    std::complex<double> R = -Q / 2.0 + std::sqrt((Q * Q) / 4.0 + (P * P * P) / 27.0);

    std::complex<double> U = std::pow(R, 1 / 3.0);

    std::complex<double> y;
    if (U == 0.0)
        y = -5.0 * a / 6.0 + U - std::pow(Q, 1.0 / 3.0);
    else
        y = -5.0 * a / 6.0 + U - P / (3.0 * U);

    std::complex<double> W = std::sqrt(a + 2.0 * y);

    // And to get the final result:
    // result = (±W + std::sqrt(-(3 * alpha + 2 * y ± 2 * beta / W))) / 2;
    // We want the largest result, so:

    std::valarray<double> t(4);

    t[0] = ((W + std::sqrt(-(3.0 * a + 2.0 * y + 2.0 * b / W))) / 2.0).real();
    t[1] = ((W + std::sqrt(-(3.0 * a + 2.0 * y - 2.0 * b / W))) / 2.0).real();
    t[2] = ((-W + std::sqrt(-(3.0 * a + 2.0 * y + 2.0 * b / W))) / 2.0).real();
    t[3] = ((-W + std::sqrt(-(3.0 * a + 2.0 * y - 2.0 * b / W))) / 2.0).real();

    return t.max();
}

load_resource()

std::unique_ptr<std::istream> cif::load_resource

(

std::filesystem::path

name

)

Definition at line 943 of file utilities.cpp.

{
    return ResourcePool::instance().load(name);
}

map_to_primitive_type()

DDL_PrimitiveType cif::map_to_primitive_type

(

std::string_view

s

)

Definition at line 72 of file validate.cpp.

{
    DDL_PrimitiveType result;
    if (iequals(s, "char"))
        result = DDL_PrimitiveType::Char;
    else if (iequals(s, "uchar"))
        result = DDL_PrimitiveType::UChar;
    else if (iequals(s, "numb"))
        result = DDL_PrimitiveType::Numb;
    else
        throw validation_error("Not a known primitive type");
    return result;
}

nextLineBreak()

std::string::const_iterator cif::nextLineBreak	(	std::string::const_iterator	text,
		std::string::const_iterator	end
	)

Definition at line 334 of file text.cpp.

{
    if (text == end)
        return text;

    enum breakAction
    {
        DBK = 0, // direct break    (blank in table)
        IBK,     // indirect break  (% in table)
        PBK,     // prohibited break (^ in table)
        CIB,     // combining indirect break
        CPB      // combining prohibited break
    };

    const breakAction brkTable[27][27] = {
        //        OP   CL   CP   QU   GL   NS   EX   SY   IS   PR   PO   NU   AL   ID   IN   HY   BA   BB   B2   ZW   CM   WJ   H2   H3   JL   JV   JT
        /* OP */ {PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, PBK, CPB, PBK, PBK, PBK, PBK, PBK, PBK},
        /* CL */ {DBK, PBK, PBK, IBK, IBK, PBK, PBK, PBK, PBK, IBK, IBK, DBK, DBK, DBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* CP */ {DBK, PBK, PBK, IBK, IBK, PBK, PBK, PBK, PBK, IBK, IBK, IBK, IBK, DBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* QU */ {PBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, PBK, CIB, PBK, IBK, IBK, IBK, IBK, IBK},
        /* GL */ {IBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, PBK, CIB, PBK, IBK, IBK, IBK, IBK, IBK},
        /* NS */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, DBK, DBK, DBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* EX */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, DBK, DBK, DBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* SY */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, IBK, DBK, DBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* IS */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, IBK, IBK, DBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* PR */ {IBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, IBK, IBK, IBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, IBK, IBK, IBK, IBK, IBK},
        /* PO */ {IBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, IBK, IBK, DBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* NU */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, IBK, IBK, IBK, IBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* AL */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, IBK, IBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* ID */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, IBK, DBK, DBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* IN */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, DBK, DBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* HY */ {DBK, PBK, PBK, IBK, DBK, IBK, PBK, PBK, PBK, DBK, DBK, IBK, DBK, DBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* BA */ {DBK, PBK, PBK, IBK, DBK, IBK, PBK, PBK, PBK, DBK, DBK, DBK, DBK, DBK, DBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* BB */ {IBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, PBK, CIB, PBK, IBK, IBK, IBK, IBK, IBK},
        /* B2 */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, DBK, DBK, DBK, DBK, IBK, IBK, DBK, PBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* ZW */ {DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK, PBK, DBK, DBK, DBK, DBK, DBK, DBK, DBK},
        /* CM */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, DBK, IBK, IBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, DBK},
        /* WJ */ {IBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, IBK, PBK, CIB, PBK, IBK, IBK, IBK, IBK, IBK},
        /* H2 */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, IBK, DBK, DBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, IBK, IBK},
        /* H3 */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, IBK, DBK, DBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, IBK},
        /* JL */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, IBK, DBK, DBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, IBK, IBK, IBK, IBK, DBK},
        /* JV */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, IBK, DBK, DBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, IBK, IBK},
        /* JT */ {DBK, PBK, PBK, IBK, IBK, IBK, PBK, PBK, PBK, DBK, IBK, DBK, DBK, DBK, IBK, IBK, IBK, DBK, DBK, PBK, CIB, PBK, DBK, DBK, DBK, DBK, IBK},
    };

    uint8_t ch = static_cast<uint8_t>(*text);

    LineBreakClass cls;

    if (ch == '\n')
        cls = kLBC_MandatoryBreak;
    else if (ch < 128)
    {
        cls = kASCII_LBTable[ch];
        if (cls > kLBC_MandatoryBreak and cls != kLBC_Space) // duh...
            cls = kLBC_Alphabetic;
    }
    else
        cls = kLBC_Unknown;

    if (cls == kLBC_Space)
        cls = kLBC_WordJoiner;

    LineBreakClass ncls = cls;

    while (++text != end and cls != kLBC_MandatoryBreak)
    {
        ch = *text;

        LineBreakClass lcls = ncls;

        if (ch == '\n')
        {
            ++text;
            break;
        }

        ncls = kASCII_LBTable[ch];

        if (ncls == kLBC_Space)
            continue;

        breakAction brk = brkTable[cls][ncls];

        if (brk == DBK or (brk == IBK and lcls == kLBC_Space))
            break;

        cls = ncls;
    }

    return text;
}

normalize()

template<typename T >

quaternion_type<T> cif::normalize

(

quaternion_type< T >

q

)

Definition at line 278 of file point.cpp.

{
    std::valarray<double> t(4);

    t[0] = q.get_a();
    t[1] = q.get_b();
    t[2] = q.get_c();
    t[3] = q.get_d();

    t *= t;

    double length = std::sqrt(t.sum());

    if (length > 0.001)
        q /= static_cast<quaternion::value_type>(length);
    else
        q = quaternion(1, 0, 0, 0);

    return q;
}

nudge()

point cif::nudge	(	point	p,
		float	offset
	)

Definition at line 562 of file point.cpp.

{
    static const float kPI_f = static_cast<float>(kPI);

    static std::random_device rd;
    static std::mt19937_64 rng(rd());

    std::uniform_real_distribution<float> randomAngle(0, 2 * kPI_f);
    std::normal_distribution<float> randomOffset(0, offset);

    float theta = randomAngle(rng);
    float phi1 = randomAngle(rng) - kPI_f;
    float phi2 = randomAngle(rng) - kPI_f;

    quaternion q = spherical(1.0f, theta, phi1, phi2);

    point r{ 0, 0, 1 };
    r.rotate(q);
    r *= randomOffset(rng);

    return p + r;
}

operator*()

template<typename M >

MatrixMultiplication<M> cif::operator*	(	const MatrixExpression< M > &	m,
		double	v
	)

Definition at line 232 of file point.cpp.

{
    return MatrixMultiplication(*static_cast<const M *>(&m), v);
}

operator-()

template<typename M1 , typename M2 >

MatrixSubtraction<M1, M2> cif::operator-	(	const MatrixExpression< M1 > &	m1,
		const MatrixExpression< M2 > &	m2
	)

Definition at line 203 of file point.cpp.

{
    return MatrixSubtraction(*static_cast<const M1 *>(&m1), *static_cast<const M2 *>(&m2));
}

parse_dictionary()

validator cif::parse_dictionary	(	std::string_view	name,
		std::istream &	is
	)

Definition at line 473 of file dictionary_parser.cpp.

{
    validator result(name);

    file f;
    dictionary_parser p(result, is, f);
    p.load_dictionary();

    return result;
}

parse_tls_selection_details()

std::unique_ptr<tls_selection> cif::parse_tls_selection_details	(	const std::string &	program,
		const std::string &	selection
	)

Definition at line 1947 of file tls.cpp.

{
    TLSSelectionParser<TLSSelectionParserImplPhenix> phenix;
    TLSSelectionParser<TLSSelectionParserImplBuster> buster;
    TLSSelectionParser<TLSSelectionParserImplBusterOld> busterOld;

    std::unique_ptr<tls_selection> result;

    if (cif::icontains(program, "buster"))
    {
        result = buster.Parse(selection);

        if (not result)
        {
            if (cif::VERBOSE > 0)
                std::cerr << "Falling back to old BUSTER" << std::endl;
            result = busterOld.Parse(selection);
        }

        if (not result)
        {
            if (cif::VERBOSE > 0)
                std::cerr << "Falling back to PHENIX" << std::endl;
            result = phenix.Parse(selection);
        }
    }
    else if (cif::icontains(program, "phenix"))
    {
        result = phenix.Parse(selection);

        if (not result)
        {
            if (cif::VERBOSE > 0)
                std::cerr << "Falling back to BUSTER" << std::endl;
            result = buster.Parse(selection);
        }

        if (not result)
        {
            if (cif::VERBOSE > 0)
                std::cerr << "Falling back to old BUSTER" << std::endl;
            result = busterOld.Parse(selection);
        }
    }
    else
    {
        if (cif::VERBOSE > 0)
            std::cerr << "No known program specified, trying PHENIX" << std::endl;

        result = phenix.Parse(selection);

        if (not result)
        {
            if (cif::VERBOSE > 0)
                std::cerr << "Falling back to BUSTER" << std::endl;
            result = buster.Parse(selection);
        }

        if (not result)
        {
            if (cif::VERBOSE > 0)
                std::cerr << "Falling back to old BUSTER" << std::endl;
            result = busterOld.Parse(selection);
        }
    }

    return result;
}

quaternion_to_angle_axis()

std::tuple<double, point> cif::quaternion_to_angle_axis

(

quaternion

q

)

Definition at line 315 of file point.cpp.

{
    if (q.get_a() > 1)
        q = normalize(q);

    // angle:
    double angle = 2 * std::acos(q.get_a());
    angle = angle * 180 / kPI;

    // axis:
    float s = std::sqrt(1 - q.get_a() * q.get_a());
    if (s < 0.001)
        s = 1;

    point axis(q.get_b() / s, q.get_c() / s, q.get_d() / s);

    return { angle, axis };
}

replace_all()

void cif::replace_all	(	std::string &	s,
		std::string_view	what,
		std::string_view	with
	)

Definition at line 134 of file text.cpp.

{
    for (std::string::size_type p = s.find(what); p != std::string::npos; p = s.find(what, p))
    {
        s.replace(p, what.length(), with);
        p += with.length();
    }
}

RMSd()

double cif::RMSd	(	const std::vector< point > &	a,
		const std::vector< point > &	b
	)

Definition at line 409 of file point.cpp.

{
    double sum = 0;
    for (uint32_t i = 0; i < a.size(); ++i)
    {
        std::valarray<double> d(3);

        d[0] = b[i].m_x - a[i].m_x;
        d[1] = b[i].m_y - a[i].m_y;
        d[2] = b[i].m_z - a[i].m_z;

        d *= d;

        sum += d.sum();
    }

    return std::sqrt(sum / a.size());
}

split_tag_name()

std::tuple<std::string, std::string> cif::split_tag_name

(

std::string_view

tag

)

Definition at line 218 of file text.cpp.

{
    if (tag.empty())
        throw std::runtime_error("empty tag");
    if (tag[0] != '_')
        throw std::runtime_error("tag '" + std::string { tag } + "' does not start with underscore");

    auto s = tag.find('.');
    if (s == std::string::npos)
        // throw std::runtime_error("tag does not contain dot (" + std::string{ tag } + ')');
        return std::tuple<std::string, std::string>{ "", tag.substr(1) };
    else
        return std::tuple<std::string, std::string>{tag.substr(1, s - 1), tag.substr(s + 1)};
}

to_lower()

void cif::to_lower

(

std::string &

s

)

Definition at line 114 of file text.cpp.

{
    for (auto &c : s)
        c = tolower(c);
}

to_lower_copy()

std::string cif::to_lower_copy

(

std::string_view

s

)

Definition at line 120 of file text.cpp.

{
    std::string result(s);
    for (auto &c : result)
        c = tolower(c);
    return result;
}

to_string()

std::string cif::to_string

(

bond_type

bondType

)

Definition at line 43 of file compound.cpp.

{
    switch (bondType)
    {
        case bond_type::sing: return "sing";
        case bond_type::doub: return "doub";
        case bond_type::trip: return "trip";
        case bond_type::quad: return "quad";
        case bond_type::arom: return "arom";
        case bond_type::poly: return "poly";
        case bond_type::delo: return "delo";
        case bond_type::pi: return "pi";
    }
    throw std::invalid_argument("Invalid bondType");
}

to_upper()

void cif::to_upper

(

std::string &

s

)

Definition at line 128 of file text.cpp.

{
    for (auto &c : s)
        c = static_cast<char>(toupper(c));
}

trim()

void cif::trim

(

std::string &

s

)

Definition at line 205 of file text.cpp.

{
    trim_right(s);
    trim_left(s);
}

trim_copy()

std::string cif::trim_copy

(

std::string_view

s

)

Definition at line 211 of file text.cpp.

{
    return trim_left_copy(trim_right_copy(s));
}

trim_left()

void cif::trim_left

(

std::string &

s

)

Definition at line 191 of file text.cpp.

{
    auto b = s.begin();
    while (b != s.end())
    {
        if (not std::isspace(*b))
            break;

        b = std::next(b);
    }

    s.erase(s.begin(), b);
}

trim_left_copy()

std::string cif::trim_left_copy

(

std::string_view

s

)

Definition at line 177 of file text.cpp.

{
    auto b = s.begin();
    while (b != s.end())
    {
        if (not std::isspace(*b))
            break;

        b = std::next(b);
    }

    return {b, s.end()};
}

trim_right()

void cif::trim_right

(

std::string &

s

)

Definition at line 148 of file text.cpp.

{
    auto e = s.end();
    while (e != s.begin())
    {
        auto pe = std::prev(e);
        if (not std::isspace(*pe))
            break;
        e = pe;
    }

    if (e != s.end())
        s.erase(e, s.end());
}

trim_right_copy()

std::string cif::trim_right_copy

(

std::string_view

s

)

Definition at line 163 of file text.cpp.

{
    auto e = s.end();
    while (e != s.begin())
    {
        auto pe = std::prev(e);
        if (not std::isspace(*pe))
            break;
        e = pe;
    }

    return {s.begin(), e};
}

word_wrap()

std::vector<std::string> cif::word_wrap	(	const std::string &	text,
		size_t	width
	)

Definition at line 488 of file text.cpp.

{
    std::vector<std::string> result;
    for (auto p : cif::split<std::string>(text, "\n"))
    {
        if (p.empty())
        {
            result.push_back("");
            continue;
        }

        auto lines = wrapLine(p, width);
        result.insert(result.end(), lines.begin(), lines.end());
    }

    return result;
}

wrapLine()

std::vector<std::string> cif::wrapLine	(	const std::string &	text,
		size_t	width
	)

Definition at line 427 of file text.cpp.

{
    std::vector<std::string> result;
    std::vector<size_t> offsets = {0};

    auto b = text.begin();
    while (b != text.end())
    {
        auto e = nextLineBreak(b, text.end());

        offsets.push_back(e - text.begin());

        b = e;
    }

    size_t count = offsets.size() - 1;

    std::vector<size_t> minima(count + 1, 1000000);
    minima[0] = 0;
    std::vector<size_t> breaks(count + 1, 0);

    for (size_t i = 0; i < count; ++i)
    {
        size_t j = i + 1;
        while (j <= count)
        {
            size_t w = offsets[j] - offsets[i];

            if (w > width)
                break;

            while (w > 0 and isspace(text[offsets[i] + w - 1]))
                --w;

            size_t cost = minima[i];
            if (j < count) // last line may be shorter
                cost += (width - w) * (width - w);

            if (cost < minima[j])
            {
                minima[j] = cost;
                breaks[j] = i;
            }

            ++j;
        }
    }

    size_t j = count;
    while (j > 0)
    {
        size_t i = breaks[j];
        result.push_back(text.substr(offsets[i], offsets[j] - offsets[i]));
        j = i;
    }

    reverse(result.begin(), result.end());

    return result;
}

Variable Documentation

kASCII_LBTable

const LineBreakClass cif::kASCII_LBTable[128]

Initial value:

=
    {
        kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark,
        kLBC_CombiningMark, kLBC_BreakAfter, kLBC_LineFeed, kLBC_MandatoryBreak, kLBC_MandatoryBreak, kLBC_CarriageReturn, kLBC_CombiningMark, kLBC_CombiningMark,
        kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark,
        kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark, kLBC_CombiningMark,
        kLBC_Space, kLBC_Exlamation, kLBC_Quotation, kLBC_Alphabetic, kLBC_PrefixNumeric, kLBC_PostfixNumeric, kLBC_Alphabetic, kLBC_Quotation,
        kLBC_OpenPunctuation, kLBC_CloseParenthesis, kLBC_Alphabetic, kLBC_PrefixNumeric,

        
        kLBC_SymbolAllowingBreakAfter ,

        kLBC_Hyphen, kLBC_InfixNumericSeparator, kLBC_SymbolAllowingBreakAfter,
        kLBC_Numeric, kLBC_Numeric, kLBC_Numeric, kLBC_Numeric, kLBC_Numeric, kLBC_Numeric, kLBC_Numeric, kLBC_Numeric,
        kLBC_Numeric, kLBC_Numeric, kLBC_InfixNumericSeparator, kLBC_InfixNumericSeparator, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Exlamation,
        kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic,
        kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic,
        kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic,
        kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_OpenPunctuation, kLBC_PrefixNumeric, kLBC_CloseParenthesis, kLBC_Alphabetic, kLBC_Alphabetic,
        kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic,
        kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic,
        kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic,
        kLBC_Alphabetic, kLBC_Alphabetic, kLBC_Alphabetic, kLBC_OpenPunctuation, kLBC_BreakAfter, kLBC_ClosePunctuation, kLBC_Alphabetic, kLBC_CombiningMark}

Definition at line 310 of file text.cpp.

kCharToLowerMap

const uint8_t cif::kCharToLowerMap[256]

Initial value:

=
    {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
        0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
        0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
        0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
        0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
        0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
        0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
        0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
        0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
        0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
        0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
        0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff}

Definition at line 38 of file text.cpp.

kMaxLineLength

const uint32_t cif::kMaxLineLength = 132

Definition at line 42 of file category.cpp.

kNoSeqNum

const int cif::kNoSeqNum = std::numeric_limits<int>::max() - 1

Definition at line 41 of file tls.cpp.

kResidueNrWildcard

const int cif::kResidueNrWildcard = std::numeric_limits<int>::min()

Definition at line 40 of file tls.cpp.

s_null_row_handle

row_handle cif::s_null_row_handle

Definition at line 35 of file item.cpp.

VERBOSE

int cif::VERBOSE = 0

Definition at line 58 of file utilities.cpp.