Line data Source code
1 : #include <msvis/MSVis/VisBufferAsyncWrapper.h>
2 :
3 : #include <stdcasa/thread/AsynchronousTools.h>
4 : using namespace casacore;
5 : using namespace casa::async;
6 :
7 : #include <stdcasa/UtilJ.h>
8 : using namespace casacore;
9 : using namespace casa::utilj;
10 :
11 : #include <msvis/MSVis/AsynchronousInterface.h>
12 : #include <msvis/MSVis/VisibilityIteratorImplAsync.h>
13 : #include <msvis/MSVis/VLAT.h>
14 :
15 : #define CheckWrap() \
16 : if (wrappedVba_p == NULL){\
17 : Throw ("VisBufferAsyncWrapper: No attached VBA");\
18 : }
19 :
20 : #define Log(level, ...) \
21 : {if (casa::asyncio::AsynchronousInterface::logThis (level)) \
22 : Logger::get()->log (__VA_ARGS__);};
23 :
24 : using namespace casacore;
25 : namespace casa { //# NAMESPACE CASA - BEGIN
26 :
27 0 : VisBufferAsyncWrapper::VisBufferAsyncWrapper ()
28 : : wrappedVba_p (NULL),
29 0 : wrappedVisIterAsync_p (NULL)
30 0 : {}
31 :
32 0 : VisBufferAsyncWrapper::VisBufferAsyncWrapper (ROVisibilityIterator & iter)
33 0 : : wrappedVba_p (NULL)
34 : {
35 0 : Assert (iter.isAsynchronous ());
36 :
37 0 : attachToVisIterAsync (iter);
38 0 : }
39 :
40 0 : VisBufferAsyncWrapper::VisBufferAsyncWrapper (const VisBufferAsync & other)
41 : : wrappedVba_p (NULL),
42 0 : wrappedVisIterAsync_p (NULL)
43 : {
44 0 : wrappedVba_p = new VisBufferAsync (other);
45 0 : }
46 :
47 0 : VisBufferAsyncWrapper::~VisBufferAsyncWrapper ()
48 : {
49 0 : if (wrappedVisIterAsync_p != NULL){
50 0 : detachFromVisIter();
51 : }
52 :
53 0 : delete wrappedVba_p;
54 0 : }
55 :
56 : VisBufferAsyncWrapper &
57 0 : VisBufferAsyncWrapper::operator= (const VisBufferAsyncWrapper & other)
58 : {
59 0 : if (this != & other){
60 :
61 0 : assign (other, true);
62 : }
63 :
64 0 : return * this;
65 : }
66 :
67 : VisBufferAsyncWrapper &
68 0 : VisBufferAsyncWrapper::assign (const VisBuffer & vb, Bool copy)
69 : {
70 : // existing?
71 :
72 0 : if (wrappedVisIterAsync_p != NULL){
73 0 : detachFromVisIter ();
74 : }
75 :
76 0 : if (wrappedVba_p == NULL){
77 0 : wrappedVba_p = new VisBufferAsync ();
78 : }
79 :
80 0 : wrappedVba_p->assign (vb, copy);
81 :
82 0 : return * this;
83 : }
84 :
85 : VisBufferAsyncWrapper &
86 0 : VisBufferAsyncWrapper::operator-= (const VisBuffer & vb)
87 : {
88 0 : CheckWrap ();
89 0 : wrappedVba_p->operator-= (vb);
90 :
91 0 : return * this;
92 : }
93 :
94 : void
95 0 : VisBufferAsyncWrapper::allSelectedSpectralWindows (Vector<Int>& spws, Vector<Int>& nvischan)
96 : {
97 0 : CheckWrap ();
98 0 : wrappedVba_p->allSelectedSpectralWindows (spws, nvischan);
99 0 : }
100 :
101 : void
102 0 : VisBufferAsyncWrapper::allSelectedSpectralWindows (Vector<Int>& spws, Vector<Int>& nvischan) const
103 : {
104 0 : CheckWrap ();
105 0 : wrappedVba_p->allSelectedSpectralWindows (spws, nvischan);
106 0 : }
107 :
108 : Vector<Int>
109 0 : VisBufferAsyncWrapper::antIdRange () const
110 : {
111 0 : CheckWrap ();
112 0 : return wrappedVba_p->antIdRange ();
113 : }
114 :
115 : Vector<Int>&
116 0 : VisBufferAsyncWrapper::antenna1 ()
117 : {
118 0 : CheckWrap ();
119 0 : return wrappedVba_p->antenna1 ();
120 : }
121 :
122 : const Vector<Int>&
123 0 : VisBufferAsyncWrapper::antenna1 () const
124 : {
125 0 : CheckWrap ();
126 0 : return wrappedVba_p->antenna1 ();
127 : }
128 :
129 : Vector<Int>&
130 0 : VisBufferAsyncWrapper::antenna2 ()
131 : {
132 0 : CheckWrap ();
133 0 : return wrappedVba_p->antenna2 ();
134 : }
135 :
136 : const Vector<Int>&
137 0 : VisBufferAsyncWrapper::antenna2 () const
138 : {
139 0 : CheckWrap ();
140 0 : return wrappedVba_p->antenna2 ();
141 : }
142 :
143 : Int
144 0 : VisBufferAsyncWrapper::arrayId () const
145 : {
146 0 : CheckWrap ();
147 0 : return wrappedVba_p->arrayId ();
148 : }
149 :
150 : void
151 0 : VisBufferAsyncWrapper::attachToVisIter (ROVisibilityIterator & iter)
152 : {
153 0 : ROVisibilityIterator * rovia = dynamic_cast<ROVisibilityIterator *> (& iter);
154 :
155 0 : ThrowIf (rovia == NULL, "Attempt to attach VisBufferAsyncWraper to synchronous ROVisibilityIterator");
156 :
157 0 : attachToVisIterAsync (* rovia);
158 0 : }
159 :
160 : void
161 0 : VisBufferAsyncWrapper::attachToVisIterAsync (ROVisibilityIterator & iter)
162 : {
163 0 : Log (2, "VBAW::attachToVisIterAsync this=%08x, iter=%08x\n", this, & iter);
164 :
165 0 : iter.attachVisBuffer (*this);
166 0 : wrappedVisIterAsync_p = & iter;
167 :
168 0 : attachWrappedVb (& iter);
169 0 : }
170 :
171 : void
172 0 : VisBufferAsyncWrapper::attachWrappedVb (ROVisibilityIterator * iter)
173 : {
174 : // Attach the wrapped VBA so that it can get needed information from
175 : // the VisibilityIterator. Make connetion 1-way so that the wrapped
176 : // VB does not try to detach when destroyed.
177 :
178 0 : if (wrappedVba_p != NULL){
179 0 : wrappedVba_p->visIter_p = iter;
180 0 : wrappedVba_p->twoWayConnection_p = false;
181 : }
182 0 : }
183 :
184 :
185 :
186 : Vector<MDirection>
187 0 : VisBufferAsyncWrapper::azel (Double time) const
188 : {
189 0 : CheckWrap ();
190 0 : return wrappedVba_p->azel (time);
191 : }
192 :
193 : MDirection
194 0 : VisBufferAsyncWrapper::azel0 (Double time) const
195 : {
196 0 : CheckWrap ();
197 0 : return wrappedVba_p->azel0 (time);
198 : }
199 :
200 : Vector<Double>&
201 0 : VisBufferAsyncWrapper::azel0Vec (Double time, Vector<Double>& azelVec) const
202 : {
203 0 : CheckWrap ();
204 0 : return wrappedVba_p->azel0Vec (time, azelVec);
205 : }
206 :
207 : Matrix<Double>&
208 0 : VisBufferAsyncWrapper::azelMat (Double time, Matrix<Double>& azelMat) const
209 : {
210 0 : CheckWrap ();
211 0 : return wrappedVba_p->azelMat (time, azelMat);
212 : }
213 :
214 : template<class T> void
215 : VisBufferAsyncWrapper::chanAccCube (Cube<T>& data, Int nChanOut)
216 : {
217 : CheckWrap ();
218 : return wrappedVba_p->chanAccCube (data, nChanOut);
219 : }
220 :
221 : void
222 0 : VisBufferAsyncWrapper::chanAveFlagCube (Cube<Bool>& flagcube, const Int nChanOut,
223 : const Bool restoreWeightSpectrum)
224 : {
225 0 : CheckWrap ();
226 0 : wrappedVba_p->chanAveFlagCube (flagcube, nChanOut, restoreWeightSpectrum);
227 0 : }
228 :
229 : //template<class T>
230 : //void chanAveVisCube (Cube<T>& data, Int nChanOut)
231 : //{
232 : // CheckWrap ();
233 : // wrappedVba_p->chanAveVisCube (Cube<T>& data, Int nChanOut);
234 : //}
235 :
236 : Vector<Int>&
237 0 : VisBufferAsyncWrapper::channel ()
238 : {
239 0 : CheckWrap ();
240 0 : return wrappedVba_p->channel ();
241 : }
242 :
243 : const Vector<Int>&
244 0 : VisBufferAsyncWrapper::channel () const
245 : {
246 0 : CheckWrap ();
247 0 : return wrappedVba_p->channel ();
248 : }
249 :
250 : void
251 0 : VisBufferAsyncWrapper::channelAve (const Matrix<Int>& chanavebounds)
252 : {
253 0 : CheckWrap ();
254 0 : wrappedVba_p->channelAve (chanavebounds);
255 0 : }
256 :
257 : Bool
258 0 : VisBufferAsyncWrapper::checkMSId ()
259 : {
260 0 : CheckWrap ();
261 0 : return wrappedVba_p->checkMSId ();
262 : }
263 :
264 : void
265 0 : VisBufferAsyncWrapper::checkVisIter (const char * func, const char * file, int line) const
266 : {
267 0 : CheckWrap ();
268 0 : wrappedVba_p->checkVisIter (func, file, line);
269 0 : }
270 :
271 : VisBuffer *
272 0 : VisBufferAsyncWrapper::clone ()
273 : {
274 0 : return wrappedVba_p->clone();
275 : }
276 :
277 : Vector<SquareMatrix<Complex, 2> >&
278 0 : VisBufferAsyncWrapper::CJones ()
279 : {
280 0 : CheckWrap ();
281 0 : return wrappedVba_p->CJones ();
282 : }
283 :
284 : const Vector<SquareMatrix<Complex, 2> >&
285 0 : VisBufferAsyncWrapper::CJones () const
286 : {
287 0 : CheckWrap ();
288 0 : return wrappedVba_p->CJones ();
289 : }
290 :
291 : void
292 0 : VisBufferAsyncWrapper::copyCache (const VisBuffer & other, Bool force)
293 : {
294 0 : assert (! force);
295 :
296 0 : CheckWrap ();
297 0 : wrappedVba_p->copyCache (other, force);
298 0 : }
299 :
300 : Vector<Int>&
301 0 : VisBufferAsyncWrapper::corrType ()
302 : {
303 0 : CheckWrap ();
304 0 : return wrappedVba_p->corrType ();
305 : }
306 :
307 : const Vector<Int>&
308 0 : VisBufferAsyncWrapper::corrType () const
309 : {
310 0 : CheckWrap ();
311 0 : return wrappedVba_p->corrType ();
312 : }
313 :
314 : Cube<Complex>&
315 0 : VisBufferAsyncWrapper::correctedVisCube ()
316 : {
317 0 : CheckWrap ();
318 0 : return wrappedVba_p->correctedVisCube ();
319 : }
320 :
321 : const Cube<Complex>&
322 0 : VisBufferAsyncWrapper::correctedVisCube () const
323 : {
324 0 : CheckWrap ();
325 0 : return wrappedVba_p->correctedVisCube ();
326 : }
327 :
328 : Matrix<CStokesVector>&
329 0 : VisBufferAsyncWrapper::correctedVisibility ()
330 : {
331 0 : CheckWrap ();
332 0 : return wrappedVba_p->correctedVisibility ();
333 : }
334 :
335 : const Matrix<CStokesVector>&
336 0 : VisBufferAsyncWrapper::correctedVisibility () const
337 : {
338 0 : CheckWrap ();
339 0 : return wrappedVba_p->correctedVisibility ();
340 : }
341 :
342 : Cube<Complex>&
343 0 : VisBufferAsyncWrapper::dataCube (const MS::PredefinedColumns whichcol)
344 : {
345 0 : CheckWrap ();
346 0 : return wrappedVba_p->dataCube (whichcol);
347 : }
348 :
349 : const Cube<Complex>&
350 0 : VisBufferAsyncWrapper::dataCube (const MS::PredefinedColumns whichcol) const
351 : {
352 0 : CheckWrap ();
353 0 : return wrappedVba_p->dataCube (whichcol);
354 : }
355 :
356 : Int
357 0 : VisBufferAsyncWrapper::dataDescriptionId () const
358 : {
359 0 : CheckWrap ();
360 0 : return wrappedVba_p->dataDescriptionId ();
361 : }
362 :
363 : void
364 0 : VisBufferAsyncWrapper::detachFromVisIter ()
365 : {
366 0 : Log (2, "VBAW::detachFromVisIterAsync this=%08x, iter=%08x\n", this, wrappedVisIterAsync_p);
367 :
368 0 : if (wrappedVisIterAsync_p != NULL){
369 :
370 0 : Log (2, "VisBufferAsyncWrapper::detachFromVisIter this=%08x\n", this);
371 :
372 0 : wrappedVisIterAsync_p->detachVisBuffer(* this);
373 :
374 0 : wrappedVisIterAsync_p = NULL;
375 : }
376 0 : }
377 :
378 : Vector<MDirection>&
379 0 : VisBufferAsyncWrapper::direction1 ()
380 : {
381 0 : CheckWrap ();
382 0 : return wrappedVba_p->direction1 ();
383 : }
384 :
385 : const Vector<MDirection>&
386 0 : VisBufferAsyncWrapper::direction1 () const
387 : {
388 0 : CheckWrap ();
389 0 : return wrappedVba_p->direction1 ();
390 : }
391 :
392 : Vector<MDirection>&
393 0 : VisBufferAsyncWrapper::direction2 ()
394 : {
395 0 : CheckWrap ();
396 0 : return wrappedVba_p->direction2 ();
397 : }
398 :
399 : const Vector<MDirection>&
400 0 : VisBufferAsyncWrapper::direction2 () const
401 : {
402 0 : CheckWrap ();
403 0 : return wrappedVba_p->direction2 ();
404 : }
405 :
406 : Bool
407 0 : VisBufferAsyncWrapper::existsWeightSpectrum () const
408 : {
409 0 : CheckWrap ();
410 0 : return wrappedVba_p->existsWeightSpectrum ();
411 : }
412 :
413 : Vector<Double>&
414 0 : VisBufferAsyncWrapper::exposure ()
415 : {
416 0 : CheckWrap ();
417 0 : return wrappedVba_p->exposure ();
418 : }
419 :
420 : const Vector<Double>&
421 0 : VisBufferAsyncWrapper::exposure () const
422 : {
423 0 : CheckWrap ();
424 0 : return wrappedVba_p->exposure ();
425 : }
426 :
427 : Vector<Int>&
428 0 : VisBufferAsyncWrapper::feed1 ()
429 : {
430 0 : CheckWrap ();
431 0 : return wrappedVba_p->feed1 ();
432 : }
433 :
434 : const Vector<Int>&
435 0 : VisBufferAsyncWrapper::feed1 () const
436 : {
437 0 : CheckWrap ();
438 0 : return wrappedVba_p->feed1 ();
439 : }
440 :
441 : Vector<Float>&
442 0 : VisBufferAsyncWrapper::feed1_pa ()
443 : {
444 0 : CheckWrap ();
445 0 : return wrappedVba_p->feed1_pa ();
446 : }
447 :
448 : const Vector<Float>&
449 0 : VisBufferAsyncWrapper::feed1_pa () const
450 : {
451 0 : CheckWrap ();
452 0 : return wrappedVba_p->feed1_pa ();
453 : }
454 :
455 : Vector<Int>&
456 0 : VisBufferAsyncWrapper::feed2 ()
457 : {
458 0 : CheckWrap ();
459 0 : return wrappedVba_p->feed2 ();
460 : }
461 :
462 : const Vector<Int>&
463 0 : VisBufferAsyncWrapper::feed2 () const
464 : {
465 0 : CheckWrap ();
466 0 : return wrappedVba_p->feed2 ();
467 : }
468 :
469 : Vector<Float>&
470 0 : VisBufferAsyncWrapper::feed2_pa ()
471 : {
472 0 : CheckWrap ();
473 0 : return wrappedVba_p->feed2_pa ();
474 : }
475 :
476 : const Vector<Float>&
477 0 : VisBufferAsyncWrapper::feed2_pa () const
478 : {
479 0 : CheckWrap ();
480 0 : return wrappedVba_p->feed2_pa ();
481 : }
482 :
483 : Vector<Float>
484 0 : VisBufferAsyncWrapper::feed_pa (Double time) const
485 : {
486 0 : CheckWrap ();
487 0 : return wrappedVba_p->feed_pa (time);
488 : }
489 :
490 : Int
491 0 : VisBufferAsyncWrapper::fieldId () const
492 : {
493 0 : CheckWrap ();
494 0 : return wrappedVba_p->fieldId ();
495 : }
496 :
497 : Int
498 0 : VisBufferAsyncWrapper::polarizationId() const
499 : {
500 0 : CheckWrap ();
501 0 : return wrappedVba_p->polarizationId ();
502 : }
503 :
504 :
505 :
506 : // Fill Routines
507 :
508 : Vector<Int>&
509 0 : VisBufferAsyncWrapper::fillAnt1 ()
510 : {
511 0 : CheckWrap ();
512 0 : return wrappedVba_p->fillAnt1 ();
513 : }
514 :
515 : Vector<Int>&
516 0 : VisBufferAsyncWrapper::fillAnt2 ()
517 : {
518 0 : CheckWrap ();
519 0 : return wrappedVba_p->fillAnt2 ();
520 : }
521 :
522 : Int &
523 0 : VisBufferAsyncWrapper::fillArrayId ()
524 : {
525 0 : CheckWrap ();
526 0 : return wrappedVba_p->fillArrayId ();
527 : }
528 :
529 : //Matrix<Int>&
530 : //VisBufferAsyncWrapper::fillChanAveBounds ()
531 : //{
532 : // CheckWrap ();
533 : // return wrappedVba_p->fillChanAveBounds ();
534 : //}
535 :
536 : Vector<Int>&
537 0 : VisBufferAsyncWrapper::fillChannel ()
538 : {
539 0 : CheckWrap ();
540 0 : return wrappedVba_p->fillChannel ();
541 : }
542 :
543 : Vector<SquareMatrix<Complex, 2> >&
544 0 : VisBufferAsyncWrapper::fillCjones ()
545 : {
546 0 : CheckWrap ();
547 0 : return wrappedVba_p->fillCjones ();
548 : }
549 :
550 : Vector<Int>&
551 0 : VisBufferAsyncWrapper::fillCorrType ()
552 : {
553 0 : CheckWrap ();
554 0 : return wrappedVba_p->fillCorrType ();
555 : }
556 :
557 : Vector<MDirection>&
558 0 : VisBufferAsyncWrapper::fillDirection1 ()
559 : {
560 0 : CheckWrap ();
561 0 : return wrappedVba_p->fillDirection1 ();
562 : }
563 :
564 : Vector<MDirection>&
565 0 : VisBufferAsyncWrapper::fillDirection2 ()
566 : {
567 0 : CheckWrap ();
568 0 : return wrappedVba_p->fillDirection2 ();
569 : }
570 :
571 : Vector<Double>&
572 0 : VisBufferAsyncWrapper::fillExposure ()
573 : {
574 0 : CheckWrap ();
575 0 : return wrappedVba_p->fillExposure ();
576 : }
577 :
578 : Vector<Int>&
579 0 : VisBufferAsyncWrapper::fillFeed1 ()
580 : {
581 0 : CheckWrap ();
582 0 : return wrappedVba_p->fillFeed1 ();
583 : }
584 :
585 : Vector<Float>&
586 0 : VisBufferAsyncWrapper::fillFeed1_pa ()
587 : {
588 0 : CheckWrap ();
589 0 : return wrappedVba_p->fillFeed1_pa ();
590 : }
591 :
592 : Vector<Int>&
593 0 : VisBufferAsyncWrapper::fillFeed2 ()
594 : {
595 0 : CheckWrap ();
596 0 : return wrappedVba_p->fillFeed2 ();
597 : }
598 :
599 : Vector<Float>&
600 0 : VisBufferAsyncWrapper::fillFeed2_pa ()
601 : {
602 0 : CheckWrap ();
603 0 : return wrappedVba_p->fillFeed2_pa ();
604 : }
605 :
606 : Int &
607 0 : VisBufferAsyncWrapper::fillFieldId ()
608 : {
609 0 : CheckWrap ();
610 0 : return wrappedVba_p->fillFieldId ();
611 : }
612 :
613 : Matrix<Bool>&
614 0 : VisBufferAsyncWrapper::fillFlag ()
615 : {
616 0 : CheckWrap ();
617 0 : return wrappedVba_p->fillFlag ();
618 : }
619 :
620 : Array<Bool>&
621 0 : VisBufferAsyncWrapper::fillFlagCategory ()
622 : {
623 0 : CheckWrap ();
624 0 : return wrappedVba_p->fillFlagCategory ();
625 : }
626 :
627 : Cube<Bool>&
628 0 : VisBufferAsyncWrapper::fillFlagCube ()
629 : {
630 0 : CheckWrap ();
631 0 : return wrappedVba_p->fillFlagCube ();
632 : }
633 :
634 : Vector<Bool> &
635 0 : VisBufferAsyncWrapper::fillFlagRow ()
636 : {
637 0 : CheckWrap ();
638 0 : return wrappedVba_p->fillFlagRow ();
639 : }
640 :
641 : Cube<Float>&
642 0 : VisBufferAsyncWrapper::fillFloatDataCube ()
643 : {
644 0 : CheckWrap ();
645 0 : return wrappedVba_p->fillFloatDataCube ();
646 : }
647 :
648 : Vector<Double>&
649 0 : VisBufferAsyncWrapper::fillFreq ()
650 : {
651 0 : CheckWrap ();
652 0 : return wrappedVba_p->fillFreq ();
653 : }
654 :
655 : //Matrix<Float>&
656 : //VisBufferAsyncWrapper::fillImagingWeight ()
657 : //{
658 : // CheckWrap ();
659 : // return wrappedVba_p->fillImagingWeight ();
660 : //}
661 :
662 : //Vector<Double>&
663 : //VisBufferAsyncWrapper::fillLSRFreq ()
664 : //{
665 : // CheckWrap ();
666 : // return wrappedVba_p->fillLSRFreq ();
667 : //}
668 :
669 : Int &
670 0 : VisBufferAsyncWrapper::fillnChannel ()
671 : {
672 0 : CheckWrap ();
673 0 : return wrappedVba_p->fillnChannel ();
674 : }
675 :
676 : Int &
677 0 : VisBufferAsyncWrapper::fillnCorr ()
678 : {
679 0 : CheckWrap ();
680 0 : return wrappedVba_p->fillnCorr ();
681 : }
682 :
683 : Int &
684 0 : VisBufferAsyncWrapper::fillnRow ()
685 : {
686 0 : CheckWrap ();
687 0 : return wrappedVba_p->fillnRow ();
688 : }
689 :
690 : Vector<Int> &
691 0 : VisBufferAsyncWrapper::fillObservationId ()
692 : {
693 0 : CheckWrap ();
694 0 : return wrappedVba_p->fillObservationId ();
695 : }
696 :
697 : MDirection &
698 0 : VisBufferAsyncWrapper::fillPhaseCenter ()
699 : {
700 0 : CheckWrap ();
701 0 : return wrappedVba_p->fillPhaseCenter ();
702 : }
703 :
704 : Int &
705 0 : VisBufferAsyncWrapper::fillPolFrame ()
706 : {
707 0 : CheckWrap ();
708 0 : return wrappedVba_p->fillPolFrame ();
709 : }
710 :
711 : Vector<Int> &
712 0 : VisBufferAsyncWrapper::fillProcessorId ()
713 : {
714 0 : CheckWrap ();
715 0 : return wrappedVba_p->fillProcessorId ();
716 : }
717 :
718 : Vector<Int> &
719 0 : VisBufferAsyncWrapper::fillScan ()
720 : {
721 0 : CheckWrap ();
722 0 : return wrappedVba_p->fillScan ();
723 : }
724 :
725 : Vector<Float>&
726 0 : VisBufferAsyncWrapper::fillSigma ()
727 : {
728 0 : CheckWrap ();
729 0 : return wrappedVba_p->fillSigma ();
730 : }
731 :
732 : Matrix<Float>&
733 0 : VisBufferAsyncWrapper::fillSigmaMat ()
734 : {
735 0 : CheckWrap ();
736 0 : return wrappedVba_p->fillSigmaMat ();
737 : }
738 :
739 : Int &
740 0 : VisBufferAsyncWrapper::fillSpW ()
741 : {
742 0 : CheckWrap ();
743 0 : return wrappedVba_p->fillSpW ();
744 : }
745 :
746 : Vector<Int> &
747 0 : VisBufferAsyncWrapper::fillStateId ()
748 : {
749 0 : CheckWrap ();
750 0 : return wrappedVba_p->fillStateId ();
751 : }
752 :
753 : Vector<Double>&
754 0 : VisBufferAsyncWrapper::fillTime ()
755 : {
756 0 : CheckWrap ();
757 0 : return wrappedVba_p->fillTime ();
758 : }
759 :
760 : Vector<Double>&
761 0 : VisBufferAsyncWrapper::fillTimeCentroid ()
762 : {
763 0 : CheckWrap ();
764 0 : return wrappedVba_p->fillTimeCentroid ();
765 : }
766 :
767 : Vector<Double>&
768 0 : VisBufferAsyncWrapper::fillTimeInterval ()
769 : {
770 0 : CheckWrap ();
771 0 : return wrappedVba_p->fillTimeInterval ();
772 : }
773 :
774 : Vector<RigidVector<Double, 3> >&
775 0 : VisBufferAsyncWrapper::filluvw ()
776 : {
777 0 : CheckWrap ();
778 0 : return wrappedVba_p->filluvw ();
779 : }
780 :
781 : Matrix<Double>&
782 0 : VisBufferAsyncWrapper::filluvwMat ()
783 : {
784 0 : CheckWrap ();
785 0 : return wrappedVba_p->filluvwMat ();
786 : }
787 :
788 : Matrix<CStokesVector>&
789 0 : VisBufferAsyncWrapper::fillVis (VisibilityIterator::DataColumn whichOne)
790 : {
791 0 : CheckWrap ();
792 0 : return wrappedVba_p->fillVis (whichOne);
793 : }
794 :
795 : Cube<Complex>&
796 0 : VisBufferAsyncWrapper::fillVisCube (VisibilityIterator::DataColumn whichOne)
797 : {
798 0 : CheckWrap ();
799 0 : return wrappedVba_p->fillVisCube (whichOne);
800 : }
801 :
802 : Vector<Float>&
803 0 : VisBufferAsyncWrapper::fillWeight ()
804 : {
805 0 : CheckWrap ();
806 0 : return wrappedVba_p->fillWeight ();
807 : }
808 :
809 : Matrix<Float>&
810 0 : VisBufferAsyncWrapper::fillWeightMat ()
811 : {
812 0 : CheckWrap ();
813 0 : return wrappedVba_p->fillWeightMat ();
814 : }
815 :
816 : Cube<Float>&
817 0 : VisBufferAsyncWrapper::fillWeightSpectrum ()
818 : {
819 0 : CheckWrap ();
820 0 : return wrappedVba_p->fillWeightSpectrum ();
821 : }
822 :
823 :
824 : Matrix<Bool>&
825 0 : VisBufferAsyncWrapper::flag ()
826 : {
827 0 : CheckWrap ();
828 0 : return wrappedVba_p->flag ();
829 : }
830 :
831 : const Matrix<Bool>&
832 0 : VisBufferAsyncWrapper::flag () const
833 : {
834 0 : CheckWrap ();
835 0 : return wrappedVba_p->flag ();
836 : }
837 :
838 : Array<Bool>&
839 0 : VisBufferAsyncWrapper::flagCategory ()
840 : {
841 0 : CheckWrap ();
842 0 : return wrappedVba_p->flagCategory ();
843 : }
844 :
845 : const Array<Bool>&
846 0 : VisBufferAsyncWrapper::flagCategory () const
847 : {
848 0 : CheckWrap ();
849 0 : return wrappedVba_p->flagCategory ();
850 : }
851 :
852 : Cube<Bool>&
853 0 : VisBufferAsyncWrapper::flagCube ()
854 : {
855 0 : CheckWrap ();
856 0 : return wrappedVba_p->flagCube ();
857 : }
858 :
859 : const Cube<Bool>&
860 0 : VisBufferAsyncWrapper::flagCube () const
861 : {
862 0 : CheckWrap ();
863 0 : return wrappedVba_p->flagCube ();
864 : }
865 :
866 : Vector<Bool>&
867 0 : VisBufferAsyncWrapper::flagRow ()
868 : {
869 0 : CheckWrap ();
870 0 : return wrappedVba_p->flagRow ();
871 : }
872 :
873 : const Vector<Bool>&
874 0 : VisBufferAsyncWrapper::flagRow () const
875 : {
876 0 : CheckWrap ();
877 0 : return wrappedVba_p->flagRow ();
878 : }
879 :
880 : Cube<Float>&
881 0 : VisBufferAsyncWrapper::floatDataCube ()
882 : {
883 0 : CheckWrap ();
884 0 : return wrappedVba_p->floatDataCube ();
885 : }
886 :
887 : const Cube<Float>&
888 0 : VisBufferAsyncWrapper::floatDataCube () const
889 : {
890 0 : CheckWrap ();
891 0 : return wrappedVba_p->floatDataCube ();
892 : }
893 :
894 : void
895 0 : VisBufferAsyncWrapper::formStokes ()
896 : {
897 0 : CheckWrap ();
898 0 : wrappedVba_p->formStokes ();
899 0 : }
900 :
901 : void
902 0 : VisBufferAsyncWrapper::formStokes (Cube<Complex>& vis)
903 : {
904 0 : CheckWrap ();
905 0 : wrappedVba_p->formStokes (vis);
906 0 : }
907 :
908 : void
909 0 : VisBufferAsyncWrapper::formStokes (Cube<Float>& fcube)
910 : {
911 0 : CheckWrap ();
912 0 : wrappedVba_p->formStokes (fcube);
913 0 : }
914 :
915 : void
916 0 : VisBufferAsyncWrapper::formStokesWeightandFlag ()
917 : {
918 0 : CheckWrap ();
919 0 : wrappedVba_p->formStokesWeightandFlag ();
920 0 : }
921 :
922 : void
923 0 : VisBufferAsyncWrapper::freqAveCubes ()
924 : {
925 0 : CheckWrap ();
926 0 : wrappedVba_p->freqAveCubes ();
927 0 : }
928 :
929 : void
930 0 : VisBufferAsyncWrapper::freqAverage ()
931 : {
932 0 : CheckWrap ();
933 0 : wrappedVba_p->freqAverage ();
934 0 : }
935 :
936 : Vector<Double>&
937 0 : VisBufferAsyncWrapper::frequency ()
938 : {
939 0 : CheckWrap ();
940 0 : return wrappedVba_p->frequency ();
941 : }
942 :
943 : const Vector<Double>&
944 0 : VisBufferAsyncWrapper::frequency () const
945 : {
946 0 : CheckWrap ();
947 0 : return wrappedVba_p->frequency ();
948 : }
949 :
950 : const VisImagingWeight &
951 0 : VisBufferAsyncWrapper::getImagingWeightGenerator () const
952 : {
953 0 : return wrappedVisIterAsync_p->getImagingWeightGenerator();
954 : }
955 :
956 : Int
957 0 : VisBufferAsyncWrapper::getOldMsId () const
958 : {
959 0 : return wrappedVba_p->oldMSId_p;
960 : }
961 :
962 :
963 : ROVisibilityIterator *
964 0 : VisBufferAsyncWrapper::getVisibilityIterator () const
965 : {
966 0 : return wrappedVisIterAsync_p;
967 : }
968 :
969 :
970 : Double
971 0 : VisBufferAsyncWrapper::hourang (Double time) const
972 : {
973 0 : CheckWrap ();
974 0 : return wrappedVba_p->hourang (time);
975 : }
976 :
977 : Matrix<Float>&
978 0 : VisBufferAsyncWrapper::imagingWeight ()
979 : {
980 0 : CheckWrap ();
981 0 : static_cast <const VisBufferAsyncWrapper *> (this)->imagingWeight ();
982 :
983 0 : return wrappedVba_p->imagingWeight_p;
984 : }
985 :
986 : const Matrix<Float>&
987 0 : VisBufferAsyncWrapper::imagingWeight () const
988 : {
989 0 : CheckWrap ();
990 0 : Assert (wrappedVisIterAsync_p != NULL);
991 :
992 0 : const VisImagingWeight & weightGenerator (wrappedVisIterAsync_p->getImagingWeightGenerator());
993 :
994 0 : return wrappedVba_p->imagingWeight (weightGenerator);
995 : }
996 :
997 :
998 : void
999 0 : VisBufferAsyncWrapper::invalidate ()
1000 : {
1001 0 : CheckWrap ();
1002 0 : wrappedVba_p->invalidate ();
1003 0 : }
1004 :
1005 : //Vector<Double>&
1006 : //VisBufferAsyncWrapper::lsrFrequency ()
1007 : //{
1008 : // CheckWrap ();
1009 : // return wrappedVba_p->lsrFrequency ();
1010 : //}
1011 : //
1012 : //const Vector<Double>&
1013 : //VisBufferAsyncWrapper::lsrFrequency () const
1014 : //{
1015 : // CheckWrap ();
1016 : // return wrappedVba_p->lsrFrequency ();
1017 : //}
1018 :
1019 : void
1020 0 : VisBufferAsyncWrapper::lsrFrequency (const Int & spw, Vector<Double>& freq, Bool & convert) const
1021 : {
1022 0 : CheckWrap ();
1023 0 : wrappedVba_p->lsrFrequency (spw, freq, convert);
1024 0 : }
1025 :
1026 : Cube<Complex>&
1027 0 : VisBufferAsyncWrapper::modelVisCube ()
1028 : {
1029 0 : CheckWrap ();
1030 0 : return wrappedVba_p->modelVisCube ();
1031 : }
1032 :
1033 : Cube<Complex>&
1034 0 : VisBufferAsyncWrapper::modelVisCube (const Bool & matchVisCubeShape)
1035 : {
1036 0 : CheckWrap ();
1037 0 : return wrappedVba_p->modelVisCube (matchVisCubeShape);
1038 : }
1039 :
1040 : const Cube<Complex>&
1041 0 : VisBufferAsyncWrapper::modelVisCube () const
1042 : {
1043 0 : CheckWrap ();
1044 0 : return wrappedVba_p->modelVisCube ();
1045 : }
1046 :
1047 : Matrix<CStokesVector>&
1048 0 : VisBufferAsyncWrapper::modelVisibility ()
1049 : {
1050 0 : CheckWrap ();
1051 0 : return wrappedVba_p->modelVisibility ();
1052 : }
1053 :
1054 : const Matrix<CStokesVector>&
1055 0 : VisBufferAsyncWrapper::modelVisibility () const
1056 : {
1057 0 : CheckWrap ();
1058 0 : return wrappedVba_p->modelVisibility ();
1059 : }
1060 :
1061 : const MSColumns &
1062 0 : VisBufferAsyncWrapper::msColumns () const
1063 : {
1064 0 : CheckWrap ();
1065 0 : return wrappedVba_p->msColumns ();
1066 : }
1067 :
1068 : Int
1069 0 : VisBufferAsyncWrapper::msId () const
1070 : {
1071 0 : CheckWrap ();
1072 0 : return wrappedVba_p->msId ();
1073 : }
1074 :
1075 : Int &
1076 0 : VisBufferAsyncWrapper::nChannel ()
1077 : {
1078 0 : CheckWrap ();
1079 0 : return wrappedVba_p->nChannel ();
1080 : }
1081 :
1082 : Int
1083 0 : VisBufferAsyncWrapper::nChannel () const
1084 : {
1085 0 : CheckWrap ();
1086 0 : return wrappedVba_p->nChannel ();
1087 : }
1088 :
1089 : Int &
1090 0 : VisBufferAsyncWrapper::nCorr ()
1091 : {
1092 0 : CheckWrap ();
1093 0 : return wrappedVba_p->nCorr ();
1094 : }
1095 :
1096 : Int
1097 0 : VisBufferAsyncWrapper::nCorr () const
1098 : {
1099 0 : CheckWrap ();
1100 0 : return wrappedVba_p->nCorr ();
1101 : }
1102 :
1103 : Bool
1104 0 : VisBufferAsyncWrapper::newArrayId () const
1105 : {
1106 0 : CheckWrap ();
1107 0 : return wrappedVba_p->newArrayId ();
1108 : }
1109 :
1110 : Bool
1111 0 : VisBufferAsyncWrapper::newFieldId () const
1112 : {
1113 0 : CheckWrap ();
1114 0 : return wrappedVba_p->newArrayId ();
1115 : }
1116 :
1117 : Bool
1118 0 : VisBufferAsyncWrapper::newSpectralWindow () const
1119 : {
1120 0 : CheckWrap ();
1121 0 : return wrappedVba_p->newArrayId ();
1122 : }
1123 :
1124 : Int &
1125 0 : VisBufferAsyncWrapper::nRow ()
1126 : {
1127 0 : CheckWrap ();
1128 0 : return wrappedVba_p->nRow ();
1129 : }
1130 :
1131 : Int
1132 0 : VisBufferAsyncWrapper::nRow () const
1133 : {
1134 0 : CheckWrap ();
1135 0 : return wrappedVba_p->nRow ();
1136 : }
1137 :
1138 : Bool
1139 0 : VisBufferAsyncWrapper::newMS () const
1140 : {
1141 0 : CheckWrap ();
1142 0 : return wrappedVba_p->newMS ();
1143 : }
1144 :
1145 : Bool
1146 0 : VisBufferAsyncWrapper::nonCanonCorr ()
1147 : {
1148 0 : CheckWrap ();
1149 0 : return wrappedVba_p->nonCanonCorr ();
1150 : }
1151 :
1152 : void
1153 0 : VisBufferAsyncWrapper::normalize (const Bool & phaseOnly)
1154 : {
1155 0 : CheckWrap ();
1156 0 : wrappedVba_p->normalize (phaseOnly);
1157 0 : }
1158 :
1159 : Int
1160 0 : VisBufferAsyncWrapper::numberAnt () const
1161 : {
1162 0 : CheckWrap ();
1163 0 : return wrappedVba_p->numberAnt ();
1164 : }
1165 :
1166 : Int
1167 0 : VisBufferAsyncWrapper::numberCoh () const
1168 : {
1169 0 : CheckWrap ();
1170 0 : return wrappedVba_p->numberCoh ();
1171 : }
1172 :
1173 : Vector<Int>&
1174 0 : VisBufferAsyncWrapper::observationId ()
1175 : {
1176 0 : CheckWrap ();
1177 0 : return wrappedVba_p->observationId ();
1178 : }
1179 :
1180 : const Vector<Int>&
1181 0 : VisBufferAsyncWrapper::observationId () const
1182 : {
1183 0 : CheckWrap ();
1184 0 : return wrappedVba_p->observationId ();
1185 : }
1186 :
1187 : Vector<Float>
1188 0 : VisBufferAsyncWrapper::parang (Double time) const
1189 : {
1190 0 : CheckWrap ();
1191 0 : return wrappedVba_p->parang (time);
1192 : }
1193 :
1194 : Float
1195 0 : VisBufferAsyncWrapper::parang0 (Double time) const
1196 : {
1197 0 : CheckWrap ();
1198 0 : return wrappedVba_p->parang0 (time);
1199 : }
1200 :
1201 : MDirection &
1202 0 : VisBufferAsyncWrapper::phaseCenter ()
1203 : {
1204 0 : CheckWrap ();
1205 0 : return wrappedVba_p->phaseCenter ();
1206 : }
1207 :
1208 : MDirection
1209 0 : VisBufferAsyncWrapper::phaseCenter () const
1210 : {
1211 0 : CheckWrap ();
1212 0 : return wrappedVba_p->phaseCenter ();
1213 : }
1214 :
1215 : void
1216 0 : VisBufferAsyncWrapper::phaseCenterShift (Double dx, Double dy)
1217 : {
1218 0 : CheckWrap ();
1219 0 : wrappedVba_p->phaseCenterShift (dx, dy);
1220 0 : }
1221 :
1222 : Int
1223 0 : VisBufferAsyncWrapper::polFrame () const
1224 : {
1225 0 : CheckWrap ();
1226 0 : return wrappedVba_p->polFrame ();
1227 : }
1228 :
1229 : Vector<Int>&
1230 0 : VisBufferAsyncWrapper::processorId ()
1231 : {
1232 0 : CheckWrap ();
1233 0 : return wrappedVba_p->processorId ();
1234 : }
1235 :
1236 : const Vector<Int>&
1237 0 : VisBufferAsyncWrapper::processorId () const
1238 : {
1239 0 : CheckWrap ();
1240 0 : return wrappedVba_p->processorId ();
1241 : }
1242 :
1243 : void
1244 0 : VisBufferAsyncWrapper::refModelVis (const Matrix<CStokesVector>& mvis)
1245 : {
1246 0 : CheckWrap ();
1247 0 : wrappedVba_p->refModelVis (mvis);
1248 0 : }
1249 :
1250 : VisBufferAsync *
1251 0 : VisBufferAsyncWrapper::releaseVba ()
1252 : {
1253 0 : VisBufferAsync * vba = wrappedVba_p;
1254 0 : wrappedVba_p = NULL;
1255 0 : return vba;
1256 : }
1257 :
1258 :
1259 : void
1260 0 : VisBufferAsyncWrapper::removeScratchCols ()
1261 : {
1262 0 : CheckWrap ();
1263 0 : wrappedVba_p->removeScratchCols ();
1264 0 : }
1265 :
1266 : void
1267 0 : VisBufferAsyncWrapper::resetWeightMat ()
1268 : {
1269 0 : CheckWrap ();
1270 0 : wrappedVba_p->resetWeightMat ();
1271 0 : }
1272 :
1273 : Vector<rownr_t>&
1274 0 : VisBufferAsyncWrapper::rowIds ()
1275 : {
1276 0 : CheckWrap ();
1277 0 : return wrappedVba_p->rowIds ();
1278 : }
1279 :
1280 : const Vector<rownr_t>&
1281 0 : VisBufferAsyncWrapper::rowIds () const
1282 : {
1283 0 : CheckWrap ();
1284 0 : return wrappedVba_p->rowIds ();
1285 : }
1286 :
1287 : Vector<Int>&
1288 0 : VisBufferAsyncWrapper::scan ()
1289 : {
1290 0 : CheckWrap ();
1291 0 : return wrappedVba_p->scan ();
1292 : }
1293 :
1294 : const Vector<Int>&
1295 0 : VisBufferAsyncWrapper::scan () const
1296 : {
1297 0 : CheckWrap ();
1298 0 : return wrappedVba_p->scan ();
1299 : }
1300 :
1301 : Int
1302 0 : VisBufferAsyncWrapper::scan0 ()
1303 : {
1304 0 : CheckWrap ();
1305 0 : return wrappedVba_p->scan0 ();
1306 : }
1307 :
1308 : void
1309 0 : VisBufferAsyncWrapper::setAllCacheStatuses (bool status)
1310 : {
1311 0 : CheckWrap ();
1312 0 : wrappedVba_p->setAllCacheStatuses (status);
1313 0 : }
1314 :
1315 : void
1316 0 : VisBufferAsyncWrapper::setCorrectedVisCube (Complex c)
1317 : {
1318 0 : CheckWrap ();
1319 0 : wrappedVba_p->setCorrectedVisCube (c);
1320 0 : }
1321 :
1322 : void
1323 0 : VisBufferAsyncWrapper::setCorrectedVisCube (const Cube<Complex> & vis)
1324 : {
1325 0 : CheckWrap ();
1326 0 : wrappedVba_p->setCorrectedVisCube (vis);
1327 0 : }
1328 :
1329 : void
1330 0 : VisBufferAsyncWrapper::setFloatDataCube (const Cube<Float> & fcube)
1331 : {
1332 0 : CheckWrap ();
1333 0 : wrappedVba_p->setFloatDataCube (fcube);
1334 0 : }
1335 :
1336 : void
1337 0 : VisBufferAsyncWrapper::setModelVisCube (Complex c)
1338 : {
1339 0 : CheckWrap ();
1340 0 : wrappedVba_p->setModelVisCube (c);
1341 0 : }
1342 :
1343 : void
1344 0 : VisBufferAsyncWrapper::setModelVisCube (const Cube<Complex> & vis)
1345 : {
1346 0 : CheckWrap ();
1347 0 : wrappedVba_p->setModelVisCube (vis);
1348 0 : }
1349 :
1350 : void
1351 0 : VisBufferAsyncWrapper::setModelVisCube (const Vector<Float> & stokes)
1352 : {
1353 0 : CheckWrap ();
1354 0 : wrappedVba_p->setModelVisCube (stokes);
1355 0 : }
1356 :
1357 : void
1358 0 : VisBufferAsyncWrapper::setVisCube (Complex c)
1359 : {
1360 0 : CheckWrap ();
1361 0 : wrappedVba_p->setVisCube (c);
1362 0 : }
1363 :
1364 : void
1365 0 : VisBufferAsyncWrapper::setVisCube (const Cube<Complex>& vis)
1366 : {
1367 0 : CheckWrap ();
1368 0 : wrappedVba_p->setVisCube (vis);
1369 0 : }
1370 :
1371 : Vector<Float>&
1372 0 : VisBufferAsyncWrapper::sigma ()
1373 : {
1374 0 : CheckWrap ();
1375 0 : return wrappedVba_p->sigma ();
1376 : }
1377 :
1378 : const Vector<Float>&
1379 0 : VisBufferAsyncWrapper::sigma () const
1380 : {
1381 0 : CheckWrap ();
1382 0 : return wrappedVba_p->sigma ();
1383 : }
1384 :
1385 : Matrix<Float>&
1386 0 : VisBufferAsyncWrapper::sigmaMat ()
1387 : {
1388 0 : CheckWrap ();
1389 0 : return wrappedVba_p->sigmaMat ();
1390 : }
1391 :
1392 : const Matrix<Float>&
1393 0 : VisBufferAsyncWrapper::sigmaMat () const
1394 : {
1395 0 : CheckWrap ();
1396 0 : return wrappedVba_p->sigmaMat ();
1397 : }
1398 :
1399 : void
1400 0 : VisBufferAsyncWrapper::sortCorr ()
1401 : {
1402 0 : CheckWrap ();
1403 0 : wrappedVba_p->sortCorr ();
1404 0 : }
1405 :
1406 : Int &
1407 0 : VisBufferAsyncWrapper::spectralWindow ()
1408 : {
1409 0 : CheckWrap ();
1410 0 : return wrappedVba_p->spectralWindow ();
1411 : }
1412 :
1413 : Int
1414 0 : VisBufferAsyncWrapper::spectralWindow () const
1415 : {
1416 0 : CheckWrap ();
1417 0 : return wrappedVba_p->spectralWindow ();
1418 : }
1419 :
1420 : Vector<Int>&
1421 0 : VisBufferAsyncWrapper::stateId ()
1422 : {
1423 0 : CheckWrap ();
1424 0 : return wrappedVba_p->stateId ();
1425 : }
1426 :
1427 : const Vector<Int>&
1428 0 : VisBufferAsyncWrapper::stateId () const
1429 : {
1430 0 : CheckWrap ();
1431 0 : return wrappedVba_p->stateId ();
1432 : }
1433 :
1434 : Vector<Double>&
1435 0 : VisBufferAsyncWrapper::time ()
1436 : {
1437 0 : CheckWrap ();
1438 0 : return wrappedVba_p->time ();
1439 : }
1440 :
1441 : const Vector<Double>&
1442 0 : VisBufferAsyncWrapper::time () const
1443 : {
1444 0 : CheckWrap ();
1445 0 : return wrappedVba_p->time ();
1446 : }
1447 :
1448 : Vector<Double>&
1449 0 : VisBufferAsyncWrapper::timeCentroid ()
1450 : {
1451 0 : CheckWrap ();
1452 0 : return wrappedVba_p->timeCentroid ();
1453 : }
1454 :
1455 : const Vector<Double>&
1456 0 : VisBufferAsyncWrapper::timeCentroid () const
1457 : {
1458 0 : CheckWrap ();
1459 0 : return wrappedVba_p->timeCentroid ();
1460 : }
1461 :
1462 : Vector<Double>&
1463 0 : VisBufferAsyncWrapper::timeInterval ()
1464 : {
1465 0 : CheckWrap ();
1466 0 : return wrappedVba_p->timeInterval ();
1467 : }
1468 :
1469 : const Vector<Double>&
1470 0 : VisBufferAsyncWrapper::timeInterval () const
1471 : {
1472 0 : CheckWrap ();
1473 0 : return wrappedVba_p->timeInterval ();
1474 : }
1475 :
1476 : Bool
1477 0 : VisBufferAsyncWrapper::timeRange (MEpoch & rTime, MVEpoch & rTimeEP, MVEpoch & rInterval) const
1478 : {
1479 0 : CheckWrap ();
1480 0 : return wrappedVba_p->timeRange (rTime, rTimeEP, rInterval);
1481 : }
1482 :
1483 : void
1484 0 : VisBufferAsyncWrapper::unSortCorr ()
1485 : {
1486 0 : CheckWrap ();
1487 0 : wrappedVba_p->unSortCorr ();
1488 0 : }
1489 :
1490 : Vector<Int>
1491 0 : VisBufferAsyncWrapper::unique (const Vector<Int>& indices) const
1492 : {
1493 0 : CheckWrap ();
1494 0 : return wrappedVba_p->unique (indices);
1495 : }
1496 :
1497 : void
1498 0 : VisBufferAsyncWrapper::updateCoordInfo (const VisBuffer * vb)
1499 : {
1500 0 : CheckWrap ();
1501 0 : wrappedVba_p->updateCoordInfo (vb);
1502 0 : }
1503 :
1504 : Vector<RigidVector<Double, 3> >&
1505 0 : VisBufferAsyncWrapper::uvw ()
1506 : {
1507 0 : CheckWrap ();
1508 0 : return wrappedVba_p->uvw ();
1509 : }
1510 :
1511 : const Vector<RigidVector<Double, 3> >&
1512 0 : VisBufferAsyncWrapper::uvw () const
1513 : {
1514 0 : CheckWrap ();
1515 0 : return wrappedVba_p->uvw ();
1516 : }
1517 :
1518 : Matrix<Double>&
1519 0 : VisBufferAsyncWrapper::uvwMat ()
1520 : {
1521 0 : CheckWrap ();
1522 0 : return wrappedVba_p->uvwMat ();
1523 : }
1524 :
1525 : const Matrix<Double>&
1526 0 : VisBufferAsyncWrapper::uvwMat () const
1527 : {
1528 0 : CheckWrap ();
1529 0 : return wrappedVba_p->uvwMat ();
1530 : }
1531 :
1532 : void
1533 0 : VisBufferAsyncWrapper::validate ()
1534 : {
1535 0 : CheckWrap ();
1536 0 : wrappedVba_p->validate ();
1537 0 : }
1538 :
1539 : Vector<Int>
1540 0 : VisBufferAsyncWrapper::vecIntRange (const MSCalEnums::colDef & calEnum) const
1541 : {
1542 0 : CheckWrap ();
1543 0 : return wrappedVba_p->vecIntRange (calEnum);
1544 : }
1545 :
1546 : Cube<Complex>&
1547 0 : VisBufferAsyncWrapper::visCube ()
1548 : {
1549 0 : CheckWrap ();
1550 0 : return wrappedVba_p->visCube ();
1551 : }
1552 :
1553 : const Cube<Complex>&
1554 0 : VisBufferAsyncWrapper::visCube () const
1555 : {
1556 0 : CheckWrap ();
1557 0 : return wrappedVba_p->visCube ();
1558 : }
1559 :
1560 : Matrix<CStokesVector>&
1561 0 : VisBufferAsyncWrapper::visibility ()
1562 : {
1563 0 : CheckWrap ();
1564 0 : return wrappedVba_p->visibility ();
1565 : }
1566 :
1567 : const Matrix<CStokesVector>&
1568 0 : VisBufferAsyncWrapper::visibility () const
1569 : {
1570 0 : CheckWrap ();
1571 0 : return wrappedVba_p->visibility ();
1572 : }
1573 :
1574 : Vector<Float>&
1575 0 : VisBufferAsyncWrapper::weight ()
1576 : {
1577 0 : CheckWrap ();
1578 0 : return wrappedVba_p->weight ();
1579 : }
1580 :
1581 : const Vector<Float>&
1582 0 : VisBufferAsyncWrapper::weight () const
1583 : {
1584 0 : CheckWrap ();
1585 0 : return wrappedVba_p->weight ();
1586 : }
1587 :
1588 : Cube<Float>&
1589 0 : VisBufferAsyncWrapper::weightCube ()
1590 : {
1591 0 : CheckWrap ();
1592 0 : return wrappedVba_p->weightCube ();
1593 : }
1594 :
1595 : Matrix<Float>&
1596 0 : VisBufferAsyncWrapper::weightMat ()
1597 : {
1598 0 : CheckWrap ();
1599 0 : return wrappedVba_p->weightMat ();
1600 : }
1601 :
1602 : const Matrix<Float>&
1603 0 : VisBufferAsyncWrapper::weightMat () const
1604 : {
1605 0 : CheckWrap ();
1606 0 : return wrappedVba_p->weightMat ();
1607 : }
1608 :
1609 : Cube<Float>&
1610 0 : VisBufferAsyncWrapper::weightSpectrum ()
1611 : {
1612 0 : CheckWrap ();
1613 0 : return wrappedVba_p->weightSpectrum ();
1614 : }
1615 :
1616 : const Cube<Float>&
1617 0 : VisBufferAsyncWrapper::weightSpectrum () const
1618 : {
1619 0 : CheckWrap ();
1620 0 : return wrappedVba_p->weightSpectrum ();
1621 : }
1622 :
1623 : void
1624 0 : VisBufferAsyncWrapper::wrap (VisBufferAsync * vba)
1625 : {
1626 0 : assert (vba != wrappedVba_p);
1627 :
1628 0 : if (wrappedVba_p != NULL){
1629 0 : delete wrappedVba_p;
1630 0 : wrappedVba_p = NULL;
1631 : }
1632 :
1633 0 : wrappedVba_p = vba;
1634 0 : attachWrappedVb (wrappedVisIterAsync_p);
1635 0 : }
1636 :
1637 : using namespace casacore;
1638 : } // end namespace casa
1639 :
|
