gclib/gclib/LayoutParser.h

#ifndef LayoutParser_H
#define LayoutParser_H

#include "GBase.h"
#include "GList.hh"
#include "GHash.hh"
#include <stdio.h>
//hash data associated with a contig/sequence name
//a contig name key is always stored as its name plus .<length>

class LytCtgData;

struct LytSeqInterSeg {
 int  segEnd, segRClip;
 int  nextStart, nextLClip;
 char segRSplice, nextLSplice;
 int nextSegSeq;
 LytSeqInterSeg(int end, int nextstart, int rclip=0, int nextlclip=0,
                                         char segrsplice=0, char nextlsplice=0, int seqpos=0) {
  segEnd=end; segRClip=rclip;
  nextStart=nextstart; nextLClip=nextlclip;
  segRSplice=segrsplice;
  nextLSplice=nextlsplice;
  nextSegSeq=seqpos;
  }
 int length() {
  return (nextStart-segEnd-1);
  }
};

class LytSeqInfo { //info for a sequence within the file
   int xlen; //total sequence length (with all the added * within contig)
   int interseglen;
  public:
   char *name;
   LytCtgData* contig; //contig data containing this sequence, as above
   bool segmented;
   int numisegs; // number of intersegs[]
   LytSeqInterSeg* intersegs;
   off_t fpos; //file position for the sequence data
   unsigned char reversed;
   int offs; //offset in contig (of the very left end)
   int left,right; //clear range (relative to sequence itself, max 1..xlen)
   LytSeqInfo(char* seqid, LytCtgData* ctg, int pos=0, unsigned char minus=0,
                          int slen=0, int clpL=0, int clpR=0) {
         contig=ctg;
         offs=pos;
         reversed=minus;
         fpos=0;
         interseglen=0;
         xlen=slen;
         left=clpL+1; //1 if no clpL given
         right=xlen-clpR; //0 if no len given
         segmented=false;
         numisegs=0;
         name=Gstrdup(seqid);
         intersegs=NULL;
         }
   ~LytSeqInfo() {
         GFREE(name);
         GFREE(intersegs);
         }
   bool hasIntrons() { return (numisegs>0); }
   void addInterSeg(int end, int nextstart, int rclip=0, int nextlclip=0,
                                          char splice=0, char nextsplice=0, int seqofs=0) {
      GREALLOC(intersegs,(numisegs+1)*sizeof(LytSeqInterSeg));
      interseglen+=nextstart-end-1;
      intersegs[numisegs].segEnd=end; intersegs[numisegs].segRClip=rclip;
      intersegs[numisegs].nextStart=nextstart; intersegs[numisegs].nextLClip=nextlclip;
      intersegs[numisegs].segRSplice=splice;
      intersegs[numisegs].nextLSplice=nextsplice;
      intersegs[numisegs].nextSegSeq=seqofs;
      numisegs++;
      }

   void setLength(int len) {
         //should only be called BEFORE setting the real clipping coordinates
         //(left,right)
         xlen=len;
         left=1;
         right=xlen;
         }
   int length() { return xlen; } //xtended span, including introns
   int seglen() { return xlen-interseglen; } //segments only, no introns
   bool operator==(const LytSeqInfo& s)  {
          return (offs+left-1==s.offs+s.left-1);
         }
   bool operator>(const LytSeqInfo& s)  {
      return (offs+left-1>s.offs+s.left-1);
     }
   bool operator<(const LytSeqInfo& s)  {
      return (offs+left-1<s.offs+s.left-1);
     }
  char* expandGaps(char* s);
  };


class LytCtgData {
   public:
    char* name; //contig name, as stored in file
    unsigned int len; //contig length (lsequence, from ACE file)
    int lpos, rpos;
    int numseqs;
    int offs; //some other type of user data that might be of use
    off_t fpos; //position in file for this contig's entry
    GList<LytSeqInfo> seqs;
    LytCtgData(off_t pos=0):seqs(false,false,false) {
      name=NULL;
      offs=0;
      len=0;
      numseqs=0;
      fpos=pos;
      }
    ~LytCtgData() {
      GFREE(name);
      seqs.Clear();
      }

   char* readName(char* s, GHash<int>& names);

   bool operator==(const LytCtgData& s)  {
      return (strcmp(name,s.name)==0);
     }
   bool operator>(const LytCtgData& s)  {
      return (strcmp(name,s.name)>0);
     }
   bool operator<(const LytCtgData& s)  {
      return (strcmp(name,s.name)<0);
     }
 };
//callback -- called after a read or contig sequence is loaded
typedef bool fnLytSeq(int ctgno, LytCtgData* d, LytSeqInfo* s, char* seq);

class LayoutParser {
 protected:
  FILE* f; //file stream
  off_t f_pos;
  char* fname;
  LytCtgData* currentContig; // currently loaded contig -- for browsing/loading
  int numContigs; //total number of contigs found in this file
  //int numSeqs; //total number of (distinct) sequences found in this file
  GHash<LytSeqInfo> seqinfo; //sequence locations in the file
  GHash<int> ctgIDs; //contig IDs, to make them unique!

  GList<LytCtgData> contigs; //list of contig names with their size,
                       //number of sequences and filepos
 protected:
  GLineReader* linebuf; //the line buffer
  off_t fskipTo(const char* linestart, const char* butnot=NULL);
  bool startsWith(const char* s, const char* start, int tlen);
  virtual LytSeqInfo* addSeq(char* s, LytCtgData* ctg);
  int seek(off_t offset) {
      int r=fseeko(f, offset, SEEK_SET);
      if (r==0) f_pos=offset;
      return r;
      }

 public:
  LayoutParser(const char* filename):contigs(false,true) {
   f=NULL;
   f_pos=0;
   numContigs=0;
   currentContig=NULL;
   if (filename==NULL) {
      f=stdin;
      fname=Gstrdup("stdin");
      }
    else
      fname=Gstrdup(filename);
   linebuf=new GLineReader();
   }
  virtual ~LayoutParser() {
    ctgIDs.Clear();
    GFREE(fname);
    delete linebuf;
    close();
    numContigs=0;
    seqinfo.Clear();
    contigs.Clear();
    }
  virtual bool open();
  void close();
  virtual bool parse(fnLytSeq* seqfn=NULL); //load all the file offsets
  virtual bool parseContigs(); //load all the file offsets for contigs
  virtual bool loadContig(int ctgidx, fnLytSeq* seqfn=NULL, bool re_pos=true); //for loading by browsing
  //if parsefn is not NULL, it is executed, passing the sequence data(first time, with the contig sequence)
  //if parserfn returns true, the data is freed after it is processed
  virtual char getFileType() { return 'L'; }
  //sequence loading - only by request
  LytCtgData* getContig(int idx) { return contigs[idx]; }
  virtual char* getSeq(LytSeqInfo* sqinfo) { return NULL; }
  virtual char* getContigSeq(LytCtgData* ctgdata) { return NULL; }
  int getNumContigs() { return numContigs; }
  //int getNumSeqs() { return numSeqs; }
  off_t getFilePos() { return f_pos; }
  //sorting the list of contigs:
  void contigsByName();
  void contigsByLen();
  void contigsByNumSeqs();
};

#endif
Revision:	16
Committed:	Mon Jul 18 20:56:02 2011 UTC (13 years, 1 month ago) by gpertea
File size:	6233 byte(s)
Log Message:	sync with local source
Line	User	Rev	File contents
1	gpertea	16	#ifndef LayoutParser_H
2			#define LayoutParser_H
3
4			#include "GBase.h"
5			#include "GList.hh"
6			#include "GHash.hh"
7			#include <stdio.h>
8			//hash data associated with a contig/sequence name
9			//a contig name key is always stored as its name plus .<length>
10
11			class LytCtgData;
12
13			struct LytSeqInterSeg {
14			int segEnd, segRClip;
15			int nextStart, nextLClip;
16			char segRSplice, nextLSplice;
17			int nextSegSeq;
18			LytSeqInterSeg(int end, int nextstart, int rclip=0, int nextlclip=0,
19			char segrsplice=0, char nextlsplice=0, int seqpos=0) {
20			segEnd=end; segRClip=rclip;
21			nextStart=nextstart; nextLClip=nextlclip;
22			segRSplice=segrsplice;
23			nextLSplice=nextlsplice;
24			nextSegSeq=seqpos;
25			}
26			int length() {
27			return (nextStart-segEnd-1);
28			}
29			};
30
31			class LytSeqInfo { //info for a sequence within the file
32			int xlen; //total sequence length (with all the added * within contig)
33			int interseglen;
34			public:
35			char *name;
36			LytCtgData* contig; //contig data containing this sequence, as above
37			bool segmented;
38			int numisegs; // number of intersegs[]
39			LytSeqInterSeg* intersegs;
40			off_t fpos; //file position for the sequence data
41			unsigned char reversed;
42			int offs; //offset in contig (of the very left end)
43			int left,right; //clear range (relative to sequence itself, max 1..xlen)
44			LytSeqInfo(char* seqid, LytCtgData* ctg, int pos=0, unsigned char minus=0,
45			int slen=0, int clpL=0, int clpR=0) {
46			contig=ctg;
47			offs=pos;
48			reversed=minus;
49			fpos=0;
50			interseglen=0;
51			xlen=slen;
52			left=clpL+1; //1 if no clpL given
53			right=xlen-clpR; //0 if no len given
54			segmented=false;
55			numisegs=0;
56			name=Gstrdup(seqid);
57			intersegs=NULL;
58			}
59			~LytSeqInfo() {
60			GFREE(name);
61			GFREE(intersegs);
62			}
63			bool hasIntrons() { return (numisegs>0); }
64			void addInterSeg(int end, int nextstart, int rclip=0, int nextlclip=0,
65			char splice=0, char nextsplice=0, int seqofs=0) {
66			GREALLOC(intersegs,(numisegs+1)*sizeof(LytSeqInterSeg));
67			interseglen+=nextstart-end-1;
68			intersegs[numisegs].segEnd=end; intersegs[numisegs].segRClip=rclip;
69			intersegs[numisegs].nextStart=nextstart; intersegs[numisegs].nextLClip=nextlclip;
70			intersegs[numisegs].segRSplice=splice;
71			intersegs[numisegs].nextLSplice=nextsplice;
72			intersegs[numisegs].nextSegSeq=seqofs;
73			numisegs++;
74			}
75
76			void setLength(int len) {
77			//should only be called BEFORE setting the real clipping coordinates
78			//(left,right)
79			xlen=len;
80			left=1;
81			right=xlen;
82			}
83			int length() { return xlen; } //xtended span, including introns
84			int seglen() { return xlen-interseglen; } //segments only, no introns
85			bool operator==(const LytSeqInfo& s) {
86			return (offs+left-1==s.offs+s.left-1);
87			}
88			bool operator>(const LytSeqInfo& s) {
89			return (offs+left-1>s.offs+s.left-1);
90			}
91			bool operator<(const LytSeqInfo& s) {
92			return (offs+left-1<s.offs+s.left-1);
93			}
94			char* expandGaps(char* s);
95			};
96
97
98			class LytCtgData {
99			public:
100			char* name; //contig name, as stored in file
101			unsigned int len; //contig length (lsequence, from ACE file)
102			int lpos, rpos;
103			int numseqs;
104			int offs; //some other type of user data that might be of use
105			off_t fpos; //position in file for this contig's entry
106			GList<LytSeqInfo> seqs;
107			LytCtgData(off_t pos=0):seqs(false,false,false) {
108			name=NULL;
109			offs=0;
110			len=0;
111			numseqs=0;
112			fpos=pos;
113			}
114			~LytCtgData() {
115			GFREE(name);
116			seqs.Clear();
117			}
118
119			char* readName(char* s, GHash<int>& names);
120
121			bool operator==(const LytCtgData& s) {
122			return (strcmp(name,s.name)==0);
123			}
124			bool operator>(const LytCtgData& s) {
125			return (strcmp(name,s.name)>0);
126			}
127			bool operator<(const LytCtgData& s) {
128			return (strcmp(name,s.name)<0);
129			}
130			};
131			//callback -- called after a read or contig sequence is loaded
132			typedef bool fnLytSeq(int ctgno, LytCtgData* d, LytSeqInfo* s, char* seq);
133
134			class LayoutParser {
135			protected:
136			FILE* f; //file stream
137			off_t f_pos;
138			char* fname;
139			LytCtgData* currentContig; // currently loaded contig -- for browsing/loading
140			int numContigs; //total number of contigs found in this file
141			//int numSeqs; //total number of (distinct) sequences found in this file
142			GHash<LytSeqInfo> seqinfo; //sequence locations in the file
143			GHash<int> ctgIDs; //contig IDs, to make them unique!
144
145			GList<LytCtgData> contigs; //list of contig names with their size,
146			//number of sequences and filepos
147			protected:
148			GLineReader* linebuf; //the line buffer
149			off_t fskipTo(const char* linestart, const char* butnot=NULL);
150			bool startsWith(const char* s, const char* start, int tlen);
151			virtual LytSeqInfo* addSeq(char* s, LytCtgData* ctg);
152			int seek(off_t offset) {
153			int r=fseeko(f, offset, SEEK_SET);
154			if (r==0) f_pos=offset;
155			return r;
156			}
157
158			public:
159			LayoutParser(const char* filename):contigs(false,true) {
160			f=NULL;
161			f_pos=0;
162			numContigs=0;
163			currentContig=NULL;
164			if (filename==NULL) {
165			f=stdin;
166			fname=Gstrdup("stdin");
167			}
168			else
169			fname=Gstrdup(filename);
170			linebuf=new GLineReader();
171			}
172			virtual ~LayoutParser() {
173			ctgIDs.Clear();
174			GFREE(fname);
175			delete linebuf;
176			close();
177			numContigs=0;
178			seqinfo.Clear();
179			contigs.Clear();
180			}
181			virtual bool open();
182			void close();
183			virtual bool parse(fnLytSeq* seqfn=NULL); //load all the file offsets
184			virtual bool parseContigs(); //load all the file offsets for contigs
185			virtual bool loadContig(int ctgidx, fnLytSeq* seqfn=NULL, bool re_pos=true); //for loading by browsing
186			//if parsefn is not NULL, it is executed, passing the sequence data(first time, with the contig sequence)
187			//if parserfn returns true, the data is freed after it is processed
188			virtual char getFileType() { return 'L'; }
189			//sequence loading - only by request
190			LytCtgData* getContig(int idx) { return contigs[idx]; }
191			virtual char* getSeq(LytSeqInfo* sqinfo) { return NULL; }
192			virtual char* getContigSeq(LytCtgData* ctgdata) { return NULL; }
193			int getNumContigs() { return numContigs; }
194			//int getNumSeqs() { return numSeqs; }
195			off_t getFilePos() { return f_pos; }
196			//sorting the list of contigs:
197			void contigsByName();
198			void contigsByLen();
199			void contigsByNumSeqs();
200			};
201
202			#endif