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);
     }
  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);
     }
 };
//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:	144
Committed:	Thu Dec 22 19:15:46 2011 UTC (12 years, 8 months ago) by gpertea
File size:	6053 byte(s)
Log Message:	added GBitVec.h; removed operator> requirement for sorted vectors; swap() is now template Gswap()
Line	File contents
1	#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	char* expandGaps(char* s);
92	};
93
94
95	class LytCtgData {
96	public:
97	char* name; //contig name, as stored in file
98	unsigned int len; //contig length (lsequence, from ACE file)
99	int lpos, rpos;
100	int numseqs;
101	int offs; //some other type of user data that might be of use
102	off_t fpos; //position in file for this contig's entry
103	GList<LytSeqInfo> seqs;
104	LytCtgData(off_t pos=0):seqs(false,false,false) {
105	name=NULL;
106	offs=0;
107	len=0;
108	numseqs=0;
109	fpos=pos;
110	}
111	~LytCtgData() {
112	GFREE(name);
113	seqs.Clear();
114	}
115
116	char* readName(char* s, GHash<int>& names);
117
118	bool operator==(const LytCtgData& s) {
119	return (strcmp(name,s.name)==0);
120	}
121	bool operator<(const LytCtgData& s) {
122	return (strcmp(name,s.name)<0);
123	}
124	};
125	//callback -- called after a read or contig sequence is loaded
126	typedef bool fnLytSeq(int ctgno, LytCtgData* d, LytSeqInfo* s, char* seq);
127
128	class LayoutParser {
129	protected:
130	FILE* f; //file stream
131	off_t f_pos;
132	char* fname;
133	LytCtgData* currentContig; // currently loaded contig -- for browsing/loading
134	int numContigs; //total number of contigs found in this file
135	//int numSeqs; //total number of (distinct) sequences found in this file
136	GHash<LytSeqInfo> seqinfo; //sequence locations in the file
137	GHash<int> ctgIDs; //contig IDs, to make them unique!
138
139	GList<LytCtgData> contigs; //list of contig names with their size,
140	//number of sequences and filepos
141	protected:
142	GLineReader* linebuf; //the line buffer
143	off_t fskipTo(const char* linestart, const char* butnot=NULL);
144	bool startsWith(const char* s, const char* start, int tlen);
145	virtual LytSeqInfo* addSeq(char* s, LytCtgData* ctg);
146	int seek(off_t offset) {
147	int r=fseeko(f, offset, SEEK_SET);
148	if (r==0) f_pos=offset;
149	return r;
150	}
151
152	public:
153	LayoutParser(const char* filename):contigs(false,true) {
154	f=NULL;
155	f_pos=0;
156	numContigs=0;
157	currentContig=NULL;
158	if (filename==NULL) {
159	f=stdin;
160	fname=Gstrdup("stdin");
161	}
162	else
163	fname=Gstrdup(filename);
164	linebuf=new GLineReader();
165	}
166	virtual ~LayoutParser() {
167	ctgIDs.Clear();
168	GFREE(fname);
169	delete linebuf;
170	close();
171	numContigs=0;
172	seqinfo.Clear();
173	contigs.Clear();
174	}
175	virtual bool open();
176	void close();
177	virtual bool parse(fnLytSeq* seqfn=NULL); //load all the file offsets
178	virtual bool parseContigs(); //load all the file offsets for contigs
179	virtual bool loadContig(int ctgidx, fnLytSeq* seqfn=NULL, bool re_pos=true); //for loading by browsing
180	//if parsefn is not NULL, it is executed, passing the sequence data(first time, with the contig sequence)
181	//if parserfn returns true, the data is freed after it is processed
182	virtual char getFileType() { return 'L'; }
183	//sequence loading - only by request
184	LytCtgData* getContig(int idx) { return contigs[idx]; }
185	virtual char* getSeq(LytSeqInfo* sqinfo) { return NULL; }
186	virtual char* getContigSeq(LytCtgData* ctgdata) { return NULL; }
187	int getNumContigs() { return numContigs; }
188	//int getNumSeqs() { return numSeqs; }
189	off_t getFilePos() { return f_pos; }
190	//sorting the list of contigs:
191	void contigsByName();
192	void contigsByLen();
193	void contigsByNumSeqs();
194	};
195
196	#endif