libStatGen Software  1
ReadFiles.cpp
1 /*
2  * Copyright (C) 2010 Regents of the University of Michigan
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 #include "ReadFiles.h"
19 #include "TestValidate.h"
20 #include "SamTags.h"
21 #include <assert.h>
22 
23 void testReadSam()
24 {
25  SamFile inSam;
26  assert(inSam.OpenForRead("testFiles/testSam.sam"));
27 
28  // Call generic test which since the sam and bam are identical, should
29  // contain the same results.
30  testRead(inSam);
31 
32  inSam.Close();
33 
34  testFlagRead("testFiles/testSam.sam");
35 }
36 
37 void testReadBam()
38 {
39  SamFile inSam;
40  assert(inSam.OpenForRead("testFiles/testBam.bam"));
41 
42  // Call generic test which since the sam and bam are identical, should
43  // contain the same results.
44  testRead(inSam);
45 
46  inSam.Close();
47 
48  testFlagRead("testFiles/testBam.bam");
49 }
50 
51 void testRead(SamFile &inSam)
52 {
53  // Read the SAM Header.
54  SamFileHeader samHeader;
55  assert(inSam.ReadHeader(samHeader));
56 
57  validateHeader(samHeader);
58 
59  testCopyHeader(samHeader);
60 
61  testModHeader(samHeader);
62 
63  SamRecord samRecord;
64  assert(inSam.ReadRecord(samHeader, samRecord) == true);
65  validateRead1(samRecord);
66 
67  // Set a new quality and get the buffer.
68  samRecord.setQuality("ABCDE");
69  validateRead1ModQuality(samRecord);
70  // void* buffer = samRecord.getRecordBuffer();
71 
72  assert(inSam.ReadRecord(samHeader, samRecord) == true);
73  validateRead2(samRecord);
74 
75  assert(inSam.ReadRecord(samHeader, samRecord) == true);
76  validateRead3(samRecord);
77 
78  assert(inSam.ReadRecord(samHeader, samRecord) == true);
79  validateRead4(samRecord);
80 
81  assert(inSam.ReadRecord(samHeader, samRecord) == true);
82  validateRead5(samRecord);
83 
84  assert(inSam.ReadRecord(samHeader, samRecord) == true);
85  validateRead6(samRecord);
86 
87  assert(inSam.ReadRecord(samHeader, samRecord) == true);
88  validateRead7(samRecord);
89 
90  assert(inSam.ReadRecord(samHeader, samRecord) == true);
91  validateRead8(samRecord);
92 
93  assert(inSam.ReadRecord(samHeader, samRecord) == true);
94  validateRead9(samRecord);
95 
96  assert(inSam.ReadRecord(samHeader, samRecord) == true);
97  validateRead10(samRecord);
98 }
99 
100 
101 void testAddHeaderAndTagToFile(const char* inputName, const char* outputName)
102 {
103  SamFile inSam, outSam;
104  assert(inSam.OpenForRead(inputName));
105  assert(outSam.OpenForWrite(outputName));
106 
107  // Read the SAM Header.
108  SamFileHeader samHeader;
109  assert(inSam.ReadHeader(samHeader));
110 
111  // Add a header line.
112  assert(samHeader.addHeaderLine("@RG\tID:myID\tSM:mySM") == false);
113  assert(samHeader.addHeaderLine("@RG\tID:myID3\tSM:mySM") == true);
114 
115  // Write Header
116  assert(outSam.WriteHeader(samHeader));
117 
118  SamRecord samRecord;
119  assert(inSam.ReadRecord(samHeader, samRecord));
120  // validateRead1(samRecord);
121  // Add two tags.
122  assert(samRecord.addIntTag("XA", 123));
123  assert(samRecord.addIntTag("XA", 456));
124  assert(samRecord.addTag("RR", 'Z', "myID1"));
125  assert(samRecord.addTag("RR", 'Z', "myID2"));
126 
127  // Write as Sam.
128  assert(outSam.WriteRecord(samHeader, samRecord));
129 
130  // TODO, add test to verify it was written correctly.
131 
132  // Read a couple of records to make sure it properly can read them even
133  // if they are bigger than the original.
134  assert(inSam.ReadRecord(samHeader, samRecord));
135  assert(inSam.ReadRecord(samHeader, samRecord));
136 
137  // Check the MD tag, which requires the reference.
138  GenomeSequence reference("testFiles/chr1_partial.fa");
139  assert(SamTags::isMDTagCorrect(samRecord, reference) == false);
140  String newMDTag;
141  SamTags::createMDTag(newMDTag, samRecord, reference);
142  assert(newMDTag == "2T1N0");
143  assert(SamTags::updateMDTag(samRecord, reference));
144  // Write as Sam.
145  assert(outSam.WriteRecord(samHeader, samRecord));
146 }
147 
148 
149 // Test reading a file, validating it is sorted.
150 void testValidateSortedRead()
151 {
152  // Open a file for reading.
154  assert(inSam.OpenForRead("testFiles/testSam.sam"));
155 
156  // Set the validation to COORDINATE.
158 
159  // Read the SAM Header.
160  SamFileHeader samHeader;
161  assert(inSam.ReadHeader(samHeader));
162 
163  SamRecord samRecord;
164  // Succeed, first record.
165  assert(inSam.ReadRecord(samHeader, samRecord) == true);
166  validateRead1(samRecord);
167 
168  // Succeed, higher coordinate.
169  assert(inSam.ReadRecord(samHeader, samRecord) == true);
170  validateRead2(samRecord);
171 
172  // Failed sort order - due to coord.
173  assert(inSam.ReadRecord(samHeader, samRecord) == false);
174  validateRead3(samRecord);
175 
176  // Failed sort order - due to coord.
177  assert(inSam.ReadRecord(samHeader, samRecord) == false);
178  validateRead4(samRecord);
179 
180  // Succeed, new reference id
181  assert(inSam.ReadRecord(samHeader, samRecord) == true);
182  validateRead5(samRecord);
183 
184  // Fail, previous reference id.
185  assert(inSam.ReadRecord(samHeader, samRecord) == false);
186  validateRead6(samRecord);
187 
188  // Succeed, same reference id, higher coord.
189  assert(inSam.ReadRecord(samHeader, samRecord) == true);
190  validateRead7(samRecord);
191 
192  // Succeed, *, new reference id.
193  assert(inSam.ReadRecord(samHeader, samRecord) == true);
194  validateRead8(samRecord);
195 
196  // Fail, reference id is not *
197  assert(inSam.ReadRecord(samHeader, samRecord) == false);
198  validateRead9(samRecord);
199 
200  // Succeed, valid reference id, and no coordinate.
201  assert(inSam.ReadRecord(samHeader, samRecord) == true);
202  validateRead10(samRecord);
203 
204 
205  ////////////////////////////////////////////
206  // Reopen the file for reading
207  assert(inSam.OpenForRead("testFiles/testSam.sam"));
208 
209  // Set the validation to QUERY_NAME.
211 
212  // Read the SAM Header.
213  assert(inSam.ReadHeader(samHeader));
214 
215  // Succeed, first record.
216  assert(inSam.ReadRecord(samHeader, samRecord) == true);
217  validateRead1(samRecord);
218 
219  // Succeed, same name.
220  assert(inSam.ReadRecord(samHeader, samRecord) == true);
221  validateRead2(samRecord);
222 
223  // Succeeds - numeric sort
224  assert(inSam.ReadRecord(samHeader, samRecord) == true);
225  validateRead3(samRecord);
226 
227  // Succeeds - numeric sort
228  assert(inSam.ReadRecord(samHeader, samRecord) == true);
229  validateRead4(samRecord);
230 
231  // Succeeds - numeric sort
232  assert(inSam.ReadRecord(samHeader, samRecord) == true);
233  validateRead5(samRecord);
234 
235  // Succeeds - numeric sort
236  assert(inSam.ReadRecord(samHeader, samRecord) == true);
237  validateRead6(samRecord);
238 
239  // Succeeds - numeric sort
240  assert(inSam.ReadRecord(samHeader, samRecord) == true);
241  validateRead7(samRecord);
242 
243  // Succeed - std sort
244  assert(inSam.ReadRecord(samHeader, samRecord) == true);
245  validateRead8(samRecord);
246 
247  // Succeed - numeric sort (Y<18)
248  assert(inSam.ReadRecord(samHeader, samRecord) == true);
249  validateRead9(samRecord);
250 
251  // Succeed - std sort
252  assert(inSam.ReadRecord(samHeader, samRecord) == true);
253  validateRead10(samRecord);
254 
255  ////////////////////////////////////////////
256  // Reopen the file for reading
257  assert(inSam.OpenForRead("testFiles/testSam.sam"));
258 
259  // Set the validation to the SO Flag. Not set, so it is UNSORTED, so
260  // all reads should pass.
262 
263  // Read the SAM Header.
264  assert(inSam.ReadHeader(samHeader));
265 
266  assert(inSam.ReadRecord(samHeader, samRecord) == true);
267  validateRead1(samRecord);
268 
269  assert(inSam.ReadRecord(samHeader, samRecord) == true);
270  validateRead2(samRecord);
271 
272  assert(inSam.ReadRecord(samHeader, samRecord) == true);
273  validateRead3(samRecord);
274 
275  assert(inSam.ReadRecord(samHeader, samRecord) == true);
276  validateRead4(samRecord);
277 
278  assert(inSam.ReadRecord(samHeader, samRecord) == true);
279  validateRead5(samRecord);
280 
281  assert(inSam.ReadRecord(samHeader, samRecord) == true);
282  validateRead6(samRecord);
283 
284  assert(inSam.ReadRecord(samHeader, samRecord) == true);
285  validateRead7(samRecord);
286 
287  assert(inSam.ReadRecord(samHeader, samRecord) == true);
288  validateRead8(samRecord);
289 
290  assert(inSam.ReadRecord(samHeader, samRecord) == true);
291  validateRead9(samRecord);
292 
293  assert(inSam.ReadRecord(samHeader, samRecord) == true);
294  validateRead10(samRecord);
295 
296  ////////////////////////////////////////////
297  // Reopen for reading SO FLAG set to coordinate.
298  assert(inSam.OpenForRead("testFiles/testSamSOcoord.sam"));
299 
300  // Set the validation to SO FLAG which is set to coordinate.
302 
303  // Read the SAM Header.
304  assert(inSam.ReadHeader(samHeader));
305 
306  // Succeed, first record.
307  assert(inSam.ReadRecord(samHeader, samRecord) == true);
308  validateRead1(samRecord);
309 
310  // Succeed, higher coordinate.
311  assert(inSam.ReadRecord(samHeader, samRecord) == true);
312  validateRead2(samRecord);
313 
314  // Failed sort order - due to coord.
315  assert(inSam.ReadRecord(samHeader, samRecord) == false);
316  validateRead3(samRecord);
317 
318  // Failed sort order - due to coord.
319  assert(inSam.ReadRecord(samHeader, samRecord) == false);
320  validateRead4(samRecord);
321 
322  // Succeed, new reference id
323  assert(inSam.ReadRecord(samHeader, samRecord) == true);
324  validateRead5(samRecord);
325 
326  // Fail, previous reference id.
327  assert(inSam.ReadRecord(samHeader, samRecord) == false);
328  validateRead6(samRecord);
329 
330  // Succeed, same reference id, higher coord.
331  assert(inSam.ReadRecord(samHeader, samRecord) == true);
332  validateRead7(samRecord);
333 
334  // Succeed, *, new reference id.
335  assert(inSam.ReadRecord(samHeader, samRecord) == true);
336  validateRead8(samRecord);
337 
338  // Fail, reference id is not *
339  assert(inSam.ReadRecord(samHeader, samRecord) == false);
340  validateRead9(samRecord);
341 
342  // Succeed, valid reference id, and no coordinate.
343  assert(inSam.ReadRecord(samHeader, samRecord) == true);
344  validateRead10(samRecord);
345 
346 
347  ////////////////////////////////////////////
348  // Reopen the file for reading
349  assert(inSam.OpenForRead("testFiles/testSamSOquery.sam"));
350 
351  // Set the validation to FLAG, SO set to queryname.
353 
354  // Read the SAM Header.
355  assert(inSam.ReadHeader(samHeader));
356 
357  // Succeed, first record.
358  assert(inSam.ReadRecord(samHeader, samRecord) == true);
359  validateRead1(samRecord);
360 
361  // Succeed, same name.
362  assert(inSam.ReadRecord(samHeader, samRecord) == true);
363  validateRead2(samRecord);
364 
365  // Succeeds - numeric sort
366  assert(inSam.ReadRecord(samHeader, samRecord) == true);
367  validateRead3(samRecord);
368 
369  // Succeeds - numeric sort
370  assert(inSam.ReadRecord(samHeader, samRecord) == true);
371  validateRead4(samRecord);
372 
373  // Succeeds - numeric sort
374  assert(inSam.ReadRecord(samHeader, samRecord) == true);
375  validateRead5(samRecord);
376 
377  // Succeeds - numeric sort
378  assert(inSam.ReadRecord(samHeader, samRecord) == true);
379  validateRead6(samRecord);
380 
381  // Succeeds - numeric sort
382  assert(inSam.ReadRecord(samHeader, samRecord) == true);
383  validateRead7(samRecord);
384 
385  // Succeed - std sort
386  assert(inSam.ReadRecord(samHeader, samRecord) == true);
387  validateRead8(samRecord);
388 
389  // Succeed - numeric sort (Y<18)
390  assert(inSam.ReadRecord(samHeader, samRecord) == true);
391  validateRead9(samRecord);
392 
393  // Succeed - std sort
394  assert(inSam.ReadRecord(samHeader, samRecord) == true);
395  validateRead10(samRecord);
396 
397  ////////////////////////////////////////////
398  // Reopen the file for reading, SO flag set to junk.
399  assert(inSam.OpenForRead("testFiles/testSamSOinvalid.sam"));
400 
401  // Set the validation to the SO Flag. Not set to anything valid,
402  // so it is considered UNSORTED, so all reads should pass.
404 
405  // Read the SAM Header.
406  assert(inSam.ReadHeader(samHeader));
407 
408  assert(inSam.ReadRecord(samHeader, samRecord) == true);
409  validateRead1(samRecord);
410 
411  assert(inSam.ReadRecord(samHeader, samRecord) == true);
412  validateRead2(samRecord);
413 
414  assert(inSam.ReadRecord(samHeader, samRecord) == true);
415  validateRead3(samRecord);
416 
417  assert(inSam.ReadRecord(samHeader, samRecord) == true);
418  validateRead4(samRecord);
419 
420  assert(inSam.ReadRecord(samHeader, samRecord) == true);
421  validateRead5(samRecord);
422 
423  assert(inSam.ReadRecord(samHeader, samRecord) == true);
424  validateRead6(samRecord);
425 
426  assert(inSam.ReadRecord(samHeader, samRecord) == true);
427  validateRead7(samRecord);
428 
429  assert(inSam.ReadRecord(samHeader, samRecord) == true);
430  validateRead8(samRecord);
431 
432  assert(inSam.ReadRecord(samHeader, samRecord) == true);
433  validateRead9(samRecord);
434 
435  assert(inSam.ReadRecord(samHeader, samRecord) == true);
436  validateRead10(samRecord);
437 }
438 
439 
440 
441 void validateRead1ModQuality(SamRecord& samRecord)
442 {
443  //////////////////////////////////////////
444  // Validate Record 1
445  // Create record structure for validating.
446  int expectedBlockSize = 89;
447  const char* expectedReferenceName = "1";
448  const char* expectedMateReferenceName = "1";
449  const char* expectedMateReferenceNameOrEqual = "=";
450 
451  bamRecordStruct* expectedRecordPtr =
452  (bamRecordStruct *) malloc(expectedBlockSize + sizeof(int));
453 
454  char tag[3];
455  char type;
456  void* value;
457  bamRecordStruct* bufferPtr;
458  unsigned char* varPtr;
459 
460  expectedRecordPtr->myBlockSize = expectedBlockSize;
461  expectedRecordPtr->myReferenceID = 0;
462  expectedRecordPtr->myPosition = 1010;
463  expectedRecordPtr->myReadNameLength = 23;
464  expectedRecordPtr->myMapQuality = 0;
465  expectedRecordPtr->myBin = 4681;
466  expectedRecordPtr->myCigarLength = 2;
467  expectedRecordPtr->myFlag = 73;
468  expectedRecordPtr->myReadLength = 5;
469  expectedRecordPtr->myMateReferenceID = 0;
470  expectedRecordPtr->myMatePosition = 1010;
471  expectedRecordPtr->myInsertSize = 0;
472 
473  // Check the alignment end
474  assert(samRecord.get0BasedAlignmentEnd() == 1016);
475  assert(samRecord.get1BasedAlignmentEnd() == 1017);
476  assert(samRecord.getAlignmentLength() == 7);
477  assert(samRecord.get0BasedUnclippedStart() == 1010);
478  assert(samRecord.get1BasedUnclippedStart() == 1011);
479  assert(samRecord.get0BasedUnclippedEnd() == 1016);
480  assert(samRecord.get1BasedUnclippedEnd() == 1017);
481 
482  // Check the accessors.
483  assert(samRecord.getBlockSize() == expectedRecordPtr->myBlockSize);
484  assert(samRecord.getReferenceID() == expectedRecordPtr->myReferenceID);
485  assert(strcmp(samRecord.getReferenceName(), expectedReferenceName) == 0);
486  assert(samRecord.get1BasedPosition() == expectedRecordPtr->myPosition + 1);
487  assert(samRecord.get0BasedPosition() == expectedRecordPtr->myPosition);
488  assert(samRecord.getReadNameLength() ==
489  expectedRecordPtr->myReadNameLength);
490  assert(samRecord.getMapQuality() == expectedRecordPtr->myMapQuality);
491  assert(samRecord.getBin() == expectedRecordPtr->myBin);
492  assert(samRecord.getCigarLength() == expectedRecordPtr->myCigarLength);
493  assert(samRecord.getFlag() == expectedRecordPtr->myFlag);
494  assert(samRecord.getReadLength() == expectedRecordPtr->myReadLength);
495  assert(samRecord.getMateReferenceID() ==
496  expectedRecordPtr->myMateReferenceID);
497  assert(strcmp(samRecord.getMateReferenceName(),
498  expectedMateReferenceName) == 0);
499  assert(strcmp(samRecord.getMateReferenceNameOrEqual(),
500  expectedMateReferenceNameOrEqual) == 0);
501  assert(samRecord.get1BasedMatePosition() ==
502  expectedRecordPtr->myMatePosition + 1);
503  assert(samRecord.get0BasedMatePosition() ==
504  expectedRecordPtr->myMatePosition);
505  assert(samRecord.getInsertSize() == expectedRecordPtr->myInsertSize);
506  assert(strcmp(samRecord.getReadName(), "1:1011:F:255+17M15D20M") == 0);
507  assert(strcmp(samRecord.getCigar(), "5M2D") == 0);
508  assert(strcmp(samRecord.getSequence(), "CCGAA") == 0);
509  assert(strcmp(samRecord.getQuality(), "ABCDE") == 0);
510  assert(samRecord.getNumOverlaps(1010, 1017) == 5);
511  assert(samRecord.getNumOverlaps(1010, 1016) == 5);
512  assert(samRecord.getNumOverlaps(1012, 1017) == 3);
513  assert(samRecord.getNumOverlaps(1015, 1017) == 0);
514  assert(samRecord.getNumOverlaps(1017, 1010) == 0);
515  assert(samRecord.getNumOverlaps(1013, 1011) == 0);
516  assert(samRecord.getNumOverlaps(-1, 1017) == 5);
517 
518  // Reset the tag iter, since the tags have already been read.
519  samRecord.resetTagIter();
520 
521  // Check the tags.
522  assert(samRecord.getNextSamTag(tag, type, &value) == true);
523  assert(tag[0] == 'A');
524  assert(tag[1] == 'M');
525  assert(type == 'i');
526  assert(*(char*)value == 0);
527  assert(samRecord.getNextSamTag(tag, type, &value) == true);
528  assert(tag[0] == 'M');
529  assert(tag[1] == 'D');
530  assert(type == 'Z');
531  assert(*(String*)value == "37");
532  assert(samRecord.getNextSamTag(tag, type, &value) == true);
533  assert(tag[0] == 'N');
534  assert(tag[1] == 'M');
535  assert(type == 'i');
536  assert(*(char*)value == 0);
537  assert(samRecord.getNextSamTag(tag, type, &value) == true);
538  assert(tag[0] == 'X');
539  assert(tag[1] == 'T');
540  assert(type == 'A');
541  assert(*(char*)value == 'R');
542  // No more tags, should return false.
543  assert(samRecord.getNextSamTag(tag, type, &value) == false);
544  assert(samRecord.getNextSamTag(tag, type, &value) == false);
545 
546  // Get the record ptr.
547  bufferPtr = (bamRecordStruct*)samRecord.getRecordBuffer();
548  // Validate the buffers match.
549  assert(bufferPtr->myBlockSize == expectedRecordPtr->myBlockSize);
550  assert(bufferPtr->myReferenceID == expectedRecordPtr->myReferenceID);
551  assert(bufferPtr->myPosition == expectedRecordPtr->myPosition);
552  assert(bufferPtr->myReadNameLength == expectedRecordPtr->myReadNameLength);
553  assert(bufferPtr->myMapQuality == expectedRecordPtr->myMapQuality);
554  assert(bufferPtr->myBin == expectedRecordPtr->myBin);
555  assert(bufferPtr->myCigarLength == expectedRecordPtr->myCigarLength);
556  assert(bufferPtr->myFlag == expectedRecordPtr->myFlag);
557  assert(bufferPtr->myReadLength == expectedRecordPtr->myReadLength);
558  assert(bufferPtr->myMateReferenceID ==
559  expectedRecordPtr->myMateReferenceID);
560  assert(bufferPtr->myMatePosition == expectedRecordPtr->myMatePosition);
561  assert(bufferPtr->myInsertSize == expectedRecordPtr->myInsertSize);
562 
563  // Validate the variable length fields in the buffer.
564  // Set the pointer to the start of the variable fields.
565  varPtr = (unsigned char*)(&(bufferPtr->myData[0]));
566 
567  // Validate the readname.
568  for(int i = 0; i < expectedRecordPtr->myReadNameLength; i++)
569  {
570  assert(*varPtr == samRecord.getReadName()[i]);
571  varPtr++;
572  }
573 
574  // Validate the cigar.
575  // The First cigar is 5M which is 5 << 4 | 0 = 80
576  assert(*(unsigned int*)varPtr == 80);
577  // Increment the varptr the size of an int.
578  varPtr += 4;
579  // The 2nd cigar is 2D which is 2 << 4 | 2 = 34
580  assert(*(unsigned int*)varPtr == 34);
581  // Increment the varptr the size of an int.
582  varPtr += 4;
583 
584  // Validate the sequence.
585  // CC = 0x22
586  assert(*varPtr == 0x22);
587  varPtr++;
588  // GA = 0x41
589  assert(*varPtr == 0x41);
590  varPtr++;
591  // A = 0x10
592  assert(*varPtr == 0x10);
593  varPtr++;
594 
595  // Validate the Quality
596  for(int i = 0; i < expectedRecordPtr->myReadLength; i++)
597  {
598  assert(*varPtr == samRecord.getQuality()[i] - 33);
599  varPtr++;
600  }
601 
602  // Validate the tags.
603  assert(*varPtr == 'A');
604  varPtr++;
605  assert(*varPtr == 'M');
606  varPtr++;
607  assert(*varPtr == 'C');
608  varPtr++;
609  assert(*varPtr == 0);
610  varPtr++;
611  assert(*varPtr == 'M');
612  varPtr++;
613  assert(*varPtr == 'D');
614  varPtr++;
615  assert(*varPtr == 'Z');
616  varPtr++;
617  assert(*varPtr == '3');
618  varPtr++;
619  assert(*varPtr == '7');
620  varPtr++;
621  assert(*varPtr == 0);
622  varPtr++;
623  assert(*varPtr == 'N');
624  varPtr++;
625  assert(*varPtr == 'M');
626  varPtr++;
627  assert(*varPtr == 'C');
628  varPtr++;
629  assert(*varPtr == 0);
630  varPtr++;
631  assert(*varPtr == 'X');
632  varPtr++;
633  assert(*varPtr == 'T');
634  varPtr++;
635  assert(*varPtr == 'A');
636  varPtr++;
637  assert(*varPtr == 'R');
638  varPtr++;
639 }
640 
641 
642 void testModHeader(SamFileHeader& samHeader)
643 {
644  // Check the header line.
645  std::string headerString = "";
646  assert(samHeader.getHeaderString(headerString) == true);
647  assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:11\tLN:134452384\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\tLB:library2\n@CO\tComment 1\n@CO\tComment 2\n");
648 
649  // Remove a tag - by setting it to "".
650  assert(samHeader.setRGTag("LB", "", "myID2") == true);
651 
652 
653  // Check the header line.
654  assert(samHeader.getHeaderString(headerString) == true);
655  assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:11\tLN:134452384\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\n@CO\tComment 1\n@CO\tComment 2\n");
656 
657  // Add an HD tag.
658  SamHeaderHD* hd = new SamHeaderHD();
659  assert(hd->setTag("VN", "1.3") == true);
660  assert(samHeader.addHD(hd) == true);
661  assert(strcmp(samHeader.getHDTagValue("VN"), "1.3") == 0);
662  assert(samHeader.getHeaderString(headerString) == true);
663  assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:11\tLN:134452384\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\n@HD\tVN:1.3\n@CO\tComment 1\n@CO\tComment 2\n");
664 
665  // Try adding another HD tag.
666  SamHeaderHD* hd2 = new SamHeaderHD();
667  assert(hd2->setTag("VN", "1.4") == true);
668  assert(samHeader.addHD(hd2) == false);
669  assert(strcmp(samHeader.getHDTagValue("VN"), "1.4") != 0);
670  assert(strcmp(samHeader.getHDTagValue("VN"), "1.3") == 0);
671  assert(samHeader.getHeaderString(headerString) == true);
672  assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:11\tLN:134452384\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\n@HD\tVN:1.3\n@CO\tComment 1\n@CO\tComment 2\n");
673 
674  // Remove the entire HD Tag.
675  assert(samHeader.removeHD() == true);
676  assert(strcmp(samHeader.getHDTagValue("VN"), "") == 0);
677  assert(samHeader.getHeaderString(headerString) == true);
678  assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:11\tLN:134452384\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\n@CO\tComment 1\n@CO\tComment 2\n");
679 
680  // Remove an entire SQ Tag.
681  assert(strcmp(samHeader.getSQTagValue("LN", "11"), "134452384") == 0);
682  assert(samHeader.removeSQ("11") == true);
683  assert(strcmp(samHeader.getSQTagValue("LN", "11"), "") == 0);
684  assert(samHeader.getHeaderString(headerString) == true);
685  assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\n@CO\tComment 1\n@CO\tComment 2\n");
686 
687  // Try adding a null HD tag.
688  hd = NULL;
689  assert(samHeader.addHD(hd) == false);
690  assert(strcmp(samHeader.getHDTagValue("VN"), "") == 0);
691  assert(strcmp(samHeader.getHDTagValue("VN"), "1.4") != 0);
692  assert(strcmp(samHeader.getHDTagValue("VN"), "1.3") != 0);
693  assert(samHeader.getHeaderString(headerString) == true);
694  assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\n@CO\tComment 1\n@CO\tComment 2\n");
695 
696  // Try adding a null SQ tag.
697  SamHeaderSQ* sq = NULL;
698  assert(samHeader.addSQ(sq) == false);
699  assert(samHeader.getHeaderString(headerString) == true);
700  assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\n@CO\tComment 1\n@CO\tComment 2\n");
701 
702  // Try adding an HD tag again.
703  assert(samHeader.addHD(hd2) == true);
704  assert(strcmp(samHeader.getHDTagValue("VN"), "1.4") == 0);
705  assert(strcmp(samHeader.getHDTagValue("VN"), "1.3") != 0);
706  assert(samHeader.getHeaderString(headerString) == true);
707  assert(headerString == "@SQ\tSN:1\tLN:247249719\n@SQ\tSN:2\tLN:242951149\n@SQ\tSN:3\tLN:199501827\n@SQ\tSN:4\tLN:191273063\n@SQ\tSN:5\tLN:180857866\n@SQ\tSN:6\tLN:170899992\n@SQ\tSN:7\tLN:158821424\n@SQ\tSN:8\tLN:146274826\n@SQ\tSN:9\tLN:140273252\n@SQ\tSN:10\tLN:135374737\n@SQ\tSN:12\tLN:132349534\n@SQ\tSN:13\tLN:114142980\n@SQ\tSN:14\tLN:106368585\n@SQ\tSN:15\tLN:100338915\n@SQ\tSN:16\tLN:88827254\n@SQ\tSN:17\tLN:78774742\n@SQ\tSN:18\tLN:76117153\n@SQ\tSN:19\tLN:63811651\n@SQ\tSN:20\tLN:62435964\n@SQ\tSN:21\tLN:46944323\n@SQ\tSN:22\tLN:49691432\n@SQ\tSN:X\tLN:154913754\n@RG\tID:myID\tLB:library\tSM:sample\n@RG\tID:myID2\tSM:sample2\n@HD\tVN:1.4\n@CO\tComment 1\n@CO\tComment 2\n");
708 
709 
710  // TODO Get the comments.
711 
712 }
713 
714 
715 
716 void testFlagRead(const char* fileName)
717 {
718  SamFile inSam;
719  SamFileHeader samHeader;
720  SamRecord samRecord;
721 
722  ////////////////////////////////////////////////////////////
723  // Required flag 0x48 (only flag 73 matches)
724  // Exclude nothing
725  assert(inSam.OpenForRead(fileName));
726  assert(inSam.ReadHeader(samHeader));
727  validateHeader(samHeader);
728  inSam.SetReadFlags(0x48, 0x0);
729 
730  assert(inSam.ReadRecord(samHeader, samRecord) == true);
731  validateRead1(samRecord);
732 
733  assert(inSam.ReadRecord(samHeader, samRecord) == false);
734 
735  inSam.Close();
736 
737  ////////////////////////////////////////////////////////////
738  // No required flags.
739  // Exclude 0x48. This leaves just the one read with flag 133.
740  assert(inSam.OpenForRead(fileName));
741  assert(inSam.ReadHeader(samHeader));
742  validateHeader(samHeader);
743  inSam.SetReadFlags(0x0, 0x48);
744 
745  assert(inSam.ReadRecord(samHeader, samRecord) == true);
746  validateRead2(samRecord);
747 
748  assert(inSam.ReadRecord(samHeader, samRecord) == false);
749 
750  inSam.Close();
751 
752  ////////////////////////////////////////////////////////////
753  // Required flag 0x40
754  // Exclude 0x48.
755  // This will not find any records since the exclude and required conflict.
756  assert(inSam.OpenForRead(fileName));
757  assert(inSam.ReadHeader(samHeader));
758  validateHeader(samHeader);
759  inSam.SetReadFlags(0x40, 0x48);
760 
761  assert(inSam.ReadRecord(samHeader, samRecord) == false);
762 
763  inSam.Close();
764 
765  ////////////////////////////////////////////////////////////
766  // Required flag 0x4
767  // Exclude 0x8.
768  // Only finds flag 133.
769  assert(inSam.OpenForRead(fileName));
770  assert(inSam.ReadHeader(samHeader));
771  validateHeader(samHeader);
772  inSam.SetReadFlags(0x4, 0x8);
773 
774  assert(inSam.ReadRecord(samHeader, samRecord) == true);
775  validateRead2(samRecord);
776 
777  assert(inSam.ReadRecord(samHeader, samRecord) == false);
778 
779  inSam.Close();
780 
781  ////////////////////////////////////////////////////////////
782  // Required flag 0x4
783  // Exclude nothing
784  // Finds flags 133 & 141.
785  assert(inSam.OpenForRead(fileName));
786  assert(inSam.ReadHeader(samHeader));
787  validateHeader(samHeader);
788  inSam.SetReadFlags(0x4, 0x0);
789 
790  assert(inSam.ReadRecord(samHeader, samRecord) == true);
791  validateRead2(samRecord);
792 
793  assert(inSam.ReadRecord(samHeader, samRecord) == true);
794  validateRead8(samRecord);
795 
796  assert(inSam.ReadRecord(samHeader, samRecord) == true);
797  validateRead10(samRecord);
798 
799  assert(inSam.ReadRecord(samHeader, samRecord) == false);
800 
801  inSam.Close();
802 }
803 
804 
805 void testCopyHeader(SamFileHeader& samHeader)
806 {
807  // Copy the header.
808  SamFileHeader samHeader2;
809 
810  SamHeaderRecord* recPtr = samHeader.getNextHeaderRecord();
811  while(recPtr != NULL)
812  {
813  samHeader2.addRecordCopy(*recPtr);
814  recPtr = samHeader.getNextHeaderRecord();
815  }
816  // Add the comments.
817  std::string nextComment = samHeader.getNextComment();
818  while(nextComment != SamFileHeader::EMPTY_RETURN)
819  {
820  samHeader2.addComment(nextComment.c_str());
821  nextComment = samHeader.getNextComment();
822  }
823  // Validate the header.
824  validateHeader(samHeader2);
825 }
SamFile::COORDINATE
@ COORDINATE
file is sorted by coordinate.
Definition: SamFile.h:49
SamRecord::get0BasedPosition
int32_t get0BasedPosition()
Get the 0-based(BAM) leftmost position of the record.
Definition: SamRecord.cpp:1307
SamRecord::getReferenceName
const char * getReferenceName()
Get the reference sequence name (RNAME) of the record.
Definition: SamRecord.cpp:1286
SamRecord::get1BasedUnclippedStart
int32_t get1BasedUnclippedStart()
Returns the 1-based inclusive left-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1507
SamFile::FLAG
@ FLAG
SO flag from the header indicates the sort type.
Definition: SamFile.h:48
SamRecord::get0BasedAlignmentEnd
int32_t get0BasedAlignmentEnd()
Returns the 0-based inclusive rightmost position of the clipped sequence.
Definition: SamRecord.cpp:1455
SamRecord::getBin
uint16_t getBin()
Get the BAM bin for the record.
Definition: SamRecord.cpp:1335
SamFile::WriteRecord
bool WriteRecord(SamFileHeader &header, SamRecord &record)
Writes the specified record into the file.
Definition: SamFile.cpp:619
SamRecord::getMateReferenceID
int32_t getMateReferenceID()
Get the mate reference id of the record (BAM format: mate_rid/next_refID).
Definition: SamRecord.cpp:1426
SamRecord::getReferenceID
int32_t getReferenceID()
Get the reference sequence id of the record (BAM format rid).
Definition: SamRecord.cpp:1293
String
Definition: StringBasics.h:38
ErrorHandler::RETURN
@ RETURN
just return failure on the error
Definition: ErrorHandler.h:31
SamFileHeader::getSQTagValue
const char * getSQTagValue(const char *tag, const char *name)
Get the value associated with the specified tag on the SQ line with the specified sequence name,...
Definition: SamFileHeader.cpp:696
GenomeSequence
Create/Access/Modify/Load Genome Sequences stored as binary mapped files.
Definition: GenomeSequence.h:99
SamRecord::getMapQuality
uint8_t getMapQuality()
Get the mapping quality (MAPQ) of the record.
Definition: SamRecord.cpp:1328
SamHeaderSQ
Definition: SamHeaderSQ.h:23
SamFileHeader::addSQ
bool addSQ(SamHeaderSQ *sq)
Add the SQ record to the header.
Definition: SamFileHeader.cpp:415
SamRecord::getCigarLength
uint16_t getCigarLength()
Get the length of the BAM formatted CIGAR.
Definition: SamRecord.cpp:1350
SamFile::ReadRecord
bool ReadRecord(SamFileHeader &header, SamRecord &record)
Reads the next record from the file & stores it in the passed in record.
Definition: SamFile.cpp:501
SamFileHeader::getNextComment
const char * getNextComment()
Returns the comment on the next comment line.
Definition: SamFileHeader.cpp:985
SamFile::QUERY_NAME
@ QUERY_NAME
file is sorted by queryname.
Definition: SamFile.h:50
SamRecord::get0BasedUnclippedStart
int32_t get0BasedUnclippedStart()
Returns the 0-based inclusive left-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1494
SamFileHeader::getHDTagValue
const char * getHDTagValue(const char *tag)
Returns the value associated with the specified HD tag, returning "" if the tag does not exist in the...
Definition: SamFileHeader.cpp:683
SamRecord::getFlag
uint16_t getFlag()
Get the flag (FLAG).
Definition: SamRecord.cpp:1372
SamRecord::getRecordBuffer
const void * getRecordBuffer()
Get a const pointer to the buffer that contains the BAM representation of the record.
Definition: SamRecord.cpp:1192
SamFileHeader::getHeaderString
bool getHeaderString(std::string &header) const
Set the passed in string to the entire header string, clearing its current contents.
Definition: SamFileHeader.cpp:131
SamFile::SetReadFlags
void SetReadFlags(uint16_t requiredFlags, uint16_t excludedFlags)
Specify which reads should be returned by ReadRecord.
Definition: SamFile.cpp:781
SamTags::isMDTagCorrect
static bool isMDTagCorrect(SamRecord &inputRec, GenomeSequence &genome)
Check to see if the MD tag in the record is accurate.
Definition: SamTags.cpp:126
SamRecord::getAlignmentLength
int32_t getAlignmentLength()
Returns the length of the clipped sequence, returning 0 if the cigar is '*'.
Definition: SamRecord.cpp:1481
SamRecord::get1BasedPosition
int32_t get1BasedPosition()
Get the 1-based(SAM) leftmost position (POS) of the record.
Definition: SamRecord.cpp:1300
SamFile::OpenForWrite
bool OpenForWrite(const char *filename, SamFileHeader *header=NULL)
Open a sam/bam file for writing with the specified filename, determining SAM/BAM from the extension (...
Definition: SamFile.cpp:223
SamRecord::get1BasedUnclippedEnd
int32_t get1BasedUnclippedEnd()
Returns the 1-based inclusive right-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1523
SamRecord::resetTagIter
void resetTagIter()
Reset the tag iterator to the beginning of the tags.
Definition: SamRecord.cpp:2022
SamFileHeader::addHD
bool addHD(SamHeaderHD *hd)
Add the HD record to the header.
Definition: SamFileHeader.cpp:393
SamRecord::getQuality
const char * getQuality()
Returns the SAM formatted quality string (QUAL).
Definition: SamRecord.cpp:1626
SamFileHeader::addRecordCopy
bool addRecordCopy(const SamHeaderRecord &hdrRec)
Add a copy of the specified header record to the header.
Definition: SamFileHeader.cpp:526
SamFileHeader::removeSQ
bool removeSQ(const char *name)
Remove SQ record with the specified key.
Definition: SamFileHeader.cpp:573
SamRecord::get0BasedMatePosition
int32_t get0BasedMatePosition()
Get the 0-based(BAM) leftmost mate/next fragment's position.
Definition: SamRecord.cpp:1440
SamRecord::getReadName
const char * getReadName()
Returns the SAM formatted Read Name (QNAME).
Definition: SamRecord.cpp:1530
SamRecord::get0BasedUnclippedEnd
int32_t get0BasedUnclippedEnd()
Returns the 0-based inclusive right-most position adjusted for clipped bases.
Definition: SamRecord.cpp:1514
SamFileHeader::getNextHeaderRecord
SamHeaderRecord * getNextHeaderRecord(uint32_t &index, SamHeaderRecord::SamHeaderRecordType headerType)
Get the next header record of the specified type starting from the specified index and update the ind...
Definition: SamFileHeader.cpp:871
SamRecord::getSequence
const char * getSequence()
Returns the SAM formatted sequence string (SEQ), translating the base as specified by setSequenceTran...
Definition: SamRecord.cpp:1556
SamRecord::getReadLength
int32_t getReadLength()
Get the length of the read.
Definition: SamRecord.cpp:1379
SamFileHeader
This class allows a user to get/set the fields in a SAM/BAM Header.
Definition: SamFileHeader.h:34
SamRecord::addTag
bool addTag(const char *tag, char vtype, const char *value)
Add the specified tag,vtype,value to the record.
Definition: SamRecord.cpp:779
SamRecord::getInsertSize
int32_t getInsertSize()
Get the inferred insert size of the read pair (ISIZE) or observed template length (TLEN).
Definition: SamRecord.cpp:1447
SamRecord::getCigar
const char * getCigar()
Returns the SAM formatted CIGAR string.
Definition: SamRecord.cpp:1543
SamRecord::getBlockSize
int32_t getBlockSize()
Get the block size of the record (BAM format).
Definition: SamRecord.cpp:1269
SamTags::createMDTag
static bool createMDTag(String &outputMDtag, SamRecord &inputRec, GenomeSequence &genome)
Create the MD tag for the specified input record and the genome.
Definition: SamTags.cpp:34
SamFile::setSortedValidation
void setSortedValidation(SortedType sortType)
Set the flag to validate that the file is sorted as it is read/written.
Definition: SamFile.cpp:669
SamRecord
Class providing an easy to use interface to get/set/operate on the fields in a SAM/BAM record.
Definition: SamRecord.h:51
SamRecord::get1BasedMatePosition
int32_t get1BasedMatePosition()
Get the 1-based(SAM) leftmost mate/next fragment's position (PNEXT).
Definition: SamRecord.cpp:1433
SamRecord::getReadNameLength
uint8_t getReadNameLength()
Get the length of the readname (QNAME) including the null.
Definition: SamRecord.cpp:1314
SamFile::OpenForRead
bool OpenForRead(const char *filename, SamFileHeader *header=NULL)
Open a sam/bam file for reading with the specified filename, determing the type of file and SAM/BAM b...
Definition: SamFile.cpp:93
SamFile::WriteHeader
bool WriteHeader(SamFileHeader &header)
Writes the specified header into the file.
Definition: SamFile.cpp:467
SamRecord::getMateReferenceNameOrEqual
const char * getMateReferenceNameOrEqual()
Get the mate/next fragment's reference sequence name (RNEXT), returning "=" if it is the same as the ...
Definition: SamRecord.cpp:1408
SamRecord::getNumOverlaps
uint32_t getNumOverlaps(int32_t start, int32_t end)
Return the number of bases in this read that overlap the passed in region.
Definition: SamRecord.cpp:1841
SamFile::ReadHeader
bool ReadHeader(SamFileHeader &header)
Reads the header section from the file and stores it in the passed in header.
Definition: SamFile.cpp:437
SamRecord::addIntTag
bool addIntTag(const char *tag, int32_t value)
Add the specified integer tag to the record.
Definition: SamRecord.cpp:635
SamFile::Close
void Close()
Close the file if there is one open.
Definition: SamFile.cpp:400
SamFile
Allows the user to easily read/write a SAM/BAM file.
Definition: SamFile.h:35
SamRecord::get1BasedAlignmentEnd
int32_t get1BasedAlignmentEnd()
Returns the 1-based inclusive rightmost position of the clipped sequence.
Definition: SamRecord.cpp:1474
SamHeaderRecord
This class encapsulates the tag value pairs contained with a SAM Header line with accessors for getti...
Definition: SamHeaderRecord.h:27
SamFileHeader::addHeaderLine
bool addHeaderLine(const char *type, const char *tag, const char *value)
Add a header line that is just one tag with a const char* value.
Definition: SamFileHeader.cpp:180
SamHeaderRecord::setTag
bool setTag(const char *tag, const char *value)
Set the value of the specified tag to the specified value, deletes the tag when value is NULL.
Definition: SamHeaderRecord.cpp:119
SamHeaderHD
Definition: SamHeaderHD.h:23
SamRecord::getMateReferenceName
const char * getMateReferenceName()
Get the mate/next fragment's reference sequence name (RNEXT).
Definition: SamRecord.cpp:1398
bamRecordStruct
Structure of a BAM record.
Definition: SamRecord.h:33
SamRecord::setQuality
bool setQuality(const char *quality)
Sets the quality (QUAL) to the specified SAM formatted quality string.
Definition: SamRecord.cpp:357
SamRecord::getNextSamTag
bool getNextSamTag(char *tag, char &vtype, void **value)
Get the next tag from the record.
Definition: SamRecord.cpp:1950
SamFileHeader::setRGTag
bool setRGTag(const char *tag, const char *value, const char *id)
Set the specified tag to the specified value in the RG header with the specified id,...
Definition: SamFileHeader.cpp:311
SamFileHeader::removeHD
bool removeHD()
Remove the HD record.
Definition: SamFileHeader.cpp:554
SamFileHeader::addComment
bool addComment(const char *comment)
Add the specified comment to the header (do not include "@CO" or "\n").
Definition: SamFileHeader.cpp:213