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_2_8_1-0-gea32989045 $ #
# $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 -------------------------------*/