cif::compound_factory_impl Class Reference

Inheritance diagram for cif::compound_factory_impl:

Collaboration diagram for cif::compound_factory_impl:

Public Member Functions
	compound_factory_impl (std::shared_ptr< compound_factory_impl > next)
	compound_factory_impl (const fs::path &file, std::shared_ptr< compound_factory_impl > next)
virtual	~compound_factory_impl ()
compound *	get (std::string id)
std::shared_ptr< compound_factory_impl >	next () const
bool	is_known_peptide (const std::string &resName)
bool	is_known_base (const std::string &resName)

Protected Member Functions
virtual compound *	create (const std::string &id)

Protected Attributes
std::shared_timed_mutex	mMutex
std::vector< compound * >	m_compounds
std::set< std::string >	m_known_peptides
std::set< std::string >	m_known_bases
std::set< std::string >	m_missing
std::shared_ptr< compound_factory_impl >	m_next

Detailed Description

Definition at line 290 of file compound.cpp.

Constructor & Destructor Documentation

compound_factory_impl() [1/2]

cif::compound_factory_impl::compound_factory_impl

(

std::shared_ptr< compound_factory_impl >

next

)

Definition at line 378 of file compound.cpp.

    : m_next(next)
{
    for (const auto &[key, value] : compound_factory::kAAMap)
        m_known_peptides.insert(key);

    for (const auto &[key, value] : compound_factory::kBaseMap)
        m_known_bases.insert(key);
}

compound_factory_impl() [2/2]

cif::compound_factory_impl::compound_factory_impl	(	const fs::path &	file,
		std::shared_ptr< compound_factory_impl >	next
	)

Definition at line 388 of file compound.cpp.

    : m_next(next)
{
    cif::file cifFile(file);

    if (cifFile.contains("comp_list")) // So this is a CCP4 restraints file, special handling
    {
        auto &compList = cifFile["comp_list"];
        auto &chemComp = compList["chem_comp"];

        for (const auto &[id, name, group] : chemComp.rows<std::string, std::string, std::string>("id", "name", "group"))
        {
            std::string type;

            // known groups are (counted from ccp4 monomer dictionary)

            //  D-pyranose
            //  DNA
            //  L-PEPTIDE LINKING
            //  L-SACCHARIDE
            //  L-peptide
            //  L-pyranose
            //  M-peptide
            //  NON-POLYMER
            //  P-peptide
            //  RNA
            //  furanose
            //  non-polymer
            //  non_polymer
            //  peptide
            //  pyranose
            //  saccharide

            if (cif::iequals(id, "gly"))
                type = "peptide linking";
            else if (cif::iequals(group, "l-peptide") or cif::iequals(group, "L-peptide linking") or cif::iequals(group, "peptide") or cif::iequals(group, "p-peptide"))
                type = "L-peptide linking";
            else if (cif::iequals(group, "DNA"))
                type = "DNA linking";
            else if (cif::iequals(group, "RNA"))
                type = "RNA linking";
            else
                type = "non-polymer";

            auto &db = cifFile["comp_" + id];

            m_compounds.push_back(new compound(db, id, name, type, group));
        }
    }
    else
    {
        // A CCD components file, validate it first
        try
        {
            cifFile.load_dictionary("mmcif_pdbx.dic");

            if (not cifFile.is_valid())
            {
                std::cerr << "The components file " << file << " is not valid" << std::endl;
                if (cif::VERBOSE < 1)
                    std::cerr << "(use --verbose to see why)" << std::endl;
            }
        }
        catch (const std::exception &e)
        {
            std::cerr << "When trying to load the components file " << file << " there was an exception:" << std::endl
                      << e.what() << std::endl;
        }

        for (auto &db : cifFile)
            m_compounds.push_back(new compound(db));
    }
}

~compound_factory_impl()

virtual cif::compound_factory_impl::~compound_factory_impl ( )

inlinevirtual

Definition at line 297 of file compound.cpp.

    {
        for (auto c : m_compounds)
            delete c;
    }

Member Function Documentation

create()

virtual compound* cif::compound_factory_impl::create ( const std::string &  id )

inlineprotectedvirtual

Reimplemented in cif::CCP4_compound_factory_impl, and cif::CCD_compound_factory_impl.

Definition at line 361 of file compound.cpp.

    {
        // For the base class we assume every compound is preloaded
        return nullptr;
    }

get()

compound* cif::compound_factory_impl::get ( std::string  id )

inline

Definition at line 303 of file compound.cpp.

    {
        cif::to_upper(id);

        std::shared_lock lock(mMutex);

        compound *result = nullptr;

        // walk the list, see if any of us has the compound already
        for (auto impl = shared_from_this(); impl; impl = impl->m_next)
        {
            for (auto cmp : impl->m_compounds)
            {
                if (cmp->id() == id)
                {
                    result = cmp;
                    break;
                }
            }

            if (result)
                break;
        }

        if (result == nullptr and m_missing.count(id) == 0)
        {
            for (auto impl = shared_from_this(); impl; impl = impl->m_next)
            {
                result = impl->create(id);
                if (result != nullptr)
                    break;
            }

            if (result == nullptr)
                m_missing.insert(id);
        }

        return result;
    }

is_known_base()

bool cif::compound_factory_impl::is_known_base ( const std::string &  resName )

inline

Definition at line 354 of file compound.cpp.

    {
        return m_known_bases.count(resName) or
               (m_next and m_next->is_known_base(resName));
    }

is_known_peptide()

bool cif::compound_factory_impl::is_known_peptide ( const std::string &  resName )

inline

Definition at line 348 of file compound.cpp.

    {
        return m_known_peptides.count(resName) or
               (m_next and m_next->is_known_peptide(resName));
    }

next()

std::shared_ptr<compound_factory_impl> cif::compound_factory_impl::next ( ) const

inline

Definition at line 343 of file compound.cpp.

    {
        return m_next;
    }

Member Data Documentation

m_compounds

std::vector<compound *> cif::compound_factory_impl::m_compounds

protected

Definition at line 369 of file compound.cpp.

m_known_bases

std::set<std::string> cif::compound_factory_impl::m_known_bases

protected

Definition at line 371 of file compound.cpp.

m_known_peptides

std::set<std::string> cif::compound_factory_impl::m_known_peptides

protected

Definition at line 370 of file compound.cpp.

m_missing

std::set<std::string> cif::compound_factory_impl::m_missing

protected

Definition at line 372 of file compound.cpp.

m_next

std::shared_ptr<compound_factory_impl> cif::compound_factory_impl::m_next

protected

Definition at line 373 of file compound.cpp.

mMutex

std::shared_timed_mutex cif::compound_factory_impl::mMutex

protected

Definition at line 367 of file compound.cpp.

---

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

• libcifpp/src/compound.cpp