ms_taxonomyrules.hpp

/*
##############################################################################
# file: ms_taxonomyrules.hpp                                                 #
# 'msparser' toolkit                                                         #
# Encapsulates "mascot.dat"-file that describes most important parameters    #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2003 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Archive:: /Mowse/ms_mascotresfile/include/ms_taxonomyrules.hpp       $ #
#     $Author: francoisr@matrixscience.com $ #
#       $Date: 2022-01-12 12:34:37 +0000 $ #
#   $Revision: b158d77079a10225ce667f6e66a6df8412823ac0 | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $ #
# $NoKeywords::                                                            $ #
##############################################################################
*/
 
#ifndef MS_TAXONOMYRULES_HPP
#define MS_TAXONOMYRULES_HPP
 
 
#include <string>
#include <vector>
 
 
namespace matrix_science {
    enum TAX_SPECIES_FORMAT
    {
        TAX_SPECIES_NCBI,         
        TAX_SPECIES_SWISSPROT,    
        TAX_SPECIES_PDB,          
        TAX_SPECIES_GI2TAXID,     
        TAX_SPECIES_ACC2TAXID,    
        TAX_SPECIES_EXPLICIT,     
        TAX_SPECIES_FORMAT_COUNT        /* Always leave this one last */
    };
 
    class MS_MASCOTRESFILE_API ms_taxspeciesfiles
    {
        friend class ms_datfile;
        friend class ms_taxonomyrules;
 
    public:
        ms_taxspeciesfiles();
 
        ms_taxspeciesfiles(const ms_taxspeciesfiles& src);
 
        ~ms_taxspeciesfiles();
 
        void defaultValues();
 
        void copyFrom(const ms_taxspeciesfiles* right);
 
#ifndef SWIG
        ms_taxspeciesfiles& operator=(const ms_taxspeciesfiles& right);
#endif
        TAX_SPECIES_FORMAT getFormat() const;
 
        void setFormat(const TAX_SPECIES_FORMAT value);
 
        std::string getFileName() const;
 
        void setFileName(const char* name);
 
    private:
        TAX_SPECIES_FORMAT  format_;
        std::string         filename_;
 
        std::string getStringValue() const;
    }; // class ms_taxspeciesfiles
 
    enum TAX_NODE_FORMAT
    {
        TAX_NODE_NCBI,     
        TAX_NODE_GENCODE   
    };
 
 
    class MS_MASCOTRESFILE_API ms_taxnodesfiles
    {
        friend class ms_datfile;
        friend class ms_taxonomyrules;
    public:
 
        ms_taxnodesfiles();
 
        ms_taxnodesfiles(const ms_taxnodesfiles& src);
 
        ~ms_taxnodesfiles();
 
        void defaultValues();
 
        void copyFrom(const ms_taxnodesfiles* right);
 
#ifndef SWIG
        ms_taxnodesfiles& operator=(const ms_taxnodesfiles& right);
#endif
        TAX_NODE_FORMAT getFormat() const;
 
        void setFormat(const TAX_NODE_FORMAT value);
 
        std::string getFileName() const;
 
        void setFileName(const char* name);
 
    private:
        TAX_NODE_FORMAT format_;
        std::string     filename_;
        std::string getStringValue() const;
    }; // class ms_taxnodesfiles
 
    class MS_MASCOTRESFILE_API ms_parserule_plus
    {
        friend class ms_datfile;
        friend class ms_taxonomyrules;
 
    public:
 
        enum TAX_CHOP_TYPES
        {
            TAX_CHOP_PREFIX = 0x0001, 
            TAX_CHOP_SUFFIX = 0x0002, 
            TAX_CHOP_WORDS  = 0x0004  
        };
 
        typedef unsigned int TAX_CHOP_SRC;
 
        ms_parserule_plus();
 
        ms_parserule_plus(const ms_parserule_plus& src);
 
        ~ms_parserule_plus();
 
        void defaultValues();
 
        void copyFrom(const ms_parserule_plus* right);
 
#ifndef SWIG
        ms_parserule_plus& operator=(const ms_parserule_plus& right);
#endif
        TAX_SPECIES_FORMAT getFileTypeToSearch() const;
 
        void setFileTypeToSearch(const TAX_SPECIES_FORMAT value);
 
        const ms_parserule* getRule() const;
 
        void setRule(const ms_parserule* src);
 
        TAX_CHOP_SRC getChopSource() const;
 
        void setChopSource(const TAX_CHOP_SRC value);
 
        std::string getNameOfDB() const;
 
        void setNameOfDB(const char* name);
 
    private:
        TAX_SPECIES_FORMAT  fileTypeToSearch_;
        ms_parserule        rule_;
        TAX_CHOP_SRC        chopSrc_;
        std::string         nameOfDb_;
        std::string getStringValue() const;
    }; // ms_parserule_plus
 
 
    class MS_MASCOTRESFILE_API ms_taxonomyrules: public ms_customproperty
    {
        friend class ms_datfile;
 
    public:
        ms_taxonomyrules();
 
        ms_taxonomyrules(const ms_taxonomyrules& src);
 
        ~ms_taxonomyrules();
 
        void defaultValues();
 
        void copyFrom(const ms_taxonomyrules* right);
 
#ifndef SWIG
        ms_taxonomyrules& operator=(const ms_taxonomyrules& right);
#endif
        bool isSectionAvailable() const;
 
        void setSectionAvailable(const bool value);
 
        bool isEnabled() const;
 
        void setEnabled(const bool flag);
 
        std::string getIdentifier() const;
 
        void setIdentifier(const char* str);
 
        int getErrorLevel() const;
 
        void setErrorLevel(const int value);
 
        bool isFromRefFile() const;
 
        void setFromRefFile(const bool flag);
 
        bool isConcatRefFileLines() const;
 
        void setConcatRefFileLines(const bool flag);
 
        char getDescriptionLineSep() const;
 
        void setDescriptionLineSep(const char value);
 
        int getNumberOfNoBreakDescLineIf() const;
 
        std::string getNoBreakDescLineIf(const int index) const;
 
        void clearNoBreakDescLineIf();
 
        void appendNoBreakDescLineIf(const char* str);
 
        int getNumberOfSpeciesFiles() const;
 
        const ms_taxspeciesfiles * getSpeciesFile(const int index) const;
 
        void clearSpeciesFiles();
 
        void appendSpeciesFile(const ms_taxspeciesfiles * item);
 
        // no longer in use
        int getNumberOfStrFiles() const;
        // no longer in use
        const ms_taxspeciesfiles * getStrFile(const int index) const;
        // no longer in use
        void clearStrFiles();
        // no longer in use
        void appendStrFile(const ms_taxspeciesfiles * item);
 
        // no longer in use
        const ms_parserule_plus* getStrRule() const;
        // no longer in use
        void setStrRule(const ms_parserule_plus* src);
 
        int getNumberOfNodesFiles() const;
 
        const ms_taxnodesfiles * getNodesFile(const int index) const;
 
        void clearNodesFiles();
 
        void appendNodesFile(const ms_taxnodesfiles * item);
 
        int getNumberOfGencodeFiles() const;
 
        const ms_taxnodesfiles * getGencodeFile(const int index) const;
 
        void clearGencodeFiles();
 
        void appendGencodeFile(const ms_taxnodesfiles * item);
 
        const ms_parserule_plus* getDefaultRule() const;
 
        void setDefaultRule(const ms_parserule_plus* src);
 
        int getNumberOfPrefixRemoves() const;
 
        std::string getPrefixRemove(const int index) const;
 
        void clearPrefixRemoves();
 
        void appendPrefixRemove(const char * item);
 
        int getNumberOfSuffixRemoves() const;
 
        std::string getSuffixRemove(const int index) const;
 
        void clearSuffixRemoves();
 
        void appendSuffixRemove(const char * item);
 
        const ms_parserule* getSrcDatabaseRule() const;
 
        void setSrcDatabaseRule(const ms_parserule* src);
 
        int getNumberOfPerDbSrcRules() const;
 
        const ms_parserule_plus * getPerDbSrcRule(const int index) const;
 
        void clearPerDbSrcRules();
 
        void appendPerDbSrcRule(const ms_parserule_plus * item);
 
        const ms_parserule* getDoThisRuleFirst() const;
 
        void setDoThisRuleFirst(const ms_parserule* src);
 
        const ms_parserule* getAccFromSpeciesLine() const;
 
        void setAccFromSpeciesLine(const ms_parserule* src);
 
        std::string getQuickRefSearch() const;
 
        void setQuickRefSearch(const char* str);
 
        int getDBLevelTaxId() const;
 
        void setDBLevelTaxId(const int value);
 
        bool isDBLevelTaxId() const;
 
        void clearDBLevelTaxId();
 
        bool isMitochondrialTranslation() const;
 
        void setMitochondrialTranslation(const bool flag);
 
        std::string getSpeciesFormatRegex(const TAX_SPECIES_FORMAT format) const;
 
        void setSpeciesFormatRegex(const TAX_SPECIES_FORMAT format, const std::string regex);
 
#ifdef SUPPRESS_MS_CUSTOMPROPERTY_INHERITANCE
#include "suppress_ms_customproperty.hpp"
#endif
 
    private:
        bool                sectionAvailable_;
        bool                enabled_;
        std::string         identifier_;
        int                 errorLevel_;
        bool                fromRefFile_;
        bool                concatRefFileLines_;
        char                descriptionLineSep_;
 
        std::vector< std::string > noBreakDescLineIf_;
        std::vector< ms_taxspeciesfiles* > speciesFiles_;
        std::vector< ms_taxspeciesfiles* > strStrFiles_;
        std::vector< ms_taxnodesfiles* > nodesFiles_;
        std::vector< ms_taxnodesfiles* > gencodeFiles_;
        std::vector< ms_parserule_plus* > perDbSrcRules_;
        std::vector< std::string > prefixRemoves_;
        std::vector< std::string > suffixRemoves_;
        std::vector< std::string > speciesFormatRegex_;
 
        ms_parserule        srcDatabaseRule_;
        ms_parserule        doThisRuleFirst_;
        ms_parserule        accFromSpeciesLine_;
        ms_parserule_plus   defaultRule_;
        ms_parserule_plus   strStrRule_;
 
        std::string         quickRefSearch_;
        int                 dbLevelTaxId_;
        bool                mitochondrialTranslation_;
    }; // class ms_taxonomyrules
 
    class ms_tinycdb;
    class ms_taxonomychoice;
 
 
    class MS_MASCOTRESFILE_API ms_taxonomytree : public ms_errors
    {
    public:
        ms_taxonomytree(const ms_taxonomyrules * taxonomyRules, 
                        const char * taxonomyDirectory = "../taxonomy",
                        const bool useIndex = true,
                        const bool createList = false,
                        const char * preparingDirectory = "../taxonomy/preparing",
                        const char * oldDirectory = "../taxonomy/old");
 
        ms_taxonomytree(const ms_taxonomytree & src);
        
        ~ms_taxonomytree();
 
        void copyFrom(const ms_taxonomytree * right);
 
#ifndef SWIG
        ms_taxonomytree& operator=(const ms_taxonomytree & right);
 
        struct TAX_TREE_NODE {
            int parentId;
            int tableId;
        };
        typedef std::vector<TAX_TREE_NODE> TAX_TREE_NODES;
 
        TAX_TREE_NODES * getTaxIDArray();
#endif
 
        bool usingIndex() const; 
        
        std::string getTaxonomyAndIndexFiles() const;
 
        bool isSpeciesDescendantOf(const int parentID, const int id) const;
 
#ifndef SWIG
        bool getParent(const int id, int & ttParent, int & ttGenTable) const;
#else // SWIG Multiple return values
        bool getParent(const int id, int & OUTPUT, int & OUTPUT) const;
#endif
 
        bool isIncludedIn(const int id, const ms_taxonomychoice * choice) const;
 
    private:
        bool usingCDB_;
        std::vector<ms_taxnodesfiles> files_;
        TAX_TREE_NODES nodes_;
        std::vector<std::string> fileNames_;
        std::vector<ms_tinycdb *> cdbFiles_;
 
        bool readFile(const std::string & filename,
                      const bool isMitochondrialTranslation);
 
    };
 
 // end of config_group
} // namespace matrix_science
 
#endif // MS_TAXONOMYRULES_HPP
 
/*------------------------------- End of File -------------------------------*/