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