ExprGroup.h
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #ifndef TABLES_EXPRGROUP_H
00029 #define TABLES_EXPRGROUP_H
00030
00031
00032 #include <casacore/casa/aips.h>
00033 #include <casacore/casa/BasicSL/String.h>
00034 #include <casacore/tables/TaQL/ExprAggrNode.h>
00035 #include <vector>
00036
00037
00038 namespace casacore {
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052 class TableExprGroupKey
00053 {
00054 public:
00055
00056 explicit TableExprGroupKey (TableExprNodeRep::NodeDataType dtype)
00057 : itsDT (dtype)
00058 {}
00059
00060
00061 TableExprNodeRep::NodeDataType dataType() const
00062 { return itsDT; }
00063
00064
00065
00066 void set (Bool v)
00067 { itsBool = v; }
00068 void set (Int64 v)
00069 { itsInt64 = v; }
00070 void set (Double v)
00071 { itsDouble = v; }
00072 void set (const String& v)
00073 { itsString = v; }
00074
00075
00076
00077
00078 bool operator== (const TableExprGroupKey&) const;
00079 bool operator< (const TableExprGroupKey&) const;
00080
00081
00082 private:
00083 TableExprNodeRep::NodeDataType itsDT;
00084 Bool itsBool;
00085 Int64 itsInt64;
00086 Double itsDouble;
00087 String itsString;
00088 };
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105 class TableExprGroupKeySet
00106 {
00107 public:
00108
00109 TableExprGroupKeySet (const vector<TableExprNode>& nodes);
00110
00111
00112 void addKey (TableExprNodeRep::NodeDataType dtype)
00113 { itsKeys.push_back (TableExprGroupKey(dtype)); }
00114
00115
00116 void fill (const vector<TableExprNode>& nodes, const TableExprId& id);
00117
00118
00119
00120
00121 bool operator== (const TableExprGroupKeySet&) const;
00122 bool operator< (const TableExprGroupKeySet&) const;
00123
00124 private:
00125 vector<TableExprGroupKey> itsKeys;
00126 };
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144 class TableExprGroupResult
00145 {
00146 public:
00147
00148
00149 explicit TableExprGroupResult
00150 (const vector<CountedPtr<TableExprGroupFuncSet> >& funcSets);
00151
00152
00153 TableExprGroupResult
00154 (const vector<CountedPtr<TableExprGroupFuncSet> >& funcSets,
00155 const vector<CountedPtr<vector<TableExprId> > >& ids);
00156
00157 uInt ngroup() const
00158 { return itsFuncSets.size(); }
00159
00160 TableExprGroupFuncSet& funcSet (uInt group) const
00161 { return *itsFuncSets[group]; }
00162
00163 const vector<TableExprId>& ids (uInt group) const
00164 { return *itsIds[group]; }
00165 private:
00166 vector<CountedPtr<TableExprGroupFuncSet> > itsFuncSets;
00167 vector<CountedPtr<vector<TableExprId> > > itsIds;
00168 };
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201 class TableExprGroupFuncBase
00202 {
00203 public:
00204
00205
00206 explicit TableExprGroupFuncBase (TableExprNodeRep* node);
00207 virtual ~TableExprGroupFuncBase();
00208
00209
00210 virtual Bool isLazy() const;
00211
00212 uInt seqnr() const
00213 { return itsSeqnr; }
00214
00215 void setSeqnr (uInt seqnr)
00216 { itsSeqnr = seqnr; }
00217
00218
00219 virtual void apply (const TableExprId& id) = 0;
00220
00221
00222 virtual void finish();
00223
00224
00225 virtual CountedPtr<vector<TableExprId> > getIds() const;
00226
00227
00228
00229
00230
00231 virtual Bool getBool (const vector<TableExprId>& = vector<TableExprId>());
00232 virtual Int64 getInt (const vector<TableExprId>& = vector<TableExprId>());
00233 virtual Double getDouble (const vector<TableExprId>& = vector<TableExprId>());
00234 virtual DComplex getDComplex (const vector<TableExprId>& = vector<TableExprId>());
00235 virtual MVTime getDate (const vector<TableExprId>& = vector<TableExprId>());
00236 virtual String getString (const vector<TableExprId>& = vector<TableExprId>());
00237 virtual MArray<Bool> getArrayBool (const vector<TableExprId>& = vector<TableExprId>());
00238 virtual MArray<Int64> getArrayInt (const vector<TableExprId>& = vector<TableExprId>());
00239 virtual MArray<Double> getArrayDouble (const vector<TableExprId>& = vector<TableExprId>());
00240 virtual MArray<DComplex> getArrayDComplex (const vector<TableExprId>& = vector<TableExprId>());
00241 virtual MArray<MVTime> getArrayDate (const vector<TableExprId>& = vector<TableExprId>());
00242 virtual MArray<String> getArrayString (const vector<TableExprId>& = vector<TableExprId>());
00243
00244 private:
00245
00246 TableExprGroupFuncBase (const TableExprGroupFuncBase&);
00247 TableExprGroupFuncBase& operator= (const TableExprGroupFuncBase&);
00248 protected:
00249
00250 TableExprNodeRep* itsNode;
00251 TableExprNodeRep* itsOperand;
00252 uInt itsSeqnr;
00253 };
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266 class TableExprGroupNull: public TableExprGroupFuncBase
00267 {
00268 public:
00269 explicit TableExprGroupNull (TableExprNodeRep* node);
00270 virtual ~TableExprGroupNull();
00271 virtual Bool isLazy() const;
00272 virtual void apply (const TableExprId& id);
00273 };
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285 class TableExprGroupFirst: public TableExprGroupFuncBase
00286 {
00287 public:
00288 explicit TableExprGroupFirst (TableExprNodeRep* node);
00289 virtual ~TableExprGroupFirst();
00290 virtual void apply (const TableExprId& id);
00291 virtual Bool getBool (const vector<TableExprId>&);
00292 virtual Int64 getInt (const vector<TableExprId>&);
00293 virtual Double getDouble (const vector<TableExprId>&);
00294 virtual DComplex getDComplex (const vector<TableExprId>&);
00295 virtual MVTime getDate (const vector<TableExprId>&);
00296 virtual String getString (const vector<TableExprId>&);
00297 virtual MArray<Bool> getArrayBool (const vector<TableExprId>&);
00298 virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
00299 virtual MArray<Double> getArrayDouble (const vector<TableExprId>&);
00300 virtual MArray<DComplex> getArrayDComplex (const vector<TableExprId>&);
00301 virtual MArray<MVTime> getArrayDate (const vector<TableExprId>&);
00302 virtual MArray<String> getArrayString (const vector<TableExprId>&);
00303 protected:
00304 TableExprId itsId;
00305 };
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318 class TableExprGroupLast: public TableExprGroupFirst
00319 {
00320 public:
00321 explicit TableExprGroupLast (TableExprNodeRep* node);
00322 virtual ~TableExprGroupLast();
00323 virtual void apply (const TableExprId& id);
00324 };
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337 class TableExprGroupExprId: public TableExprGroupFuncBase
00338 {
00339 public:
00340 explicit TableExprGroupExprId (TableExprNodeRep* node);
00341 virtual ~TableExprGroupExprId();
00342 virtual Bool isLazy() const;
00343 virtual void apply (const TableExprId& id);
00344 virtual CountedPtr<vector<TableExprId> > getIds() const;
00345 private:
00346 CountedPtr<vector<TableExprId> > itsIds;
00347 };
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358 class TableExprGroupRowid: public TableExprGroupFuncBase
00359 {
00360 public:
00361 explicit TableExprGroupRowid (TableExprNodeRep* node);
00362 virtual ~TableExprGroupRowid();
00363 virtual Bool isLazy() const;
00364 virtual void apply (const TableExprId& id);
00365 virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
00366 };
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377
00378 class TableExprGroupAggr: public TableExprGroupFuncBase
00379 {
00380 public:
00381 explicit TableExprGroupAggr (TableExprNodeRep* node);
00382 virtual ~TableExprGroupAggr();
00383 virtual Bool isLazy() const;
00384 virtual void apply (const TableExprId& id);
00385 virtual MArray<Bool> getArrayBool (const vector<TableExprId>&);
00386 virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
00387 virtual MArray<Double> getArrayDouble (const vector<TableExprId>&);
00388 virtual MArray<DComplex> getArrayDComplex (const vector<TableExprId>&);
00389 virtual MArray<MVTime> getArrayDate (const vector<TableExprId>&);
00390 virtual MArray<String> getArrayString (const vector<TableExprId>&);
00391 protected:
00392 template<typename T>
00393 MArray<T> getArray (const vector<TableExprId>& ids)
00394 {
00395
00396 if (itsOperand->valueType() == TableExprNodeRep::VTScalar) {
00397 Vector<T> result(ids.size());
00398 for (size_t i=0; i<ids.size(); ++i) {
00399 itsOperand->get (ids[i], result[i]);
00400 }
00401 return MArray<T>(result);
00402 }
00403
00404
00405 MArray<T> arr;
00406 size_t id;
00407 Bool hasMask = False;
00408 IPosition shp;
00409 for (id=0; id<ids.size(); ++id) {
00410 itsOperand->get (ids[id], arr);
00411 if (! arr.isNull()) {
00412 hasMask = arr.hasMask();
00413 shp = arr.shape();
00414 shp.append (IPosition (1, ids.size()));
00415 break;
00416 }
00417 }
00418 size_t ndef = 0;
00419 if (id == ids.size()) {
00420
00421 return MArray<T>();
00422 }
00423 Array<T> result(shp);
00424 ArrayIterator<T> iter (result, arr.ndim());
00425 Array<Bool> mask;
00426 CountedPtr<ArrayIterator<Bool> > miter;
00427 if (hasMask) {
00428 mask.resize (shp);
00429 miter = new ArrayIterator<Bool> (mask, arr.ndim());
00430 }
00431 for (; id<ids.size(); ++id) {
00432 MArray<T> values;
00433 itsOperand->get (ids[id], values);
00434 if (! values.isNull()) {
00435 ndef++;
00436 iter.array() = values.array();
00437 iter.next();
00438 if (hasMask) {
00439 miter->array() = values.mask();
00440 miter->next();
00441 }
00442 }
00443 }
00444 if (ndef < ids.size()) {
00445 shp[shp.size() - 1] = ndef;
00446 result.resize (shp, True);
00447 if (hasMask) {
00448 mask.resize (shp, True);
00449 }
00450 }
00451 return MArray<T>(result, mask);
00452 }
00453 };
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469 class TableExprGroupFuncBool: public TableExprGroupFuncBase
00470 {
00471 public:
00472 explicit TableExprGroupFuncBool (TableExprNodeRep* node)
00473 : TableExprGroupFuncBase (node)
00474 {}
00475 TableExprGroupFuncBool (TableExprNodeRep* node, Bool initValue)
00476 : TableExprGroupFuncBase (node),
00477 itsValue (initValue)
00478 {}
00479 virtual ~TableExprGroupFuncBool();
00480 virtual Bool getBool (const vector<TableExprId>&);
00481 protected:
00482 Bool itsValue;
00483 };
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498 class TableExprGroupFuncInt: public TableExprGroupFuncBase
00499 {
00500 public:
00501 explicit TableExprGroupFuncInt (TableExprNodeRep* node, Int64 initValue=0)
00502 : TableExprGroupFuncBase (node),
00503 itsValue (initValue)
00504 {}
00505 virtual ~TableExprGroupFuncInt();
00506 virtual Int64 getInt (const vector<TableExprId>&);
00507 virtual Double getDouble (const vector<TableExprId>&);
00508 protected:
00509 Int64 itsValue;
00510 };
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525 class TableExprGroupFuncDouble: public TableExprGroupFuncBase
00526 {
00527 public:
00528 explicit TableExprGroupFuncDouble (TableExprNodeRep* node,
00529 Double initValue = 0)
00530 : TableExprGroupFuncBase (node),
00531 itsValue (initValue)
00532 {}
00533 virtual ~TableExprGroupFuncDouble();
00534 virtual Double getDouble (const vector<TableExprId>&);
00535 protected:
00536 Double itsValue;
00537 };
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552 class TableExprGroupFuncDComplex: public TableExprGroupFuncBase
00553 {
00554 public:
00555 explicit TableExprGroupFuncDComplex (TableExprNodeRep* node,
00556 const DComplex& initValue = DComplex())
00557 : TableExprGroupFuncBase (node),
00558 itsValue (initValue)
00559 {}
00560 virtual ~TableExprGroupFuncDComplex();
00561 virtual DComplex getDComplex (const vector<TableExprId>&);
00562 protected:
00563 DComplex itsValue;
00564 };
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579 class TableExprGroupFuncDate: public TableExprGroupFuncBase
00580 {
00581 public:
00582 explicit TableExprGroupFuncDate (TableExprNodeRep* node,
00583 const MVTime& initValue = MVTime())
00584 : TableExprGroupFuncBase (node),
00585 itsValue (initValue)
00586 {}
00587 virtual ~TableExprGroupFuncDate();
00588 virtual MVTime getDate (const vector<TableExprId>&);
00589 protected:
00590 MVTime itsValue;
00591 };
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606 class TableExprGroupFuncString: public TableExprGroupFuncBase
00607 {
00608 public:
00609 explicit TableExprGroupFuncString (TableExprNodeRep* node,
00610 const String& initValue = String())
00611 : TableExprGroupFuncBase (node),
00612 itsValue (initValue)
00613 {}
00614 virtual ~TableExprGroupFuncString();
00615 virtual String getString (const vector<TableExprId>&);
00616 protected:
00617 String itsValue;
00618 };
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633 class TableExprGroupFuncArrayBool: public TableExprGroupFuncBase
00634 {
00635 public:
00636 explicit TableExprGroupFuncArrayBool (TableExprNodeRep* node)
00637 : TableExprGroupFuncBase (node)
00638 {}
00639 virtual ~TableExprGroupFuncArrayBool();
00640 virtual MArray<Bool> getArrayBool (const vector<TableExprId>&);
00641 protected:
00642
00643
00644 Bool checkShape (const MArrayBase& arr, const String& func);
00645 MArray<Bool> itsValue;
00646 };
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661 class TableExprGroupFuncArrayInt: public TableExprGroupFuncBase
00662 {
00663 public:
00664 explicit TableExprGroupFuncArrayInt (TableExprNodeRep* node)
00665 : TableExprGroupFuncBase (node)
00666 {}
00667 virtual ~TableExprGroupFuncArrayInt();
00668 virtual MArray<Int64> getArrayInt (const vector<TableExprId>&);
00669 protected:
00670
00671
00672 Bool checkShape (const MArrayBase& arr, const String& func);
00673 MArray<Int64> itsValue;
00674 };
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689 class TableExprGroupFuncArrayDouble: public TableExprGroupFuncBase
00690 {
00691 public:
00692 explicit TableExprGroupFuncArrayDouble (TableExprNodeRep* node)
00693 : TableExprGroupFuncBase (node)
00694 {}
00695 virtual ~TableExprGroupFuncArrayDouble();
00696 virtual MArray<Double> getArrayDouble (const vector<TableExprId>&);
00697 protected:
00698
00699
00700 Bool checkShape (const MArrayBase& arr, const String& func);
00701 MArray<Double> itsValue;
00702 };
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717 class TableExprGroupFuncArrayDComplex: public TableExprGroupFuncBase
00718 {
00719 public:
00720 explicit TableExprGroupFuncArrayDComplex (TableExprNodeRep* node)
00721 : TableExprGroupFuncBase (node)
00722 {}
00723 virtual ~TableExprGroupFuncArrayDComplex();
00724 virtual MArray<DComplex> getArrayDComplex (const vector<TableExprId>&);
00725 protected:
00726
00727
00728 Bool checkShape (const MArrayBase& arr, const String& func);
00729 MArray<DComplex> itsValue;
00730 };
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745 class TableExprGroupFuncArrayDate: public TableExprGroupFuncBase
00746 {
00747 public:
00748 explicit TableExprGroupFuncArrayDate (TableExprNodeRep* node)
00749 : TableExprGroupFuncBase (node)
00750 {}
00751 virtual ~TableExprGroupFuncArrayDate();
00752 virtual MArray<MVTime> getArrayDate (const vector<TableExprId>&);
00753 protected:
00754
00755
00756 Bool checkShape (const MArrayBase& arr, const String& func);
00757 MArray<MVTime> itsValue;
00758 };
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773 class TableExprGroupFuncArrayString: public TableExprGroupFuncBase
00774 {
00775 public:
00776 explicit TableExprGroupFuncArrayString (TableExprNodeRep* node)
00777 : TableExprGroupFuncBase (node)
00778 {}
00779 virtual ~TableExprGroupFuncArrayString();
00780 virtual MArray<String> getArrayString (const vector<TableExprId>&);
00781 protected:
00782
00783
00784 Bool checkShape (const MArrayBase& arr, const String& func);
00785 MArray<String> itsValue;
00786 };
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801 class TableExprGroupFuncSet
00802 {
00803 public:
00804 TableExprGroupFuncSet()
00805 : itsId (0)
00806 {}
00807
00808
00809 TableExprGroupFuncSet (const vector<TableExprNodeRep*>& aggrNodes);
00810
00811
00812 void add (const CountedPtr<TableExprGroupFuncBase>& func);
00813
00814
00815 void apply (const TableExprId& id);
00816
00817
00818 const vector<CountedPtr<TableExprGroupFuncBase> >& getFuncs() const
00819 { return itsFuncs; }
00820
00821
00822 const TableExprId& getId() const
00823 { return itsId; }
00824
00825 private:
00826
00827 TableExprGroupFuncSet (const TableExprGroupFuncSet&);
00828 TableExprGroupFuncSet& operator= (const TableExprGroupFuncSet&);
00829
00830
00831 vector<CountedPtr<TableExprGroupFuncBase> > itsFuncs;
00832 TableExprId itsId;
00833 };
00834
00835 }
00836
00837 #endif