ms_unigene.hpp

/*
##############################################################################
# file: ms_mascotrespeptide.hpp                                              #
# 'msparser' toolkit                                                         #
# Encapsulates a Unigene file (from NCBI)                                    #
#                                                                            #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2003 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Archive:: /Mowse/ms_mascotresfile/include/ms_unigene.hpp             $ #
#     $Author: robertog@matrixscience.com $ #
#       $Date: 2023-08-29 15:05:00 +0100 $ #
#   $Revision: 59a8ab98151c86e0bdeddc2efea60d287d6087ba | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $ #
# $NoKeywords::                                                            $ #
##############################################################################
*/
 
#ifndef MS_MASCOTRESUNIGENE_HPP
#define MS_MASCOTRESUNIGENE_HPP
 
 
// Includes from the standard template library
#include <stdio.h>
#include <string>
#include <vector>
 
 
 
namespace matrix_science {
    class ms_tinycdb;
 
 
    class MS_MASCOTRESFILE_API ms_unigene_entry
    {
        public:
            ms_unigene_entry(FILE * f, ms_unigene & unigene);
 
            ms_unigene_entry(const std::string & id,
                             const std::string & title,
                             const std::string & gene,
                             const std::string & cytoBand,
                             const std::string & locusLink,
                             const std::string & express,
                             const long          chromosome,
                             const int           numAccessions,
                             const OFFSET64_T    fileOffset);
 
            ~ms_unigene_entry();
 
 
            int getNumAccessions() const     { return numAccessions_; }
 
 
            std::string getID() const        { return id_;                }
 
 
            std::string getTitle() const     { return title_;             }
 
 
            std::string getGene() const      { return gene_;              }
 
 
            std::string getCytoBand() const  { return cytoBand_;          }
 
 
            std::string getLocusLink() const { return locuslink_;         }
 
 
            std::string getExpress() const   { return express_;           }
 
 
            long getChromosome() const       { return chromosome_;        }
 
 
            OFFSET64_T getFileOffset() const { return fileOffset_;        }
 
        protected:
            // Not safe to copy or assign this object.
#ifndef SWIG
            ms_unigene_entry(const ms_unigene_entry & rhs);
            ms_unigene_entry & operator=(const ms_unigene_entry & rhs);
#endif
        private:
            bool getString(const char * buf, const char * id,
                           const int idLen,  std::string &res);
 
            bool getLong(const char * buf, const char * id, 
                         const int idLen,  long &res);
 
            bool getAccessions(const char * buf, const char * id, const int idLen,  
                               std::string & giNumber, std::string & accession);
            std::string id_;
            std::string title_;
            std::string gene_;
            std::string cytoBand_;
            std::string locuslink_;
            std::string express_;
            long        chromosome_;
            int         numAccessions_;
            OFFSET64_T  fileOffset_;
    };
 
 
    class MS_MASCOTRESFILE_API ms_unigene
    {
        friend class ms_unigene_entry;
 
        public:
    ms_unigene(const ms_mascotresfilebase&  resfile, const char * filename);
 
    virtual ~ms_unigene() = default;
 
    virtual const ms_unigene_entry * findEntry(const char * id) = 0;
    
    virtual std::string getUnigeneForAccession(const std::string accession, 
                           const int index) = 0;
 
        protected:
            // Not safe to copy or assign this object.
#ifndef SWIG
            ms_unigene(const ms_unigene & rhs);
            ms_unigene & operator=(const ms_unigene & rhs);
#endif
    void addAccessionUnigenePair(const ms_unigene_entry * unigene, 
                     const std::string & accession);
    
    protected:
    const ms_mascotresfilebase&  resfile_;
    std::vector<ms_unigene_entry *> entries_;
    std::string filename_;
    int numAccessions_;
    typedef std::multimap<std::string, const ms_unigene_entry *> unigenesForAcc;
    unigenesForAcc accessionToUnigene_;
    
    };
 
 
  class MS_MASCOTRESFILE_API ms_unigene_dat : public ms_unigene
    {
        friend class ms_unigene_entry;
 
        public:
            ms_unigene_dat(const ms_mascotresfile_dat  &resfile, const char * filename);
 
        virtual ~ms_unigene_dat();
 
            virtual const ms_unigene_entry * findEntry(const char * id);
 
            virtual std::string getUnigeneForAccession(const std::string accession, 
                                               const int index);
 
        protected:
            // Not safe to copy or assign this object.
#ifndef SWIG
            ms_unigene_dat(const ms_unigene_dat & rhs);
            ms_unigene_dat & operator=(const ms_unigene_dat & rhs);
#endif
    private:
 
            ms_tinycdb * pcdb_;
 
    }; // end of resfile_group
}   // matrix_science namespace
 
 
#endif // MS_MASCOTRESUNIGENE_HPP
 
/*------------------------------- End of File -------------------------------*/