1 //
2 // This file is part of the SDTS++ toolkit, written by the U.S.
3 // Geological Survey. It is experimental software, written to support
4 // USGS research and cartographic data production.
5 //
6 // SDTS++ is public domain software. It may be freely copied,
7 // distributed, and modified. The USGS welcomes user feedback, but makes
8 // no committment to any level of support for this code. See the SDTS
9 // web site at http://mcmcweb.er.usgs.gov/sdts for more information,
10 // including points of contact.
11 //
12 // $Id: sb_Ddsh.cpp,v 1.9 2002/11/24 22:07:42 mcoletti Exp $
13 //
14
15 #ifdef _MSC_VER
16 #pragma warning( disable : 4786 )
17 #endif
18
19
20 #include <sdts++/builder/sb_Ddsh.h>
21
22
23 #include <iostream>
24 #include <strstream>
25
26 #include <limits.h>
27 #include <float.h>
28
29 #ifndef INCLUDED_SB_UTILS_H
30 #include <sdts++/builder/sb_Utils.h>
31 #endif
32
33 #ifndef INCLUDED_SB_FOREIGNID_H
34 #include <sdts++/builder/sb_ForeignID.h>
35 #endif
36
37 #ifndef INCLUDED_SC_RECORD_H
38 #include <sdts++/container/sc_Record.h>
39 #endif
40
41 #ifndef INCLUDED_SC_FIELD_H
42 #include <sdts++/container/sc_Field.h>
43 #endif
44
45 #ifndef INCLUDED_SC_SUBFIELD_H
46 #include <sdts++/container/sc_Subfield.h>
47 #endif
48
49 #ifndef INCLUDED_SIO_8211CONVERTER_H
50 #include <sdts++/io/sio_8211Converter.h>
51 #endif
52
53
54 using namespace std;
55
56
57 static const char* ident_ = "$Id: sb_Ddsh.cpp,v 1.9 2002/11/24 22:07:42 mcoletti Exp $";
58
59 // Strings and integers are initialized with these values; they are used
60 // to indicate whether a given module value has been assigned a value or not.
61
62 // (XXX I arbitrarily chose 0x4 as the sentinal value. I hate ad hoc crap.)
63
64 static const string UNVALUED_STRING(1, static_cast<string::value_type>(0x4) );
65
66 static const long UNVALUED_LONG = INT_MIN;
67
68 static const double UNVALUED_DOUBLE = DBL_MAX;
69
70 static set<string> TYPE_domain;
71 static set<string> KEY_domain;
72
73
74
75 struct sb_Ddsh_Imp
76 {
77 string Name_;
78 string Type_;
79 string EntityLabel_;
80 string EntityAuthority_;
81 string AttributeLabel_;
82 string AttributeAuthority_;
83 string Format_;
84 string Unit_;
85 double Precision_;
86 long MaximumSubfieldLength_;
87 string Key_;
88
89
sb_Ddsh_Impsb_Ddsh_Imp90 sb_Ddsh_Imp()
91 :
92 Name_( UNVALUED_STRING ),
93 Type_( UNVALUED_STRING ),
94 EntityLabel_( UNVALUED_STRING ),
95 EntityAuthority_( UNVALUED_STRING ),
96 AttributeLabel_( UNVALUED_STRING ),
97 AttributeAuthority_( UNVALUED_STRING ),
98 Format_( UNVALUED_STRING ),
99 Unit_( UNVALUED_STRING ),
100 Precision_( UNVALUED_DOUBLE ),
101 MaximumSubfieldLength_( UNVALUED_LONG ),
102 Key_( UNVALUED_STRING )
103 {}
104
105 };
106
107
sb_Ddsh()108 sb_Ddsh::sb_Ddsh()
109 : imp_( new sb_Ddsh_Imp() )
110 {
111 setMnemonic("DDSH");
112 setID( 1 );
113
114
115 // initialize static domain types
116
117 if ( TYPE_domain.empty() )
118 {
119 TYPE_domain.insert( "ATPR" );
120 TYPE_domain.insert( "ATSC" );
121 TYPE_domain.insert( "CELL" );
122 }
123
124 if ( KEY_domain.empty() )
125 {
126 KEY_domain.insert( "NOKEY" );
127 KEY_domain.insert( "PKEY" );
128 KEY_domain.insert( "FKEY" );
129 KEY_domain.insert( "PFKEY" );
130 }
131
132 } // Ddsh ctor
133
134
~sb_Ddsh()135 sb_Ddsh::~sb_Ddsh()
136 {
137 delete imp_;
138 } // Ddsh dtor
139
140
141
142
143 static sio_8211Converter_I converter_I; // XXX should define these in
144 static sio_8211Converter_A converter_A; // XXX sio_8211Converter.h
145 static sio_8211Converter_R converter_R;
146
147 static sio_8211Schema schema_; // module specific schema
148
149
150 sio_8211Schema&
schema_()151 sb_Ddsh::schema_()
152 {
153 return ::schema_;
154 } // sb_Ddsh::schema_()
155
156
157
158
159 void
buildSpecificSchema_()160 sb_Ddsh::buildSpecificSchema_( )
161 {
162 schema_().push_back( sio_8211FieldFormat() );
163
164 sio_8211FieldFormat& field_format = schema_().back();
165
166 field_format.setDataStructCode( sio_8211FieldFormat::vector );
167 field_format.setDataTypeCode( sio_8211FieldFormat::mixed_data_type );
168 field_format.setName( "Data Dictionary/Schema" );
169 field_format.setTag( "DDSH" );
170
171
172 field_format.push_back( sio_8211SubfieldFormat() );
173
174 field_format.back().setLabel( "MODN" );
175 field_format.back().setType( sio_8211SubfieldFormat::A );
176 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
177 field_format.back().setConverter( &converter_A );
178
179 field_format.push_back( sio_8211SubfieldFormat() );
180
181 field_format.back().setLabel( "RCID" );
182 field_format.back().setType( sio_8211SubfieldFormat::I );
183 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
184 field_format.back().setConverter( &converter_I );
185
186 field_format.push_back( sio_8211SubfieldFormat() );
187
188 field_format.back().setLabel( "NAME" );
189 field_format.back().setType( sio_8211SubfieldFormat::A );
190 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
191 field_format.back().setConverter( &converter_A );
192
193
194 field_format.push_back( sio_8211SubfieldFormat() );
195
196 field_format.back().setLabel( "TYPE" );
197 field_format.back().setType( sio_8211SubfieldFormat::A );
198 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
199 field_format.back().setConverter( &converter_A );
200
201
202 field_format.push_back( sio_8211SubfieldFormat() );
203
204 field_format.back().setLabel( "ETLB" );
205 field_format.back().setType( sio_8211SubfieldFormat::A );
206 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
207 field_format.back().setConverter( &converter_A );
208
209
210 field_format.push_back( sio_8211SubfieldFormat() );
211
212 field_format.back().setLabel( "EUTH" );
213 field_format.back().setType( sio_8211SubfieldFormat::A );
214 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
215 field_format.back().setConverter( &converter_A );
216
217
218 field_format.push_back( sio_8211SubfieldFormat() );
219
220 field_format.back().setLabel( "ATLB" );
221 field_format.back().setType( sio_8211SubfieldFormat::A );
222 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
223 field_format.back().setConverter( &converter_A );
224
225
226 field_format.push_back( sio_8211SubfieldFormat() );
227
228 field_format.back().setLabel( "AUTH" );
229 field_format.back().setType( sio_8211SubfieldFormat::A );
230 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
231 field_format.back().setConverter( &converter_A );
232
233
234 field_format.push_back( sio_8211SubfieldFormat() );
235
236 field_format.back().setLabel( "FMT" );
237 field_format.back().setType( sio_8211SubfieldFormat::A );
238 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
239 field_format.back().setConverter( &converter_A );
240
241
242 field_format.push_back( sio_8211SubfieldFormat() );
243
244 field_format.back().setLabel( "UNIT" );
245 field_format.back().setType( sio_8211SubfieldFormat::A );
246 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
247 field_format.back().setConverter( &converter_A );
248
249
250 field_format.push_back( sio_8211SubfieldFormat() );
251
252 field_format.back().setLabel( "PREC" );
253 field_format.back().setType( sio_8211SubfieldFormat::R );
254 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
255 field_format.back().setConverter( &converter_R );
256
257
258 field_format.push_back( sio_8211SubfieldFormat() );
259
260 field_format.back().setLabel( "MXLN" );
261 field_format.back().setType( sio_8211SubfieldFormat::I );
262 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
263 field_format.back().setConverter( &converter_I );
264
265
266 field_format.push_back( sio_8211SubfieldFormat() );
267
268 field_format.back().setLabel( "KEY" );
269 field_format.back().setType( sio_8211SubfieldFormat::A );
270 field_format.back().setFormat( sio_8211SubfieldFormat::variable );
271 field_format.back().setConverter( &converter_A );
272
273
274 } // build__schema
275
276
277 static
278 bool
ingest_record_(sb_Ddsh & ddsh,sb_Ddsh_Imp & ddsh_imp,sc_Record const & record)279 ingest_record_( sb_Ddsh& ddsh, sb_Ddsh_Imp &ddsh_imp, sc_Record const& record )
280 {
281
282 // Make sure we have a record from an
283 // External Spatial Reference module.
284
285 sc_FieldCntr::const_iterator curfield;
286
287 if ( ! sb_Utils::getFieldByMnem( record,"DDSH",curfield) )
288 {
289 #ifdef SDTSXX_DEBUG
290 cerr << "sb_Ddsh::sb_Ddsh(sc_Record const&): "
291 << "Not an data dictionary/schema record.";
292 cerr << endl;
293 #endif
294 return false;
295 }
296
297
298 // We have a primary field from a module. Start// picking it apart.
299
300 sc_SubfieldCntr::const_iterator cursubfield;
301
302 string tmp_str;
303 long tmp_int;
304
305
306 // MODN
307 if (sb_Utils::getSubfieldByMnem(*curfield,"MODN",cursubfield))
308 {
309 cursubfield->getA( tmp_str );
310 ddsh.setMnemonic( tmp_str );
311 }
312
313
314 // RCID
315 if (sb_Utils::getSubfieldByMnem(*curfield,"RCID",cursubfield))
316 {
317 cursubfield->getI( tmp_int );
318 ddsh.setID( tmp_int );
319 }
320
321
322 // NAME
323 if (sb_Utils::getSubfieldByMnem(*curfield,"NAME",cursubfield))
324 {
325 cursubfield->getA( ddsh_imp.Name_);
326 }
327
328
329 // TYPE
330 if (sb_Utils::getSubfieldByMnem(*curfield,"TYPE",cursubfield))
331 {
332 cursubfield->getA( ddsh_imp.Type_);
333 }
334
335
336 // ETLB
337 if (sb_Utils::getSubfieldByMnem(*curfield,"ETLB",cursubfield))
338 {
339 cursubfield->getA( ddsh_imp.EntityLabel_);
340 }
341
342
343 // EUTH
344 if (sb_Utils::getSubfieldByMnem(*curfield,"EUTH",cursubfield))
345 {
346 cursubfield->getA( ddsh_imp.EntityAuthority_);
347 }
348
349
350 // ATLB
351 if (sb_Utils::getSubfieldByMnem(*curfield,"ATLB",cursubfield))
352 {
353 cursubfield->getA( ddsh_imp.AttributeLabel_);
354 }
355
356
357 // AUTH
358 if (sb_Utils::getSubfieldByMnem(*curfield,"AUTH",cursubfield))
359 {
360 cursubfield->getA( ddsh_imp.AttributeAuthority_);
361 }
362
363
364 // FMT
365 if (sb_Utils::getSubfieldByMnem(*curfield,"FMT",cursubfield))
366 {
367 cursubfield->getA( ddsh_imp.Format_);
368 }
369
370
371 // UNIT
372 if (sb_Utils::getSubfieldByMnem(*curfield,"UNIT",cursubfield))
373 {
374 cursubfield->getA( ddsh_imp.Unit_);
375 }
376
377
378 // PREC
379 if (sb_Utils::getSubfieldByMnem(*curfield,"PREC",cursubfield))
380 {
381 cursubfield->getR( ddsh_imp.Precision_);
382 }
383
384
385 // MXLN
386 if (sb_Utils::getSubfieldByMnem(*curfield,"MXLN",cursubfield))
387 {
388 cursubfield->getI( ddsh_imp.MaximumSubfieldLength_);
389 }
390
391
392 // KEY
393 if (sb_Utils::getSubfieldByMnem(*curfield,"KEY",cursubfield))
394 {
395 cursubfield->getA( ddsh_imp.Key_);
396 }
397
398
399 return true;
400
401
402 } // ingest_record_
403
404
405
406
407 bool
getName(string & val) const408 sb_Ddsh::getName( string& val ) const
409 {
410 if ( imp_->Name_ == UNVALUED_STRING )
411 return false;
412
413 val = imp_->Name_;
414
415 return true;
416 } // sb_Ddsh::getName
417
418
419 bool
getType(string & val) const420 sb_Ddsh::getType( string& val ) const
421 {
422 if ( imp_->Type_ == UNVALUED_STRING )
423 return false;
424
425 val.assign( imp_->Type_.begin(), imp_->Type_.end() );
426
427 return true;
428 } // sb_Ddsh::getType
429
430
431 bool
getEntityLabel(string & val) const432 sb_Ddsh::getEntityLabel( string& val ) const
433 {
434 if ( imp_->EntityLabel_ == UNVALUED_STRING )
435 return false;
436
437 val = imp_->EntityLabel_;
438
439 return true;
440 } // sb_Ddsh::getEntityLabel
441
442
443 bool
getEntityAuthority(string & val) const444 sb_Ddsh::getEntityAuthority( string& val ) const
445 {
446 if ( imp_->EntityAuthority_ == UNVALUED_STRING )
447 return false;
448
449 val = imp_->EntityAuthority_;
450
451 return true;
452 } // sb_Ddsh::getEntityAuthority
453
454
455 bool
getAttributeLabel(string & val) const456 sb_Ddsh::getAttributeLabel( string& val ) const
457 {
458 if ( imp_->AttributeLabel_ == UNVALUED_STRING )
459 return false;
460
461 val = imp_->AttributeLabel_;
462
463 return true;
464 } // sb_Ddsh::getAttributeLabel
465
466
467 bool
getAttributeAuthority(string & val) const468 sb_Ddsh::getAttributeAuthority( string& val ) const
469 {
470 if ( imp_->AttributeAuthority_ == UNVALUED_STRING )
471 return false;
472
473 val = imp_->AttributeAuthority_;
474
475 return true;
476 } // sb_Ddsh::getAttributeAuthority
477
478
479 bool
getFormat(string & val) const480 sb_Ddsh::getFormat( string& val ) const
481 {
482 if ( imp_->Format_ == UNVALUED_STRING )
483 return false;
484
485 val = imp_->Format_;
486
487 return true;
488 } // sb_Ddsh::getFormat
489
490
491 bool
getUnit(string & val) const492 sb_Ddsh::getUnit( string& val ) const
493 {
494 if ( imp_->Unit_ == UNVALUED_STRING )
495 return false;
496
497 val = imp_->Unit_;
498
499 return true;
500 } // sb_Ddsh::getUnit
501
502
503 bool
getPrecision(double & val) const504 sb_Ddsh::getPrecision( double& val ) const
505 {
506 if ( imp_->Precision_ == UNVALUED_DOUBLE )
507 return false;
508
509 val = imp_->Precision_;
510
511 return true;
512 } // sb_Ddsh::getPrecision
513
514
515 bool
getMaximumSubfieldLength(long & val) const516 sb_Ddsh::getMaximumSubfieldLength( long& val ) const
517 {
518 if ( imp_->MaximumSubfieldLength_ == UNVALUED_LONG )
519 return false;
520
521 val = imp_->MaximumSubfieldLength_;
522
523 return true;
524 } // sb_Ddsh::getMaximumSubfieldLength
525
526
527 bool
getKey(string & val) const528 sb_Ddsh::getKey( string& val ) const
529 {
530 if ( imp_->Key_ == UNVALUED_STRING )
531 return false;
532
533 val = imp_->Key_;
534
535 return true;
536 } // sb_Ddsh::getKey
537
538
539
540 bool
getRecord(sc_Record & record) const541 sb_Ddsh::getRecord( sc_Record & record ) const
542 {
543 record.clear(); // start with a clean slate
544
545 // first field, which contains module name and record number
546
547 record.push_back( sc_Field() );
548
549 record.back().setMnemonic( "DDSH" );
550 record.back().setName( "Data Dictionary/Schema" );
551
552 string tmp_str;
553 double tmp_double;
554 long tmp_long;
555
556 getMnemonic( tmp_str );
557 sb_Utils::add_subfield( record.back(), "MODN", tmp_str );
558 sb_Utils::add_subfield( record.back(), "RCID", getID() );
559
560 if ( getName( tmp_str) )
561 {
562 sb_Utils::add_subfield( record.back(),"NAME", tmp_str );
563 }
564 else
565 {
566 return false;
567 }
568
569
570 if ( getType( tmp_str) )
571 {
572
573 if ( sb_Utils::valid_domain( tmp_str, TYPE_domain ) )
574 {
575 sb_Utils::add_subfield( record.back(),"TYPE", tmp_str );
576 }
577 else
578 {
579 return false;
580 }
581 }
582 else
583 {
584 sb_Utils::add_empty_subfield( record.back(),"TYPE", sc_Subfield::is_A );
585 }
586
587 if ( getEntityLabel( tmp_str) )
588 {
589 sb_Utils::add_subfield( record.back(),"ETLB", tmp_str );
590 }
591 else
592 {
593 sb_Utils::add_empty_subfield( record.back(),"ETLB", sc_Subfield::is_A );
594 }
595
596 if ( getEntityAuthority( tmp_str) )
597 {
598 sb_Utils::add_subfield( record.back(),"EUTH", tmp_str );
599 }
600 else
601 {
602 sb_Utils::add_empty_subfield( record.back(),"EUTH", sc_Subfield::is_A );
603 }
604
605 if ( getAttributeLabel( tmp_str) )
606 {
607 sb_Utils::add_subfield( record.back(),"ATLB", tmp_str );
608 }
609 else
610 {
611 sb_Utils::add_empty_subfield( record.back(),"ATLB", sc_Subfield::is_A );
612 }
613
614 if ( getAttributeAuthority( tmp_str) )
615 {
616 sb_Utils::add_subfield( record.back(),"AUTH", tmp_str );
617 }
618 else
619 {
620 sb_Utils::add_empty_subfield( record.back(),"AUTH", sc_Subfield::is_A );
621 }
622
623 if ( getFormat( tmp_str) )
624 {
625 sb_Utils::add_subfield( record.back(),"FMT", tmp_str );
626 }
627 else
628 {
629 sb_Utils::add_empty_subfield( record.back(),"FMT", sc_Subfield::is_A );
630 }
631
632 if ( getUnit( tmp_str) )
633 {
634 sb_Utils::add_subfield( record.back(),"UNIT", tmp_str );
635 }
636 else
637 {
638 sb_Utils::add_empty_subfield( record.back(),"UNIT" , sc_Subfield::is_A);
639 }
640
641 if ( getPrecision( tmp_double) )
642 {
643 sb_Utils::add_subfield( record.back(),"PREC", tmp_double );
644 }
645 else
646 {
647 sb_Utils::add_empty_subfield( record.back(),"PREC", sc_Subfield::is_R );
648 }
649
650 if ( getMaximumSubfieldLength( tmp_long) )
651 {
652 sb_Utils::add_subfield( record.back(),"MXLN", tmp_long );
653 }
654 else
655 {
656 sb_Utils::add_empty_subfield( record.back(),"MXLN", sc_Subfield::is_I );
657 }
658
659 if ( getKey( tmp_str) )
660 {
661 if ( sb_Utils::valid_domain( tmp_str, KEY_domain ) )
662 {
663 sb_Utils::add_subfield( record.back(),"KEY", tmp_str );
664 }
665 else
666 {
667 return false;
668 }
669 }
670 else
671 {
672 sb_Utils::add_empty_subfield( record.back(),"MXLN", sc_Subfield::is_A );
673 }
674
675 return true;
676
677
678 } // Ddsh::getRecord
679
680
681
682
683 bool
setName(string const & val)684 sb_Ddsh::setName( string const& val )
685 {
686 imp_->Name_ = val;
687
688 return true;
689 } // sb_Ddsh::setName
690
691
692 bool
setType(string const & val)693 sb_Ddsh::setType( string const& val )
694 {
695 if ( sb_Utils::valid_domain( val, TYPE_domain ) )
696 imp_->Type_ = val;
697 else
698 return false;
699
700 return true;
701 } // sb_Ddsh::setType
702
703
704 bool
setEntityLabel(string const & val)705 sb_Ddsh::setEntityLabel( string const& val )
706 {
707 imp_->EntityLabel_ = val;
708
709 return true;
710 } // sb_Ddsh::setEntityLabel
711
712
713 bool
setEntityAuthority(string const & val)714 sb_Ddsh::setEntityAuthority( string const& val )
715 {
716 imp_->EntityAuthority_ = val;
717
718 return true;
719 } // sb_Ddsh::setEntityAuthority
720
721
722 bool
setAttributeLabel(string const & val)723 sb_Ddsh::setAttributeLabel( string const& val )
724 {
725 imp_->AttributeLabel_ = val;
726
727 return true;
728 } // sb_Ddsh::setAttributeLabel
729
730
731 bool
setAttributeAuthority(string const & val)732 sb_Ddsh::setAttributeAuthority( string const& val )
733 {
734 imp_->AttributeAuthority_ = val;
735
736 return true;
737 } // sb_Ddsh::setAttributeAuthority
738
739
740 bool
setFormat(string const & val)741 sb_Ddsh::setFormat( string const& val )
742 {
743 imp_->Format_ = val;
744
745 return true;
746 } // sb_Ddsh::setFormat
747
748
749 bool
setUnit(string const & val)750 sb_Ddsh::setUnit( string const& val )
751 {
752 imp_->Unit_ = val;
753
754 return true;
755 } // sb_Ddsh::setUnit
756
757
758 bool
setPrecision(double val)759 sb_Ddsh::setPrecision( double val )
760 {
761 imp_->Precision_ = val;
762
763 return true;
764 } // sb_Ddsh::setPrecision
765
766
767 bool
setMaximumSubfieldLength(long val)768 sb_Ddsh::setMaximumSubfieldLength( long val )
769 {
770 imp_->MaximumSubfieldLength_ = val;
771
772 return true;
773 } // sb_Ddsh::setMaximumSubfieldLength
774
775
776 bool
setKey(string const & val)777 sb_Ddsh::setKey( string const& val )
778 {
779 if ( sb_Utils::valid_domain( val, KEY_domain ) )
780 imp_->Key_ = val;
781 else
782 return false;
783
784 return true;
785 } // sb_Ddsh::setKey
786
787
788 bool
setRecord(sc_Record const & record)789 sb_Ddsh::setRecord( sc_Record const& record )
790 {
791 return ingest_record_( *this, *imp_, record );
792 } // sb_Ddsh::setRecord
793
794
795
796 void
unDefineName()797 sb_Ddsh::unDefineName( )
798 {
799 imp_->Name_ = UNVALUED_STRING;
800 } // sb_Ddsh::unDefineName
801
802
803 void
unDefineType()804 sb_Ddsh::unDefineType( )
805 {
806 imp_->Type_ = UNVALUED_STRING;
807 } // sb_Ddsh::unDefineType
808
809
810 void
unDefineEntityLabel()811 sb_Ddsh::unDefineEntityLabel( )
812 {
813 imp_->EntityLabel_ = UNVALUED_STRING;
814 } // sb_Ddsh::unDefineEntityLabel
815
816
817 void
unDefineEntityAuthority()818 sb_Ddsh::unDefineEntityAuthority( )
819 {
820 imp_->EntityAuthority_ = UNVALUED_STRING;
821 } // sb_Ddsh::unDefineEntityAuthority
822
823
824 void
unDefineAttributeLabel()825 sb_Ddsh::unDefineAttributeLabel( )
826 {
827 imp_->AttributeLabel_ = UNVALUED_STRING;
828 } // sb_Ddsh::unDefineAttributeLabel
829
830
831 void
unDefineAttributeAuthority()832 sb_Ddsh::unDefineAttributeAuthority( )
833 {
834 imp_->AttributeAuthority_ = UNVALUED_STRING;
835 } // sb_Ddsh::unDefineAttributeAuthority
836
837
838 void
unDefineFormat()839 sb_Ddsh::unDefineFormat( )
840 {
841 imp_->Format_ = UNVALUED_STRING;
842 } // sb_Ddsh::unDefineFormat
843
844
845 void
unDefineUnit()846 sb_Ddsh::unDefineUnit( )
847 {
848 imp_->Unit_ = UNVALUED_STRING;
849 } // sb_Ddsh::unDefineUnit
850
851
852 void
unDefinePrecision()853 sb_Ddsh::unDefinePrecision( )
854 {
855 imp_->Precision_ = UNVALUED_DOUBLE;
856 } // sb_Ddsh::unDefinePrecision
857
858
859 void
unDefineMaximumSubfieldLength()860 sb_Ddsh::unDefineMaximumSubfieldLength( )
861 {
862 imp_->MaximumSubfieldLength_ = UNVALUED_LONG;
863 } // sb_Ddsh::unDefineMaximumSubfieldLength
864
865
866 void
unDefineKey()867 sb_Ddsh::unDefineKey( )
868 {
869 imp_->Key_ = UNVALUED_STRING;
870 } // sb_Ddsh::unDefineKey
871
872
873