cadbc.h

Go to the documentation of this file.

#ifndef CADBC_H
#define CADBC_H

// system specific C library
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
//#include <openssl/md5.h>

//#include <string.h>
#include <string>   // in GCC-3.2 you should not use *.h for system headers
#include <cstdio>
//#include <iostream.h>
#include <iostream>
#include <cstdlib>
#include <string>
#include "Aceobj.h"

//#include "seqrslt.h"
/* after the first hand shake, the Server sends in a header first then
 * it sends the body.  You needs to get the body after the header with
 * more recv commands.  
 * */

using namespace std;

class AceException {
        public:
                AceException() : err() { }
                AceException(const string &er) : err(er) { }
                AceException(const char er[]) : err(er) { }
                friend ostream& operator<<(ostream &ous, const AceException &ae) { 
                        ous << "AceException:\n" << ae.err; return ous; }
                const string& getMessage() const { return err; }

        private:
                string err;
};
class AQLException : public AceException {
        public:
                AQLException() : AceException() {}
                AQLException(const string &er) : AceException(er) {}
                friend ostream& operator<<(ostream &ous, const AQLException &e) {
                        ous << "AQLException:\n" << e.getMessage(); return ous; }
};
class DNANotFound : public AceException { 
        public:
                DNANotFound() : AceException() {}
                DNANotFound(const string &er) : AceException(er) {}

};
class pepNotFound : public AceException {
        public:
                pepNotFound() : AceException() {}
                pepNotFound(const string &er) : AceException(er) {}
                pepNotFound(const char er[]) : AceException(er) {}
};

class cadbc 
{
        public:
                friend class Result;
                //friend class seqrslt;
                // no copy constructor, no assignment operator
                // these should all be made private
                // because a problem on my computer in resolving host names
                // I have to use IP addresses not host names
                // I can use 127.0.0.1 but not localhost for hostname
                // It worked with certain database but not all. Don't know why?

                cadbc(const string &host, int port, int rcvbfsz=100000);
                ~cadbc() { delete[] msg; shutdown(sock,2); }

                void login(const char user[], const char passwd[]);

                /* Get the fasta formated peptide sequence 
                 * >seqname
                 * PEPSEQFLLW
                 *
                 * The server returns this format by default.  It is less
                 * work to use this format.
                 * This method is formated to get even very long sequences.
                 * Should not depends on query method.
                 * This methods is used by tabaln
                 * should use getPeptideFasta
                 * This method deprecated
                 * */
                //const char* getFasPep(const char pepName[]) throw(pepNotFound) { getPeptideFasta(pepName); return result.c_str(); }
                //const char* getFasPep(const string &pn) {

                //      return getFasPep(pn.c_str());}

                // returns a copy of the peptide
                //string& getPeptideFasta(const char pepName[]) throw(pepNotFound);
                //string& getPeptideFasta(const string &pepName) throw(pepNotFound);
                
                const char* getPeptideFasta(const string &pepName) throw(pepNotFound);
                //string& getPeptideString(const char pepName[]) throw(pepNotFound);
                const char* getPeptideString(const string &pepName) throw(pepNotFound);

                /* The unformated pep string with white space removed 
                 * This methods used the getFasPep method.  Then it removes the
                 * \n character.  It does more work.
                 * */
                //void getPep(char* &pepStr, int &bfsz, const char pepName[]) throw(pepNotFound);
                // getPep() has been removed, all programs depends on this needs to be re-written

                //string& getDNAFasta(const string& seqname) throw(DNANotFound);
                //string& getDNAString(const string& seqname) throw(DNANotFound);
                const char* getDNAFasta(const string& seqname) throw(DNANotFound);
                const char* getDNAString(const string& seqname) throw(DNANotFound);

                const char* fas2str(); 
                Aceobj* fetch(const string &objType, const string &objName) throw(AceException);
                void aql(const string &query) throw(AQLException);
                int fields() const { return columns.size(); }
                string fieldName(int i) const { return columns[i]; }
                // field data type is a more correct name
                string fieldType(int i) const { return columns[i]; }

                bool next();
                string getvalue(int i) { return currRow[i]; }

                /* potential problem: if a query generate a large result 
                 * the server may send the first segment.  The caller needs to 
                 * check the message type to decide to receive the next message
                 * */
                char* query(const string q) { return query(q.c_str()); }
                char* query(const char q[]) { send_msg("ACESERV_MSGREQ",q); receive(); return getBody(); }

                /* returns the pointer to the message. 
                 * For efficiency (no need to copy result), we can modify this
                 * pointer.
                 * This is supposed to be the low level method.
                 * It does not consult msglen, if truncating from the end, needs to
                 * set the char to \0
                 * */
                char *getBody() const { return msg+HEADER_LEN; }
                int getBodyLength() const { return msglen-HEADER_LEN; }

                /* The old message will be overwritten, you need to copy the old
                 * message to save them
                 * */
                char *getNext() { send_msg("ACESERV_MSGENCORE", "encore"); receive(); return getBody(); }

                /* return the number of bytes sent including the 50 byte header
                 * */
                int send_msg(const char msgType[], const char body[], int body_len);
                int send_msg(const char msgType[], const char body[]) {
                        return send_msg(msgType,body,strlen(body)+1); }
                int send_msg(const char msgType[], const string &body) {
                        return send_msg(msgType,body.c_str(),body.length()+1); }

                int receive();

                /*helper functions */
                /* Depending on the calling context, it could be the size of the
                 * out going or the incoming message
                 * */
                int getMaxBytes() const { return *((int*)(msg+16)); }
                int getMsgLen() const { return *((int*)(msg+4)); }
                void setMsgLen(int l) { *((int*)(msg+4))=l; }
                const char* getMsgType() const { return msg+20; } 
                void setMsgType(const char mt[]) { 
                        if (strlen(mt)>29) { cerr << "msg type longer than 29\n"; exit(1); }
                        strcpy(msg+20, mt); }
                int getSockbufSize();
                void setSockbufSize(int sz);

                void show(); // for debug 

                static const int HEADER_LEN=50;
                //MESSAGE TYPE, for short cut
                static const char *OK, *REQ, *FAIL, *DATA, *ENCORE, *KILL;
                //enum messageType { MSGOK, MSGREQ, MSGFAIL, MSGDATA, MSGENCORE, MSGKILL};

        private:
                string& completeQuery(const string &query);

                void showHeader();  // debuging function
                /* msg 
                 * is the buffer to hold both incoming and outgoing messages 
                 * we are assuming
                 * that one object will not be doing both sending and receiving at
                 * the same time
                 * the whole message to be sent usually smaller
                 * No threading assumed here.
                 *
                 * the allocated size of msg is always msgMaxlen+1
                 * */
                char *msg;
                //int msgLen;  // msssage length including the 50 byte header
                int msglen;  // the actual length of msg
                int msgMaxlen;    
                int maxBytes;

                int sock;            // socket file descriptor
                sockaddr_in svaddr;  // server internet address xxx.com

                string result;  
                static const int faswidth = 50; // this the aceserver line width for
                // fasta formated sequences, it may changes in the future

                Aceobj obj;

                vector<string> columns;
                char *aqlResult;
                char *nextRow; // point to the next row
                vector<string> currRow; 
};

#endif