ms_datfile.hpp

/*
##############################################################################
# file: ms_datfile.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_datfile.hpp             $ #
#     $Author: robertog@matrixscience.com $ #
#       $Date: 2024-08-27 16:16:41 +0100 $ #
#   $Revision: 5566e3f2f102c2aae2dea328044e0e4030755ddd | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $ #
# $NoKeywords::                                                            $ #
##############################################################################
*/
 
#ifndef MS_DATFILE_HPP
#define MS_DATFILE_HPP
 
 
#include <string>
#include <vector>
 
 
namespace matrix_science {
 
    class ms_filesource;
 
 
    class MS_MASCOTRESFILE_API ms_datfile : public ms_errors
    {
    public:
 
 
        enum WST
        {
            WST_APACHE=0, 
            WST_IIS=1     
        };
 
 
        enum SEQDB_INSTALL
        {
            // Anything in the lower 16 bits (1..16) should result in asking the user to confirm that they want to update
            SEQDB_INSTALL_SHOULD_QUERY_USER = 0x0000FFFF, 
            SEQDB_INSTALL_CUSTOMISED        = 0x00000001, 
            SEQDB_INSTALL_INACTIVE          = 0x00000002, 
            SEQDB_INSTALL_INVALID_CONFIG    = 0x00000004, 
            SEQDB_INSTALL_EXISTING_LARGER   = 0x00000010, 
 
            // Bit 32 for something really bad.
            SEQDB_INSTALL_INVALID_DBNAME    = 0x00000000, 
 
            // Further information that may be useful in bits 16 to 31 
            SEQDB_INSTALL_MUST_UPDATE_CFG   = 0x000F000F, 
            SEQDB_INSTALL_MISSING_CONFIG    = 0x00010000, 
            SEQDB_INSTALL_OLD_RULES         = 0x00020000, 
            SEQDB_INSTALL_WRONG_WILDCARD    = 0x00040000, 
 
            // Additional information, but no need to update 
            SEQDB_INSTALL_CURRENT_RULES     = 0x01000000  
        };
 
 
        enum INST_FLAGS
        {
            IFLG_UPDATETAXONOMY          = 0x00000001,   
            IFLG_UPDATEPARSERULES        = 0x00000002,   
            IFLG_UPDATESWISSPROT         = 0x00000004,   
            IFLG_UPDATECLUSTER           = 0x00000008,   
            IFLG_UPDATEESTTAX            = 0x00000010,   
            IFLG_ADDMISSINGOPTIONS       = 0x00000020,   
            IFLG_ADDREPORTAUTO           = 0x00000040,   
            IFLG_UPDATEAPACHEFORKOPT     = 0x00000080,   
            IFLG_ADDPERCOLATOROPT        = 0x00000100,   
            IFLG_UPDATENCBIHTTPS         = 0x00000200,   
            IFLG_UPDATEPRIDECONTAMINANTS = 0x00000400,   
            IFLG_UPDATEDBMANAGERPERLPATH = 0x00000800,   
            IFLG_UPDATEMSPEPSEARCHOPTS   = 0x00001000,   
            IFLG_UPDATEEXECAFTERSEARCH   = 0x00002000,   
            IFLG_UPDATEPERCOLATORFEATS   = 0x00004000,   
            IFLG_UPDATEPROTFAMILYSWITCH  = 0x00008000,   
            IFLG_UPDATEPERCOLATORUSERT   = 0x00010000,   
            IFLG_UPDATESPLITNUMOFQUERIES = 0x00020000,   
            IFLG_UPDATESPLITDATAFILESIZE = 0x00040000,   
            IFLG_UPDATERESULTSCACHE      = 0x00080000,   //<!Update ResultsCache
 
            IFLG_DEFAULTNEWINSTALL   = IFLG_UPDATECLUSTER       |
                                       IFLG_UPDATEAPACHEFORKOPT, 
            IFLG_DEFAULTUPGRADE      = IFLG_UPDATETAXONOMY      |
                                       IFLG_UPDATEPARSERULES    |
                                       IFLG_UPDATEESTTAX        |
                                       IFLG_ADDMISSINGOPTIONS   |
                                       IFLG_ADDREPORTAUTO       |
                                       IFLG_UPDATEAPACHEFORKOPT |
                                       IFLG_ADDPERCOLATOROPT    |
                                       IFLG_UPDATEPERCOLATORFEATS  |
                                       IFLG_UPDATEPERCOLATORUSERT |
                                       IFLG_UPDATENCBIHTTPS     |
                                       IFLG_UPDATEDBMANAGERPERLPATH | 
                                       IFLG_UPDATEMSPEPSEARCHOPTS  |
                                       IFLG_UPDATEEXECAFTERSEARCH |
                                       IFLG_UPDATERESULTSCACHE  |
                                       IFLG_UPDATESPLITNUMOFQUERIES |
                                       IFLG_UPDATESPLITDATAFILESIZE |
                                       IFLG_UPDATEPROTFAMILYSWITCH 
        };
 
        ms_datfile();
 
        ms_datfile(const ms_datfile& src);
 
        ms_datfile(const char* filename, const int timeoutSec = 0,
                   const matrix_science::ms_connection_settings * cs = 0);
 
        ~ms_datfile();
 
        void defaultValues();
 
        void copyFrom(const ms_datfile* right);
 
#ifndef SWIG
        ms_datfile& operator=(const ms_datfile& right);
#endif
        std::string getFileName() const;
 
        void setFileName(const char* name);
 
        void setConnectionSettings(const matrix_science::ms_connection_settings & cs);
 
        matrix_science::ms_connection_settings getConnectionSettings() const;
 
        void read_file();
 
        void read_buffer(const char * buffer);
 
        void save_file();
 
        bool editedByDatabaseManager() const;
 
        const ms_databases* getDatabases() const;
 
        void setDatabases(const ms_databases* dbs);
 
        const ms_libraryoptions* getLibraryOptions() const;
 
        void setLibraryOptions(const ms_libraryoptions* spectralLibraryOptions);
 
        const ms_parseoptions* getParseOptions() const;
 
        void setParseOptions(const ms_parseoptions* rules);
 
        const ms_wwwoptions* getWWWOptions() const;
 
        void setWWWOptions(const ms_wwwoptions* www);
 
        const ms_processoroptions* getProcessors() const;
 
        void setProcessors(const ms_processoroptions* info);
 
        const ms_taxonomyrules* getTaxonomyRules(const int idx) const;
 
        void setTaxonomyRules(const int idx, const ms_taxonomyrules* rules);
 
        int getMaxTaxonomyRules() const;
 
        const ms_clusterparams* getClusterParams() const;
 
        void setClusterParams(const ms_clusterparams* params);
 
        const ms_unigeneoptions* getUniGeneOptions() const;
 
        void setUniGeneOptions(const ms_unigeneoptions * uoptions);
 
        const ms_mascotoptions* getMascotOptions() const;
 
        void setMascotOptions(const ms_mascotoptions* opt);
 
        const ms_cronoptions* getCronOptions() const;
 
        void setCronOptions(const ms_cronoptions* options);
 
        const ms_mascotfiles* getMascotFiles() const;
 
        void setMascotFiles(const ms_mascotfiles* src);
 
        void setFindFileTimeout(const int seconds);
 
        int getFindFileTimeout() const;
 
        unsigned int checkSeqDBInstallRequest(const std::string & dbName,
                                              const double newFastaSize) const;
 
        bool updateForInstaller(ms_errs    & log,
                                const char         * not_mascot_dat_path, 
                                const char         * mascot_dat_path,
                                const char         * licenseFilePath,
                                const char         * pathToMascot,
                                const char         * mascotURL,
                                const char         * sequenceDatabases,
                                const bool           clusterEnable,
                                const WST            wst,
                                const char         * NTGuestName,
                                const char         * NTAdminName,
                                const unsigned int   flags);
 
        std::string getHeaderComments() const;
 
        void setHeaderComments(const std::string headerComments);
 
    private:
        std::string         filename_;
 
        int                 findFileTimeout_;
 
        ms_databases        Databases;
 
        ms_libraryoptions   libraryOptions;
 
        ms_parseoptions     parseOptions;
 
        ms_wwwoptions       wwwOptions;
 
        ms_processoroptions Processors;
 
        ms_taxonomyrules    **taxonomyRules;
 
        ms_clusterparams    clusterParams;
 
        ms_unigeneoptions   unigeneOptions;
 
        ms_mascotoptions    Options;
 
        ms_cronoptions      cronOptions;
 
        ms_mascotfiles      MascotFiles;
 
        std::string         headerComments_;
        std::string         footerComments_;
 
        ms_connection_settings  cs_;
 
    private:
        void defaultFileName();
 
        void defaultTaxonomyRules();
        void copyTaxonomyRules(const ms_datfile* right);
 
        void get_db_info(ms_filesource *f);
        void save_db_info(void *f);
 
        void get_library_options(ms_filesource *f, const std::string & preceedingComments);
        void save_library_options(void *f);
 
        void get_parse_rules(ms_filesource *f, const std::string & preceedingComments);
        void save_parse_rules(void *f);
 
        void get_www(ms_filesource *f, const std::string & preceedingComments);
        void save_www(void *f);
 
        void get_taxonomy_rules(ms_filesource *f, const char * sectionTitle, const std::string & preceedingComments);
        void save_taxonomy(void *f, const int index);
 
        void get_cluster_params(ms_filesource *f, const std::string & preceedingComments);
        void save_cluster_params(void *f);
 
        void get_unigene_options(ms_filesource *f, const std::string & preceedingComments);
        void save_unigene_options(void *f);
 
        void get_processors(ms_filesource *f, const std::string & preceedingComments);
        void save_processors(void *f);
 
        void get_options(ms_filesource *f, const std::string & preceedingComments);
        void save_options(void *f);
 
        void get_cron_job_list(ms_filesource *f, const std::string & preceedingComments);
        void save_cron_job_list(void *f);
 
        bool get_parse_rule_plus(const char *lineForError, char *pSrc, ms_parserule_plus *pRulePlus);
        void setIamParameter();
        void checkAndCompileParseRules();
        bool parseStringIntoCron(const char *szBuf, ms_cronjob & cron);
 
        int parseIntoArray(const char * szBufCopy, 
                           bool * array, 
                           int minVal, 
                           int maxVal, 
                           int starMeans, 
                           const char * wholeLine);
 
        bool skipToEndOfSection(ms_filesource *f);
        bool getStringExcludingQuotes(const char *line, char *pDst);
        void readToEndOfLine(const char * pSrc, char * pDst, int maximumLength);
        void replaceHashes(matrix_science::ms_customproperty & section,
                           const std::string & localPath,
                           const std::string & hostname,
                           const std::string & url);
 
        void read_filesource(ms_filesource & fsource);
        bool updateForInstallerDatabase(ms_errs               & log, 
                                        const std::string     & dbName, 
                                        const std::string     & defaultWildcard, 
                                        ms_databases          & dbs, 
                                        const ms_databases    * not_dbs,
                                        ms_parseoptions       & thisParse,
                                        const ms_parseoptions * notMascotDatParse);
        void updateForInstaller_ExecAfterSearch(ms_errs & log, matrix_science::ms_mascotoptions & options, const std::string & createPipCompleteString);
    }; // class ms_datfile // end of config_group
} // namespace matrix_science
 
#endif // MS_DATFILE_HPP
 
/*------------------------------- End of File -------------------------------*/