1 /*===========================================================================
2 *
3 * PUBLIC DOMAIN NOTICE
4 * National Center for Biotechnology Information
5 *
6 * This software/database is a "United States Government Work" under the
7 * terms of the United States Copyright Act. It was written as part of
8 * the author's official duties as a United States Government employee and
9 * thus cannot be copyrighted. This software/database is freely available
10 * to the public for use. The National Library of Medicine and the U.S.
11 * Government have not placed any restriction on its use or reproduction.
12 *
13 * Although all reasonable efforts have been taken to ensure the accuracy
14 * and reliability of the software and data, the NLM and the U.S.
15 * Government do not and cannot warrant the performance or results that
16 * may be obtained by using this software or data. The NLM and the U.S.
17 * Government disclaim all warranties, express or implied, including
18 * warranties of performance, merchantability or fitness for any particular
19 * purpose.
20 *
21 * Please cite the author in any work or product based on this material.
22 *
23 * ===========================================================================
24 *
25 */
26
27 #include "py_AlignmentItf.h"
28 #include "py_ErrorMsg.hpp"
29
30 #include <ngs/itf/AlignmentItf.hpp>
31 #include <ngs/itf/FragmentItf.hpp>
32
33 /*
34 GEN_PY_FUNC_GET_STRING_CAST ( Alignment, FragmentId, Fragment )
35 GEN_PY_FUNC_GET_STRING_BY_PARAMS_2_CAST ( Alignment, FragmentBases, Fragment, uint64_t, offset, uint64_t, length )
36 GEN_PY_FUNC_GET_STRING_BY_PARAMS_2_CAST ( Alignment, FragmentQualities, Fragment, uint64_t, offset, uint64_t, length )
37 */
38
PY_NGS_AlignmentGetAlignmentId(void * pRef,void ** pRet,void ** ppNGSStrError)39 PY_RES_TYPE PY_NGS_AlignmentGetAlignmentId ( void* pRef, void** pRet, void** ppNGSStrError )
40 {
41 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
42 try
43 {
44 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getAlignmentId ();
45 assert (pRet != NULL);
46 *pRet = (void*) res;
47 ret = PY_RES_OK;
48 }
49 catch ( ngs::ErrorMsg & x )
50 {
51 ret = ExceptionHandler ( x, ppNGSStrError );
52 }
53 catch ( std::exception & x )
54 {
55 ret = ExceptionHandler ( x, ppNGSStrError );
56 }
57 catch ( ... )
58 {
59 ret = ExceptionHandler ( ppNGSStrError );
60 }
61
62 return ret;
63 }
64
PY_NGS_AlignmentGetReferenceSpec(void * pRef,void ** pRet,void ** ppNGSStrError)65 PY_RES_TYPE PY_NGS_AlignmentGetReferenceSpec ( void* pRef, void** pRet, void** ppNGSStrError )
66 {
67 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
68 try
69 {
70 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getReferenceSpec ();
71 assert (pRet != NULL);
72 *pRet = (void*) res;
73 ret = PY_RES_OK;
74 }
75 catch ( ngs::ErrorMsg & x )
76 {
77 ret = ExceptionHandler ( x, ppNGSStrError );
78 }
79 catch ( std::exception & x )
80 {
81 ret = ExceptionHandler ( x, ppNGSStrError );
82 }
83 catch ( ... )
84 {
85 ret = ExceptionHandler ( ppNGSStrError );
86 }
87
88 return ret;
89 }
90
PY_NGS_AlignmentGetMappingQuality(void * pRef,int32_t * pRet,void ** ppNGSStrError)91 PY_RES_TYPE PY_NGS_AlignmentGetMappingQuality ( void* pRef, int32_t* pRet, void** ppNGSStrError )
92 {
93 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
94 try
95 {
96 int32_t res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getMappingQuality ();
97 assert (pRet != NULL);
98 *pRet = (int32_t) res;
99 ret = PY_RES_OK;
100 }
101 catch ( ngs::ErrorMsg & x )
102 {
103 ret = ExceptionHandler ( x, ppNGSStrError );
104 }
105 catch ( std::exception & x )
106 {
107 ret = ExceptionHandler ( x, ppNGSStrError );
108 }
109 catch ( ... )
110 {
111 ret = ExceptionHandler ( ppNGSStrError );
112 }
113
114 return ret;
115 }
116
PY_NGS_AlignmentGetReferenceBases(void * pRef,void ** pRet,void ** ppNGSStrError)117 PY_RES_TYPE PY_NGS_AlignmentGetReferenceBases ( void* pRef, void** pRet, void** ppNGSStrError )
118 {
119 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
120 try
121 {
122 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getReferenceBases ();
123 assert (pRet != NULL);
124 *pRet = (void*) res;
125 ret = PY_RES_OK;
126 }
127 catch ( ngs::ErrorMsg & x )
128 {
129 ret = ExceptionHandler ( x, ppNGSStrError );
130 }
131 catch ( std::exception & x )
132 {
133 ret = ExceptionHandler ( x, ppNGSStrError );
134 }
135 catch ( ... )
136 {
137 ret = ExceptionHandler ( ppNGSStrError );
138 }
139
140 return ret;
141 }
142
PY_NGS_AlignmentGetReadGroup(void * pRef,void ** pRet,void ** ppNGSStrError)143 PY_RES_TYPE PY_NGS_AlignmentGetReadGroup ( void* pRef, void** pRet, void** ppNGSStrError )
144 {
145 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
146 try
147 {
148 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getReadGroup ();
149 assert (pRet != NULL);
150 *pRet = (void*) res;
151 ret = PY_RES_OK;
152 }
153 catch ( ngs::ErrorMsg & x )
154 {
155 ret = ExceptionHandler ( x, ppNGSStrError );
156 }
157 catch ( std::exception & x )
158 {
159 ret = ExceptionHandler ( x, ppNGSStrError );
160 }
161 catch ( ... )
162 {
163 ret = ExceptionHandler ( ppNGSStrError );
164 }
165
166 return ret;
167 }
168
PY_NGS_AlignmentGetReadId(void * pRef,void ** pRet,void ** ppNGSStrError)169 PY_RES_TYPE PY_NGS_AlignmentGetReadId ( void* pRef, void** pRet, void** ppNGSStrError )
170 {
171 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
172 try
173 {
174 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getReadId ();
175 assert (pRet != NULL);
176 *pRet = (void*) res;
177 ret = PY_RES_OK;
178 }
179 catch ( ngs::ErrorMsg & x )
180 {
181 ret = ExceptionHandler ( x, ppNGSStrError );
182 }
183 catch ( std::exception & x )
184 {
185 ret = ExceptionHandler ( x, ppNGSStrError );
186 }
187 catch ( ... )
188 {
189 ret = ExceptionHandler ( ppNGSStrError );
190 }
191
192 return ret;
193 }
194
PY_NGS_AlignmentGetClippedFragmentBases(void * pRef,void ** pRet,void ** ppNGSStrError)195 PY_RES_TYPE PY_NGS_AlignmentGetClippedFragmentBases ( void* pRef, void** pRet, void** ppNGSStrError )
196 {
197 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
198 try
199 {
200 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getClippedFragmentBases ();
201 assert (pRet != NULL);
202 *pRet = (void*) res;
203 ret = PY_RES_OK;
204 }
205 catch ( ngs::ErrorMsg & x )
206 {
207 ret = ExceptionHandler ( x, ppNGSStrError );
208 }
209 catch ( std::exception & x )
210 {
211 ret = ExceptionHandler ( x, ppNGSStrError );
212 }
213 catch ( ... )
214 {
215 ret = ExceptionHandler ( ppNGSStrError );
216 }
217
218 return ret;
219 }
220
PY_NGS_AlignmentGetClippedFragmentQualities(void * pRef,void ** pRet,void ** ppNGSStrError)221 PY_RES_TYPE PY_NGS_AlignmentGetClippedFragmentQualities ( void* pRef, void** pRet, void** ppNGSStrError )
222 {
223 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
224 try
225 {
226 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getClippedFragmentQualities ();
227 assert (pRet != NULL);
228 *pRet = (void*) res;
229 ret = PY_RES_OK;
230 }
231 catch ( ngs::ErrorMsg & x )
232 {
233 ret = ExceptionHandler ( x, ppNGSStrError );
234 }
235 catch ( std::exception & x )
236 {
237 ret = ExceptionHandler ( x, ppNGSStrError );
238 }
239 catch ( ... )
240 {
241 ret = ExceptionHandler ( ppNGSStrError );
242 }
243
244 return ret;
245 }
246
PY_NGS_AlignmentGetAlignedFragmentBases(void * pRef,void ** pRet,void ** ppNGSStrError)247 PY_RES_TYPE PY_NGS_AlignmentGetAlignedFragmentBases ( void* pRef, void** pRet, void** ppNGSStrError )
248 {
249 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
250 try
251 {
252 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getAlignedFragmentBases ();
253 assert (pRet != NULL);
254 *pRet = (void*) res;
255 ret = PY_RES_OK;
256 }
257 catch ( ngs::ErrorMsg & x )
258 {
259 ret = ExceptionHandler ( x, ppNGSStrError );
260 }
261 catch ( std::exception & x )
262 {
263 ret = ExceptionHandler ( x, ppNGSStrError );
264 }
265 catch ( ... )
266 {
267 ret = ExceptionHandler ( ppNGSStrError );
268 }
269
270 return ret;
271 }
272
PY_NGS_AlignmentGetAlignmentCategory(void * pRef,uint32_t * pRet,void ** ppNGSStrError)273 PY_RES_TYPE PY_NGS_AlignmentGetAlignmentCategory ( void* pRef, uint32_t* pRet, void** ppNGSStrError )
274 {
275 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
276 try
277 {
278 uint32_t res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getAlignmentCategory ();
279 assert (pRet != NULL);
280 *pRet = (uint32_t) res;
281 ret = PY_RES_OK;
282 }
283 catch ( ngs::ErrorMsg & x )
284 {
285 ret = ExceptionHandler ( x, ppNGSStrError );
286 }
287 catch ( std::exception & x )
288 {
289 ret = ExceptionHandler ( x, ppNGSStrError );
290 }
291 catch ( ... )
292 {
293 ret = ExceptionHandler ( ppNGSStrError );
294 }
295
296 return ret;
297 }
298
PY_NGS_AlignmentGetAlignmentPosition(void * pRef,int64_t * pRet,void ** ppNGSStrError)299 PY_RES_TYPE PY_NGS_AlignmentGetAlignmentPosition ( void* pRef, int64_t* pRet, void** ppNGSStrError )
300 {
301 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
302 try
303 {
304 int64_t res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getAlignmentPosition ();
305 assert (pRet != NULL);
306 *pRet = (int64_t) res;
307 ret = PY_RES_OK;
308 }
309 catch ( ngs::ErrorMsg & x )
310 {
311 ret = ExceptionHandler ( x, ppNGSStrError );
312 }
313 catch ( std::exception & x )
314 {
315 ret = ExceptionHandler ( x, ppNGSStrError );
316 }
317 catch ( ... )
318 {
319 ret = ExceptionHandler ( ppNGSStrError );
320 }
321
322 return ret;
323 }
324
PY_NGS_AlignmentGetAlignmentLength(void * pRef,uint64_t * pRet,void ** ppNGSStrError)325 PY_RES_TYPE PY_NGS_AlignmentGetAlignmentLength ( void* pRef, uint64_t* pRet, void** ppNGSStrError )
326 {
327 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
328 try
329 {
330 uint64_t res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getAlignmentLength ();
331 assert (pRet != NULL);
332 *pRet = (uint64_t) res;
333 ret = PY_RES_OK;
334 }
335 catch ( ngs::ErrorMsg & x )
336 {
337 ret = ExceptionHandler ( x, ppNGSStrError );
338 }
339 catch ( std::exception & x )
340 {
341 ret = ExceptionHandler ( x, ppNGSStrError );
342 }
343 catch ( ... )
344 {
345 ret = ExceptionHandler ( ppNGSStrError );
346 }
347
348 return ret;
349 }
350
PY_NGS_AlignmentGetIsReversedOrientation(void * pRef,int * pRet,void ** ppNGSStrError)351 PY_RES_TYPE PY_NGS_AlignmentGetIsReversedOrientation ( void* pRef, int* pRet, void** ppNGSStrError )
352 {
353 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
354 try
355 {
356 bool res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getIsReversedOrientation ();
357 assert (pRet != NULL);
358 *pRet = (int) res;
359 ret = PY_RES_OK;
360 }
361 catch ( ngs::ErrorMsg & x )
362 {
363 ret = ExceptionHandler ( x, ppNGSStrError );
364 }
365 catch ( std::exception & x )
366 {
367 ret = ExceptionHandler ( x, ppNGSStrError );
368 }
369 catch ( ... )
370 {
371 ret = ExceptionHandler ( ppNGSStrError );
372 }
373
374 return ret;
375 }
376
PY_NGS_AlignmentGetSoftClip(void * pRef,uint32_t edge,int32_t * pRet,void ** ppNGSStrError)377 PY_RES_TYPE PY_NGS_AlignmentGetSoftClip ( void* pRef, uint32_t edge, int32_t* pRet, void** ppNGSStrError )
378 {
379 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
380 try
381 {
382 int32_t res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getSoftClip ( edge );
383 assert (pRet != NULL);
384 *pRet = (int32_t) res;
385 ret = PY_RES_OK;
386 }
387 catch ( ngs::ErrorMsg & x )
388 {
389 ret = ExceptionHandler ( x, ppNGSStrError );
390 }
391 catch ( std::exception & x )
392 {
393 ret = ExceptionHandler ( x, ppNGSStrError );
394 }
395 catch ( ... )
396 {
397 ret = ExceptionHandler ( ppNGSStrError );
398 }
399
400 return ret;
401 }
402
PY_NGS_AlignmentGetTemplateLength(void * pRef,uint64_t * pRet,void ** ppNGSStrError)403 PY_RES_TYPE PY_NGS_AlignmentGetTemplateLength ( void* pRef, uint64_t* pRet, void** ppNGSStrError )
404 {
405 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
406 try
407 {
408 uint64_t res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getTemplateLength ();
409 assert (pRet != NULL);
410 *pRet = (uint64_t) res;
411 ret = PY_RES_OK;
412 }
413 catch ( ngs::ErrorMsg & x )
414 {
415 ret = ExceptionHandler ( x, ppNGSStrError );
416 }
417 catch ( std::exception & x )
418 {
419 ret = ExceptionHandler ( x, ppNGSStrError );
420 }
421 catch ( ... )
422 {
423 ret = ExceptionHandler ( ppNGSStrError );
424 }
425
426 return ret;
427 }
428
PY_NGS_AlignmentGetShortCigar(void * pRef,int clipped,void ** pRet,void ** ppNGSStrError)429 PY_RES_TYPE PY_NGS_AlignmentGetShortCigar ( void* pRef, int clipped, void** pRet, void** ppNGSStrError )
430 {
431 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
432 try
433 {
434 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getShortCigar ( clipped != 0 );
435 assert (pRet != NULL);
436 *pRet = (void*) res;
437 ret = PY_RES_OK;
438 }
439 catch ( ngs::ErrorMsg & x )
440 {
441 ret = ExceptionHandler ( x, ppNGSStrError );
442 }
443 catch ( std::exception & x )
444 {
445 ret = ExceptionHandler ( x, ppNGSStrError );
446 }
447 catch ( ... )
448 {
449 ret = ExceptionHandler ( ppNGSStrError );
450 }
451
452 return ret;
453 }
454
PY_NGS_AlignmentGetLongCigar(void * pRef,int clipped,void ** pRet,void ** ppNGSStrError)455 PY_RES_TYPE PY_NGS_AlignmentGetLongCigar ( void* pRef, int clipped, void** pRet, void** ppNGSStrError )
456 {
457 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
458 try
459 {
460 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getLongCigar ( clipped != 0 );
461 assert (pRet != NULL);
462 *pRet = (void*) res;
463 ret = PY_RES_OK;
464 }
465 catch ( ngs::ErrorMsg & x )
466 {
467 ret = ExceptionHandler ( x, ppNGSStrError );
468 }
469 catch ( std::exception & x )
470 {
471 ret = ExceptionHandler ( x, ppNGSStrError );
472 }
473 catch ( ... )
474 {
475 ret = ExceptionHandler ( ppNGSStrError );
476 }
477
478 return ret;
479 }
480
PY_NGS_AlignmentGetRNAOrientation(void * pRef,char * pRet,void ** ppNGSStrError)481 PY_RES_TYPE PY_NGS_AlignmentGetRNAOrientation ( void* pRef, char* pRet, void** ppNGSStrError )
482 {
483 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
484 try
485 {
486 char res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getRNAOrientation ();
487 assert (pRet != NULL);
488 *pRet = (char) res;
489 ret = PY_RES_OK;
490 }
491 catch ( ngs::ErrorMsg & x )
492 {
493 ret = ExceptionHandler ( x, ppNGSStrError );
494 }
495 catch ( std::exception & x )
496 {
497 ret = ExceptionHandler ( x, ppNGSStrError );
498 }
499 catch ( ... )
500 {
501 ret = ExceptionHandler ( ppNGSStrError );
502 }
503
504 return ret;
505 }
506
507 //GEN_PY_FUNC_GET ( Alignment, HasMate, bool ) // TODO: decide what to do with non-standard names
PY_NGS_AlignmentHasMate(void * pRef,int * pRet,void ** ppNGSStrError)508 PY_RES_TYPE PY_NGS_AlignmentHasMate ( void* pRef, int* pRet, void** ppNGSStrError )
509 {
510 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
511 try
512 {
513 bool res = CheckedCast< ngs::AlignmentItf* >(pRef) -> hasMate ();
514 assert (pRet != NULL);
515 *pRet = (int) res;
516 ret = PY_RES_OK;
517 }
518 catch ( ngs::ErrorMsg & x )
519 {
520 ret = ExceptionHandler ( x, ppNGSStrError );
521 }
522 catch ( std::exception & x )
523 {
524 ret = ExceptionHandler ( x, ppNGSStrError );
525 }
526 catch ( ... )
527 {
528 ret = ExceptionHandler ( ppNGSStrError );
529 }
530
531 return ret;
532 }
533
PY_NGS_AlignmentGetMateAlignmentId(void * pRef,void ** pRet,void ** ppNGSStrError)534 PY_RES_TYPE PY_NGS_AlignmentGetMateAlignmentId ( void* pRef, void** pRet, void** ppNGSStrError )
535 {
536 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
537 try
538 {
539 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getMateAlignmentId ();
540 assert (pRet != NULL);
541 *pRet = (void*) res;
542 ret = PY_RES_OK;
543 }
544 catch ( ngs::ErrorMsg & x )
545 {
546 ret = ExceptionHandler ( x, ppNGSStrError );
547 }
548 catch ( std::exception & x )
549 {
550 ret = ExceptionHandler ( x, ppNGSStrError );
551 }
552 catch ( ... )
553 {
554 ret = ExceptionHandler ( ppNGSStrError );
555 }
556
557 return ret;
558 }
559
PY_NGS_AlignmentGetMateAlignment(void * pRef,void ** pRet,void ** ppNGSStrError)560 PY_RES_TYPE PY_NGS_AlignmentGetMateAlignment ( void* pRef, void** pRet, void** ppNGSStrError )
561 {
562 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
563 try
564 {
565 ngs::AlignmentItf* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getMateAlignment ();
566 assert (pRet != NULL);
567 *pRet = (void*) res;
568 ret = PY_RES_OK;
569 }
570 catch ( ngs::ErrorMsg & x )
571 {
572 ret = ExceptionHandler ( x, ppNGSStrError );
573 }
574 catch ( std::exception & x )
575 {
576 ret = ExceptionHandler ( x, ppNGSStrError );
577 }
578 catch ( ... )
579 {
580 ret = ExceptionHandler ( ppNGSStrError );
581 }
582
583 return ret;
584 }
585
PY_NGS_AlignmentGetMateReferenceSpec(void * pRef,void ** pRet,void ** ppNGSStrError)586 PY_RES_TYPE PY_NGS_AlignmentGetMateReferenceSpec ( void* pRef, void** pRet, void** ppNGSStrError )
587 {
588 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
589 try
590 {
591 void* res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getMateReferenceSpec ();
592 assert (pRet != NULL);
593 *pRet = (void*) res;
594 ret = PY_RES_OK;
595 }
596 catch ( ngs::ErrorMsg & x )
597 {
598 ret = ExceptionHandler ( x, ppNGSStrError );
599 }
600 catch ( std::exception & x )
601 {
602 ret = ExceptionHandler ( x, ppNGSStrError );
603 }
604 catch ( ... )
605 {
606 ret = ExceptionHandler ( ppNGSStrError );
607 }
608
609 return ret;
610 }
611
PY_NGS_AlignmentGetMateIsReversedOrientation(void * pRef,int * pRet,void ** ppNGSStrError)612 PY_RES_TYPE PY_NGS_AlignmentGetMateIsReversedOrientation ( void* pRef, int* pRet, void** ppNGSStrError )
613 {
614 PY_RES_TYPE ret = PY_RES_ERROR; // TODO: use xt_* codes
615 try
616 {
617 bool res = CheckedCast< ngs::AlignmentItf* >(pRef) -> getMateIsReversedOrientation ();
618 assert (pRet != NULL);
619 *pRet = (int) res;
620 ret = PY_RES_OK;
621 }
622 catch ( ngs::ErrorMsg & x )
623 {
624 ret = ExceptionHandler ( x, ppNGSStrError );
625 }
626 catch ( std::exception & x )
627 {
628 ret = ExceptionHandler ( x, ppNGSStrError );
629 }
630 catch ( ... )
631 {
632 ret = ExceptionHandler ( ppNGSStrError );
633 }
634
635 return ret;
636 }
637
638
639
640