bes  Updated for version 3.20.6
RenamedArrayWrapper.cc
1 // This file is part of the "NcML Module" project, a BES module designed
3 // to allow NcML files to be used to be used as a wrapper to add
4 // AIS to existing datasets of any format.
5 //
6 // Copyright (c) 2009 OPeNDAP, Inc.
7 // Author: Michael Johnson <m.johnson@opendap.org>
8 //
9 // For more information, please also see the main website: http://opendap.org/
10 //
11 // This library is free software; you can redistribute it and/or
12 // modify it under the terms of the GNU Lesser General Public
13 // License as published by the Free Software Foundation; either
14 // version 2.1 of the License, or (at your option) any later version.
15 //
16 // This library is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 // Lesser General Public License for more details.
20 //
21 // You should have received a copy of the GNU Lesser General Public
22 // License along with this library; if not, write to the Free Software
23 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 //
25 // Please see the files COPYING and COPYRIGHT for more information on the GLPL.
26 //
27 // You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
29 #include "RenamedArrayWrapper.h"
30 
31 #include <AttrTable.h>
32 #include <BaseType.h>
33 #include <DDS.h>
34 #include <dods-datatypes.h>
35 #include <Marshaller.h>
36 #include <UnMarshaller.h>
37 #include "NCMLDebug.h"
38 #include "NCMLUtil.h"
39 #include <sstream>
40 #include <vector>
41 
42 using namespace libdap;
43 using std::ostringstream;
44 using std::string;
45 
46 namespace ncml_module {
47 RenamedArrayWrapper::RenamedArrayWrapper() :
48  Array("", 0), _pArray(0), _orgName("")
49 {
50 }
51 
52 RenamedArrayWrapper::RenamedArrayWrapper(const RenamedArrayWrapper& proto) :
53  Array(proto) // I think we need to do this for constraints
54  , _pArray(0), _orgName(proto._orgName)
55 {
56  copyLocalRepFrom(proto);
57 }
58 
59 RenamedArrayWrapper::RenamedArrayWrapper(libdap::Array* toBeWrapped) :
60  Array(*toBeWrapped) // ugh, this will copy a lot of stuff we might not want to copy either, but seems safest.
61  , _pArray(toBeWrapped), _orgName("")
62 {
63  NCML_ASSERT_MSG(_pArray, "RenamedArrayWrapper(): expected non-null Array to wrap!!");
64  _orgName = toBeWrapped->name();
65  set_read_p(false); // force it to reload if we need to
66 }
67 
68 RenamedArrayWrapper::~RenamedArrayWrapper()
69 {
70  destroy(); // local vars
71 }
72 
73 RenamedArrayWrapper*
74 RenamedArrayWrapper::ptr_duplicate()
75 {
76  return new RenamedArrayWrapper(*this);
77 }
78 
79 RenamedArrayWrapper&
80 RenamedArrayWrapper::operator=(const RenamedArrayWrapper& rhs)
81 {
82  if (&rhs == this) {
83  return *this;
84  }
85  destroy();
86  copyLocalRepFrom(rhs);
87  return *this;
88 }
89 
92 
93 #if 1
94 void RenamedArrayWrapper::add_constraint(Dim_iter i, int start, int stride, int stop)
95 {
96  // Set the constraint on the dimension and then sync the wrapped array to the new constraint.
97  Array::add_constraint(i, start, stride, stop);
98  syncConstraints();
99 }
100 
101 void RenamedArrayWrapper::reset_constraint()
102 {
103  Array::reset_constraint();
104  _pArray->reset_constraint();
105 }
106 
108 {
109  Array::clear_constraint();
110  _pArray->clear_constraint();
111 }
112 #endif
113 
114 string RenamedArrayWrapper::toString()
115 {
116  return const_cast<const RenamedArrayWrapper*>(this)->toString();
117 }
118 
119 string RenamedArrayWrapper::toString() const
120 {
121  ostringstream oss;
122  oss << "RenamedArrayWrapper(" << this << "): " << endl;
123  oss << "\t_pArray=" << ((_pArray) ? (_pArray->toString()) : ("NULL")) << endl;
124  return oss.str();
125 }
126 
127 void RenamedArrayWrapper::dump(std::ostream &strm) const
128 {
129  strm << toString();
130 }
131 #if 0
132 
133 bool
134 RenamedArrayWrapper::is_simple_type() const
135 {
136  return _pArray->is_simple_type();
137 }
138 
139 bool
140 RenamedArrayWrapper::is_vector_type() const
141 {
142  return _pArray->is_vector_type();
143 }
144 
145 bool
146 RenamedArrayWrapper::is_constructor_type() const
147 {
148  return _pArray->is_constructor_type();
149 }
150 
151 bool
152 RenamedArrayWrapper::synthesized_p()
153 {
154  return _pArray->synthesized_p();
155 }
156 
157 void
158 RenamedArrayWrapper::set_synthesized_p(bool state)
159 {
160  // keep us in sync, why not.
161  BaseType::set_synthesized_p(state);
162  _pArray->set_synthesized_p(state);
163 }
164 
165 int
166 RenamedArrayWrapper::element_count(bool leaves /* = false */)
167 {
168  return _pArray->element_count(leaves);
169 }
170 #endif
171 
172 bool RenamedArrayWrapper::read_p()
173 {
174  return _pArray->read_p();
175 }
176 
177 void RenamedArrayWrapper::set_read_p(bool state)
178 {
179 // BaseType::set_read_p(state);
180  _pArray->set_read_p(state);
181 }
182 
183 bool RenamedArrayWrapper::send_p()
184 {
185  return _pArray->send_p();
186 }
187 
188 void RenamedArrayWrapper::set_send_p(bool state)
189 {
190 // BaseType::set_send_p(state);
191  _pArray->set_send_p(state);
192 }
193 #if 0
194 
196 AttrTable&
197 RenamedArrayWrapper::get_attr_table()
198 {
199  return _pArray->get_attr_table();
200 }
201 
202 void
203 RenamedArrayWrapper::set_attr_table(const AttrTable &at)
204 {
205  _pArray->set_attr_table(at);
206 }
207 
208 bool
209 RenamedArrayWrapper::is_in_selection()
210 {
211  return _pArray->is_in_selection();
212 }
213 
214 void
215 RenamedArrayWrapper::set_in_selection(bool state)
216 {
217  BaseType::set_in_selection(state);
218  _pArray->set_in_selection(state);
219 }
220 
222 void
223 RenamedArrayWrapper::set_parent(BaseType *parent)
224 {
225  BaseType::set_parent(parent);
226  _pArray->set_parent(parent);
227 }
228 
229 BaseType*
230 RenamedArrayWrapper::get_parent() const
231 {
232  return _pArray->get_parent();
233 }
234 #endif
235 
236 BaseType*
237 RenamedArrayWrapper::var(const string &name /* = "" */, bool exact_match /* = true */, btp_stack *s /* = 0 */)
238 {
239  return _pArray->var(name, exact_match, s);
240 }
241 
242 BaseType*
243 RenamedArrayWrapper::var(const string &name, btp_stack &s)
244 {
245  return _pArray->var(name, s);
246 }
247 
248 void RenamedArrayWrapper::add_var(BaseType *bt, Part part /* = nil */)
249 {
250  _pArray->add_var(bt, part);
251 }
252 
253 void RenamedArrayWrapper::add_var_nocopy(BaseType *bt, Part part /* = nil */)
254 {
255  _pArray->add_var_nocopy(bt, part);
256 }
257 
258 #if 0
259 bool
260 RenamedArrayWrapper::check_semantics(string &msg, bool all /* = false*/)
261 {
262  return _pArray->check_semantics(msg, all);
263 }
264 
265 bool
266 RenamedArrayWrapper::ops(BaseType *b, int op)
267 {
268  return _pArray->ops(b, op);
269 }
270 #endif
271 
272 #if FILE_METHODS // from libdap/BaseType.h, whether to include FILE* methods
273 void
274 RenamedArrayWrapper::print_decl(FILE *out,
275  string space /* = " "*/,
276  bool print_semi /* = true*/,
277  bool constraint_info /* = false*/,
278  bool constrained /* = false */)
279 {
280  syncConstraints();
281  withNewName();
282  _pArray->print_decl(out, space, print_semi, constraint_info, constrained);
283  withOrgName();
284 }
285 
286 void
287 RenamedArrayWrapper::print_xml(FILE *out,
288  string space /* = " "*/,
289  bool constrained /* = false */)
290 {
291  syncConstraints();
292  withNewName();
293  _pArray->print_xml(out, space, constrained);
294  withOrgName();
295 }
296 
297 void
298 RenamedArrayWrapper::print_val(FILE *out,
299  string space /* = ""*/,
300  bool print_decl_p /* = true*/)
301 {
302  syncConstraints();
303  withNewName();
304  print_val(out, space, print_decl_p);
305  withOrgName();
306 }
307 #endif // FILE_METHODS
308 
309 #if 0
310 void
311 RenamedArrayWrapper::print_decl(ostream &out,
312  string space /* = " "*/,
313  bool print_semi /* = true*/,
314  bool constraint_info /* = false*/,
315  bool constrained /* = false*/)
316 {
317  syncConstraints();
318  withNewName();
319  _pArray->print_decl(out, space, print_semi, constraint_info, constrained);
320  withOrgName();
321 }
322 
323 void
324 RenamedArrayWrapper::print_xml(ostream &out,
325  string space /* = " " */,
326  bool constrained /* = false */)
327 {
328  syncConstraints();
329  withNewName();
330  _pArray->print_xml(out, space, constrained);
331  withOrgName();
332 }
333 
334 void
335 RenamedArrayWrapper::print_val(ostream &out,
336  string space /* = ""*/,
337  bool print_decl_p /* = true*/)
338 {
339  syncConstraints();
340  withNewName();
341  print_val(out, space, print_decl_p);
342  withOrgName();
343 }
344 
345 unsigned int
346 RenamedArrayWrapper::width(bool constrained)
347 {
348  syncConstraints();
349  return _pArray->width(constrained);
350 }
351 #endif
352 
353 unsigned int RenamedArrayWrapper::buf2val(void **val)
354 {
355  //syncConstraints();
356  return _pArray->buf2val(val);
357 }
358 
359 unsigned int RenamedArrayWrapper::val2buf(void *val, bool reuse /* = false */)
360 {
361  //syncConstraints();
362  return _pArray->val2buf(val, reuse);
363 }
364 
365 template <typename T>
366 bool RenamedArrayWrapper::set_value_worker(T *v, int sz)
367 {
368  //syncConstraints();
369  return _pArray->set_value(v, sz);
370 }
371 bool RenamedArrayWrapper::set_value(dods_byte *val, int sz) { return set_value_worker(val,sz); }
372 bool RenamedArrayWrapper::set_value(dods_int8 *val, int sz) { return set_value_worker(val,sz); }
373 bool RenamedArrayWrapper::set_value(dods_int16 *val, int sz) { return set_value_worker(val,sz); }
374 bool RenamedArrayWrapper::set_value(dods_uint16 *val, int sz) { return set_value_worker(val,sz); }
375 bool RenamedArrayWrapper::set_value(dods_int32 *val, int sz) { return set_value_worker(val,sz); }
376 bool RenamedArrayWrapper::set_value(dods_uint32 *val, int sz) { return set_value_worker(val,sz); }
377 bool RenamedArrayWrapper::set_value(dods_int64 *val, int sz) { return set_value_worker(val,sz); }
378 bool RenamedArrayWrapper::set_value(dods_uint64 *val, int sz) { return set_value_worker(val,sz); }
379 bool RenamedArrayWrapper::set_value(dods_float32 *val, int sz) { return set_value_worker(val,sz); }
380 bool RenamedArrayWrapper::set_value(dods_float64 *val, int sz) { return set_value_worker(val,sz); }
381 bool RenamedArrayWrapper::set_value(string *val, int sz) { return set_value_worker(val,sz); }
382 
383 template <typename T>
384 bool RenamedArrayWrapper::set_value_worker(vector<T> &v, int sz)
385 {
386  //syncConstraints();
387  return _pArray->set_value(v, sz);
388 }
389 bool RenamedArrayWrapper::set_value(vector<dods_byte> &val, int sz) { return set_value_worker(val,sz); }
390 bool RenamedArrayWrapper::set_value(vector<dods_int8> &val, int sz) { return set_value_worker(val,sz); }
391 bool RenamedArrayWrapper::set_value(vector<dods_int16> &val, int sz) { return set_value_worker(val,sz); }
392 bool RenamedArrayWrapper::set_value(vector<dods_uint16> &val, int sz) { return set_value_worker(val,sz); }
393 bool RenamedArrayWrapper::set_value(vector<dods_int32> &val, int sz) { return set_value_worker(val,sz); }
394 bool RenamedArrayWrapper::set_value(vector<dods_uint32> &val, int sz) { return set_value_worker(val,sz); }
395 bool RenamedArrayWrapper::set_value(vector<dods_int64> &val, int sz) { return set_value_worker(val,sz); }
396 bool RenamedArrayWrapper::set_value(vector<dods_uint64> &val, int sz) { return set_value_worker(val,sz); }
397 bool RenamedArrayWrapper::set_value(vector<dods_float32> &val, int sz) { return set_value_worker(val,sz); }
398 bool RenamedArrayWrapper::set_value(vector<dods_float64> &val, int sz) { return set_value_worker(val,sz); }
399 bool RenamedArrayWrapper::set_value(vector<string> &val, int sz) { return set_value_worker(val,sz); }
400 
401 #if 0
402 
403 bool RenamedArrayWrapper::set_value(dods_byte *val, int sz)
404 {
405  //syncConstraints();
406  return _pArray->set_value(val, sz);
407 }
408 
409 bool RenamedArrayWrapper::set_value(vector<dods_byte> &val, int sz)
410 {
411  //syncConstraints();
412  return _pArray->set_value(val, sz);
413 }
414 
415 bool RenamedArrayWrapper::set_value(dods_int16 *val, int sz)
416 {
417  //syncConstraints();
418  return _pArray->set_value(val, sz);
419 }
420 
421 bool RenamedArrayWrapper::set_value(vector<dods_int16> &val, int sz)
422 {
423  //syncConstraints();
424  return _pArray->set_value(val, sz);
425 }
426 
427 bool RenamedArrayWrapper::set_value(dods_uint16 *val, int sz)
428 {
429  //syncConstraints();
430  return _pArray->set_value(val, sz);
431 }
432 
433 bool RenamedArrayWrapper::set_value(vector<dods_uint16> &val, int sz)
434 {
435  //syncConstraints();
436  return _pArray->set_value(val, sz);
437 }
438 
439 bool RenamedArrayWrapper::set_value(dods_int32 *val, int sz)
440 {
441  //syncConstraints();
442  return _pArray->set_value(val, sz);
443 }
444 
445 bool RenamedArrayWrapper::set_value(vector<dods_int32> &val, int sz)
446 {
447  //syncConstraints();
448  return _pArray->set_value(val, sz);
449 }
450 
451 bool RenamedArrayWrapper::set_value(dods_uint32 *val, int sz)
452 {
453  //syncConstraints();
454  return _pArray->set_value(val, sz);
455 }
456 
457 bool RenamedArrayWrapper::set_value(vector<dods_uint32> &val, int sz)
458 {
459  //syncConstraints();
460  return _pArray->set_value(val, sz);
461 }
462 
463 bool RenamedArrayWrapper::set_value(dods_float32 *val, int sz)
464 {
465  //syncConstraints();
466  return _pArray->set_value(val, sz);
467 }
468 
469 bool RenamedArrayWrapper::set_value(vector<dods_float32> &val, int sz)
470 {
471  //syncConstraints();
472  return _pArray->set_value(val, sz);
473 }
474 
475 bool RenamedArrayWrapper::set_value(dods_float64 *val, int sz)
476 {
477  //syncConstraints();
478  return _pArray->set_value(val, sz);
479 }
480 
481 bool RenamedArrayWrapper::set_value(vector<dods_float64> &val, int sz)
482 {
483  //syncConstraints();
484  return _pArray->set_value(val, sz);
485 }
486 
487 bool RenamedArrayWrapper::set_value(string *val, int sz)
488 {
489  //syncConstraints();
490  return _pArray->set_value(val, sz);
491 }
492 
493 bool RenamedArrayWrapper::set_value(vector<string> &val, int sz)
494 {
495  //syncConstraints();
496  return _pArray->set_value(val, sz);
497 }
498 #endif
499 
500 
501 template <typename T>
502 void RenamedArrayWrapper::value_worker(T *v) const
503 {
504  //syncConstraints();
505  _pArray->value(v);
506 }
507 void RenamedArrayWrapper::value(dods_byte *b) const { value_worker(b); }
508 void RenamedArrayWrapper::value(dods_int8 *b) const { value_worker(b); }
509 void RenamedArrayWrapper::value(dods_int16 *b) const { value_worker(b); }
510 void RenamedArrayWrapper::value(dods_uint16 *b) const { value_worker(b); }
511 void RenamedArrayWrapper::value(dods_int32 *b) const { value_worker(b); }
512 void RenamedArrayWrapper::value(dods_uint32 *b) const { value_worker(b); }
513 void RenamedArrayWrapper::value(dods_int64 *b) const { value_worker(b); }
514 void RenamedArrayWrapper::value(dods_uint64 *b) const { value_worker(b); }
515 void RenamedArrayWrapper::value(dods_float32 *b) const { value_worker(b); }
516 void RenamedArrayWrapper::value(dods_float64 *b) const { value_worker(b); }
517 void RenamedArrayWrapper::value(vector<string> &b) const { return _pArray->value(b); }
518 
519 
520 #if 0
521 void RenamedArrayWrapper::value(dods_byte *b) const
522 {
523  //syncConstraints();
524  _pArray->value(b);
525 }
526 
527 void RenamedArrayWrapper::value(dods_int16 *b) const
528 {
529  //syncConstraints();
530  _pArray->value(b);
531 }
532 
533 void RenamedArrayWrapper::value(dods_uint16 *b) const
534 {
535  //syncConstraints();
536  _pArray->value(b);
537 }
538 
539 void RenamedArrayWrapper::value(dods_int32 *b) const
540 {
541  //syncConstraints();
542  _pArray->value(b);
543 }
544 
545 void RenamedArrayWrapper::value(dods_uint32 *b) const
546 {
547  //syncConstraints();
548  _pArray->value(b);
549 }
550 
551 void RenamedArrayWrapper::value(dods_float32 *b) const
552 {
553  //syncConstraints();
554  _pArray->value(b);
555 }
556 
557 void RenamedArrayWrapper::value(dods_float64 *b) const
558 {
559  //syncConstraints();
560  _pArray->value(b);
561 }
562 
563 void RenamedArrayWrapper::value(vector<string> &b) const
564 {
565  //syncConstraints();
566  _pArray->value(b);
567 }
568 #endif
569 
570 template <typename T>
571 void RenamedArrayWrapper::value_worker(vector<unsigned int> *indices, T *b) const
572 {
573  return _pArray->value(indices,b);
574 }
575 
576 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_byte *b) const { value_worker(indices,b); };
577 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_int8 *b) const { value_worker(indices,b); };
578 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_int16 *b) const { value_worker(indices,b); };
579 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_uint16 *b) const { value_worker(indices,b); };
580 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_int32 *b) const { value_worker(indices,b); };
581 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_uint32 *b) const { value_worker(indices,b); };
582 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_int64 *b) const { value_worker(indices,b); };
583 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_uint64 *b) const { value_worker(indices,b); };
584 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_float32 *b) const { value_worker(indices,b); };
585 void RenamedArrayWrapper::value(vector<unsigned int> *indices, dods_float64 *b) const { value_worker(indices,b); };
586 void RenamedArrayWrapper::value(vector<unsigned int> *indices, vector<string> &b) const { return _pArray->value(indices,b); }
587 
588 
589 
590 void*
591 RenamedArrayWrapper::value()
592 {
593  //syncConstraints();
594  return _pArray->value();
595 }
596 
597 #if 0
598 // DO THE REAL WORK
599 bool
600 RenamedArrayWrapper::read()
601 {
602  // Read using the old name....
603  withOrgName();
604  bool ret = _pArray->read();
605  set_read_p(true);// get us too
606  withNewName();
607  return ret;
608 }
609 #endif
610 
611 // DO THE REAL WORK
612 bool RenamedArrayWrapper::read()
613 {
614  //syncConstraints();
615  return _pArray->read();
616 }
617 
618 #if 0
619 void
620 RenamedArrayWrapper::intern_data(ConstraintEvaluator &eval, DDS &dds)
621 {
622  syncConstraints();
623 
624  // Force the correct read to be called, as with serialize...
625  // If not read in, read it in with the orgName and these constraints.
626  if (!_pArray->read_p())
627  {
628  //withOrgName();
629  _pArray->read();
630  set_read_p(true);
631  }
632 
633  // Now we're back to the new name for intern_data purposes.
634  //withNewName();
635  _pArray->intern_data(eval, dds);
636 }
637 #endif
638 void RenamedArrayWrapper::intern_data(ConstraintEvaluator &eval, DDS &dds)
639 {
640  _pArray->intern_data(eval, dds);
641 }
642 
643 #if 0
644 bool
645 RenamedArrayWrapper::serialize(ConstraintEvaluator &eval, DDS &dds,
646  Marshaller &m, bool ce_eval /* = true */)
647 {
648  // BESDEBUG("ncml_rename", "RenamedArrayWrapper::serialize(): Doing the magic for renamed read()!!" << endl);
649  // Push them down if we need to.
650  syncConstraints();
651 
652  //string no_preload_tag = "no_preload_for_renamed_arrays";
653  if (BESISDEBUG( "no_preload_for_renamed_arrays" ) || 1) {
654  // BESDEBUG("no_preload_for_renamed_arrays", "RenamedArrayWrapper::serialize() - !!!!! Skipping preload of renamed array orgName: '" << _orgName << "' newName: '" << name() << "'" << endl);
655  BESDEBUG("ncml_rename", "RenamedArrayWrapper::serialize() - !!!!! SKIPPING preload of renamed array orgName: '" << _orgName << "' newName: '" << name() << "'" << endl);
656  // withOrgName();
657  }
658  else {
659  BESDEBUG("ncml_rename", "RenamedArrayWrapper::serialize() - Preloading renamed array orgName: '" << _orgName << "' newName: '" << name() << "'" << endl);
660 
661  // If not read in, read it in with the orgName and these constraints.
662  if (!_pArray->read_p())
663  {
664  //withOrgName();
665  _pArray->read();
666  set_read_p(true);
667  }
668 
669  // Now we're back to the new name for printing purposes.
670  //withNewName();
671  }
672  // So call the actual serialize, which should hopefully respect read_p() being set!!
673  return _pArray->serialize(eval, dds, m, ce_eval);
674 }
675 #endif
676 
677 bool RenamedArrayWrapper::serialize(ConstraintEvaluator &eval, DDS &dds, Marshaller &m, bool ce_eval /* = true */)
678 {
679  BESDEBUG("ncml_rename", "RenamedArrayWrapper::serialize(): Doing the magic for renamed read()!!" << endl);
680  //syncConstraints();
681  return _pArray->serialize(eval, dds, m, ce_eval);
682 }
683 
684 bool RenamedArrayWrapper::deserialize(UnMarshaller &um, DDS *dds, bool reuse /* = false */)
685 {
686  // I *think* this should work
687  //syncConstraints();
688  return _pArray->deserialize(um, dds, reuse);
689 }
690 
693 
694 void RenamedArrayWrapper::copyLocalRepFrom(const RenamedArrayWrapper& proto)
695 {
696  if (&proto == this) {
697  return;
698  }
699 
700  if (proto._pArray) {
701  _pArray = dynamic_cast<libdap::Array*>(proto._pArray->ptr_duplicate());
702  }
703  _orgName = proto._orgName;
704 }
705 
706 void RenamedArrayWrapper::destroy()
707 {
708  SAFE_DELETE(_pArray);
709  _orgName = "";
710 }
711 
712 #if 0
713 void
714 RenamedArrayWrapper::withNewName()
715 {
716  NCMLUtil::setVariableNameProperly(_pArray, name());
717 }
718 
719 void
720 RenamedArrayWrapper::withOrgName()
721 {
722  NCMLUtil::setVariableNameProperly(_pArray, _orgName);
723 }
724 #endif
725 
726 void RenamedArrayWrapper::syncConstraints()
727 {
728  // First see if the number of dimensions is correct. We may not need to bother with this,
729  // just constraint propagation
730  if (_pArray->dimensions() != dimensions()) {
731  THROW_NCML_INTERNAL_ERROR(
732  "RenamedArrayWrapper::syncConstraints(): dimensions() of this and wrapped array do not match!");
733  }
734 
735  // If they match, iterate the shape and set make sure the values are set.
736  Array::Dim_iter thisEndIt = dim_end();
737  Array::Dim_iter thisIt, wrapIt;
738  for (thisIt = dim_begin(), wrapIt = _pArray->dim_begin(); thisIt != thisEndIt; ++thisIt, ++wrapIt) {
739  Array::dimension& thisDim = *thisIt;
740  Array::dimension& wrapDim = *wrapIt;
741  wrapDim = thisDim; // copy them!
742  }
743  // this calculates it's length fine, then set it to the wrapped
744  // since it has no way to know we changed the dimensions...
745  update_length(this->length());
746  _pArray->set_length(this->length());
747  NCML_ASSERT_MSG(this->length() == _pArray->length(),
748  "RenamedArrayWrapper::syncConstraints(): length() of this and wrapped do not match!!");
749 }
750 }
libdap
Definition: BESDapFunctionResponseCache.h:35
ncml_module
NcML Parser for adding/modifying/removing metadata (attributes) to existing local datasets using NcML...
Definition: AggregationElement.cc:72
ncml_module::RenamedArrayWrapper::clear_constraint
virtual void clear_constraint()
Definition: RenamedArrayWrapper.cc:107
ncml_module::RenamedArrayWrapper
A Decorator Pattern for wrapping a libdap::Array in order to change its name efficiently in the face ...
Definition: RenamedArrayWrapper.h:60
ncml_module::RenamedArrayWrapper::add_constraint
virtual void add_constraint(Dim_iter i, int start, int stride, int stop)
Wrappers.
Definition: RenamedArrayWrapper.cc:94
ncml_module::NCMLUtil::setVariableNameProperly
static void setVariableNameProperly(libdap::BaseType *pVar, const std::string &name)
Definition: NCMLUtil.cc:460