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_Cats.cpp,v 1.7 2002/11/24 22:07:42 mcoletti Exp $
13 //
14 
15 #include <sdts++/builder/sb_Cats.h>
16 
17 
18 
19 #include <iostream>
20 #include <strstream>
21 
22 #include <limits.h>
23 #include <float.h>
24 
25 #ifndef INCLUDED_SB_UTILS_H
26 #include <sdts++/builder/sb_Utils.h>
27 #endif
28 
29 #ifndef INCLUDED_SB_FOREIGNID_H
30 #include <sdts++/builder/sb_ForeignID.h>
31 #endif
32 
33 #ifndef INCLUDED_SC_RECORD_H
34 #include <sdts++/container/sc_Record.h>
35 #endif
36 
37 #ifndef INCLUDED_SC_FIELD_H
38 #include <sdts++/container/sc_Field.h>
39 #endif
40 
41 #ifndef INCLUDED_SC_SUBFIELD_H
42 #include <sdts++/container/sc_Subfield.h>
43 #endif
44 
45 #ifndef INCLUDED_SIO_8211CONVERTER_H
46 #include <sdts++/io/sio_8211Converter.h>
47 #endif
48 
49 
50 using namespace std;
51 
52 
53 static const char* ident_ = "$Id: sb_Cats.cpp,v 1.7 2002/11/24 22:07:42 mcoletti Exp $";
54 
55 // Strings and integers are initialized with these values; they are used
56 // to indicate whether a given module value has been assigned a value or not.
57 
58 // (XXX I arbitrarily chose 0x4 as the sentinal value.  I hate ad hoc crap.)
59 
60 static const string  UNVALUED_STRING(1, static_cast<string::value_type>(0x4) );
61 
62 static const long    UNVALUED_LONG   = INT_MIN;
63 
64 static const double  UNVALUED_DOUBLE = DBL_MAX;
65 
66 struct sb_Cats_Imp
67 {
68   string   Name_;
69   string   Type_;
70   string   Domain_;
71   string   Map_;
72   string   Them_;
73   string   AggregateObject_;
74   string   AggregateObjectType_;
75   string   Comment_;
76 
77 
sb_Cats_Impsb_Cats_Imp78   sb_Cats_Imp()
79     :
80     Name_( UNVALUED_STRING ),
81     Type_( UNVALUED_STRING ),
82     Domain_( UNVALUED_STRING ),
83     Map_( UNVALUED_STRING ),
84     Them_( UNVALUED_STRING ),
85     AggregateObject_( UNVALUED_STRING ),
86     AggregateObjectType_( UNVALUED_STRING ),
87     Comment_( UNVALUED_STRING )
88   {}
89 
90 };
91 
92 
sb_Cats()93 sb_Cats::sb_Cats()
94   : imp_( new sb_Cats_Imp() )
95 {
96   setMnemonic("CATS");
97   setID( 1 );
98 
99 
100   // insert static initializers
101 
102 } // Cats ctor
103 
104 
~sb_Cats()105 sb_Cats::~sb_Cats()
106 {
107   delete imp_;
108 } // Cats dtor
109 
110 
111 
112 
113 static sio_8211Converter_I converter_I; // XXX should define these in
114 static sio_8211Converter_A converter_A; // XXX sio_8211Converter.h
115 static sio_8211Converter_R converter_R;
116 static sio_8211Converter_C converter_C;
117 
118 static sio_8211Schema schema_; // module specific schema
119 
120 
121 
122 sio_8211Schema&
schema_()123 sb_Cats::schema_()
124 {
125    return ::schema_;
126 } // sb_Cats::schema_
127 
128 
129 
130 
131 void
buildSpecificSchema_()132 sb_Cats::buildSpecificSchema_( )
133 {
134   schema_().push_back( sio_8211FieldFormat() );
135 
136   sio_8211FieldFormat& field_format = schema_().back();
137 
138   field_format.setDataStructCode( sio_8211FieldFormat::vector );
139   field_format.setDataTypeCode( sio_8211FieldFormat::mixed_data_type );
140   field_format.setName( "Catalog/Spatial Domain" );
141   field_format.setTag( "CATS" );
142 
143 
144   field_format.push_back( sio_8211SubfieldFormat() );
145 
146   field_format.back().setLabel( "MODN" );
147   field_format.back().setType( sio_8211SubfieldFormat::A );
148   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
149   field_format.back().setConverter( &converter_A );
150 
151   field_format.push_back( sio_8211SubfieldFormat() );
152 
153   field_format.back().setLabel( "RCID" );
154   field_format.back().setType( sio_8211SubfieldFormat::I );
155   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
156   field_format.back().setConverter( &converter_I );
157 
158   field_format.push_back( sio_8211SubfieldFormat() );
159 
160   field_format.back().setLabel( "NAME" );
161   field_format.back().setType( sio_8211SubfieldFormat::A );
162   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
163   field_format.back().setConverter( &converter_A );
164 
165 
166   field_format.push_back( sio_8211SubfieldFormat() );
167 
168   field_format.back().setLabel( "TYPE" );
169   field_format.back().setType( sio_8211SubfieldFormat::A );
170   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
171   field_format.back().setConverter( &converter_A );
172 
173 
174   field_format.push_back( sio_8211SubfieldFormat() );
175 
176   field_format.back().setLabel( "DOMN" );
177   field_format.back().setType( sio_8211SubfieldFormat::A );
178   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
179   field_format.back().setConverter( &converter_A );
180 
181 
182   field_format.push_back( sio_8211SubfieldFormat() );
183 
184   field_format.back().setLabel( "MAP" );
185   field_format.back().setType( sio_8211SubfieldFormat::A );
186   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
187   field_format.back().setConverter( &converter_A );
188 
189 
190   field_format.push_back( sio_8211SubfieldFormat() );
191   field_format.back().setLabel( "THEM" );
192   field_format.back().setType( sio_8211SubfieldFormat::A );
193   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
194   field_format.back().setConverter( &converter_A );
195 
196 
197   field_format.push_back( sio_8211SubfieldFormat() );
198 
199   field_format.back().setLabel( "AGOB" );
200   field_format.back().setType( sio_8211SubfieldFormat::A );
201   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
202   field_format.back().setConverter( &converter_A );
203 
204 
205   field_format.push_back( sio_8211SubfieldFormat() );
206 
207   field_format.back().setLabel( "AGTP" );
208   field_format.back().setType( sio_8211SubfieldFormat::A );
209   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
210   field_format.back().setConverter( &converter_A );
211 
212 
213   field_format.push_back( sio_8211SubfieldFormat() );
214 
215   field_format.back().setLabel( "COMT" );
216   field_format.back().setType( sio_8211SubfieldFormat::A );
217   field_format.back().setFormat( sio_8211SubfieldFormat::variable );
218   field_format.back().setConverter( &converter_A );
219 
220 
221 } // build__schema
222 
223 
224 static
225 bool
ingest_record_(sb_Cats & cats,sb_Cats_Imp & cats_imp,sc_Record const & record)226 ingest_record_( sb_Cats& cats, sb_Cats_Imp &cats_imp, sc_Record const& record )
227 {
228 
229   // Make sure we have a record from an
230   // External Spatial Reference module.
231 
232   sc_FieldCntr::const_iterator curfield;
233 
234   if ( ! sb_Utils::getFieldByMnem( record,"CATS",curfield) )
235   {
236 #ifdef SDTSXX_DEBUG
237     cerr << "sb_Cats::sb_Cats(sc_Record const&): "
238          << "Not an catalog/spatial domain record.";
239     cerr << endl;
240 #endif
241     return false;
242   }
243 
244 
245   // We have a primary field from a  module. Start// picking it apart.
246 
247   sc_SubfieldCntr::const_iterator cursubfield;
248 
249   string tmp_str;
250   long   tmp_int;
251 
252 
253   // MODN
254   if (sb_Utils::getSubfieldByMnem(*curfield,"MODN",cursubfield))
255   {
256     cursubfield->getA( tmp_str );
257     cats.setMnemonic( tmp_str );
258   }
259 
260 
261   // RCID
262   if (sb_Utils::getSubfieldByMnem(*curfield,"RCID",cursubfield))
263   {
264     cursubfield->getI( tmp_int );
265     cats.setID( tmp_int );
266   }
267 
268 
269   // NAME
270   if (sb_Utils::getSubfieldByMnem(*curfield,"NAME",cursubfield))
271   {
272     cursubfield->getA( cats_imp.Name_);
273   }
274 
275 
276   // TYPE
277   if (sb_Utils::getSubfieldByMnem(*curfield,"TYPE",cursubfield))
278   {
279     cursubfield->getA( cats_imp.Type_);
280   }
281 
282 
283   // DOMN
284   if (sb_Utils::getSubfieldByMnem(*curfield,"DOMN",cursubfield))
285   {
286     cursubfield->getA( cats_imp.Domain_);
287   }
288 
289 
290   // MAP
291   if (sb_Utils::getSubfieldByMnem(*curfield,"MAP",cursubfield))
292   {
293     cursubfield->getA( cats_imp.Map_);
294   }
295 
296 
297   // THEM
298   if (sb_Utils::getSubfieldByMnem(*curfield,"THEM",cursubfield))
299   {
300      cursubfield->getA( cats_imp.Them_);
301   }
302   else
303   {
304      return false;
305   }
306 
307 
308   // AGOB
309   if (sb_Utils::getSubfieldByMnem(*curfield,"AGOB",cursubfield))
310   {
311     cursubfield->getA( cats_imp.AggregateObject_);
312   }
313 
314 
315   // AGTP
316   if (sb_Utils::getSubfieldByMnem(*curfield,"AGTP",cursubfield))
317   {
318     cursubfield->getA( cats_imp.AggregateObjectType_);
319   }
320 
321 
322   // COMT
323   if (sb_Utils::getSubfieldByMnem(*curfield,"COMT",cursubfield))
324   {
325     cursubfield->getA( cats_imp.Comment_);
326   }
327 
328 
329   return true;
330 
331 
332 } // ingest_record_
333 
334 
335 
336 
337 bool
getName(string & val) const338 sb_Cats::getName( string& val ) const
339 {
340   if ( imp_->Name_ == UNVALUED_STRING )
341     return false;
342 
343   val = imp_->Name_;
344 
345   return true;
346 } // sb_Cats::getName
347 
348 
349 bool
getType(string & val) const350 sb_Cats::getType( string& val ) const
351 {
352   if ( imp_->Type_ == UNVALUED_STRING )
353     return false;
354 
355   val = imp_->Type_;
356 
357   return true;
358 } // sb_Cats::getType
359 
360 
361 bool
getDomain(string & val) const362 sb_Cats::getDomain( string& val ) const
363 {
364   if ( imp_->Domain_ == UNVALUED_STRING )
365     return false;
366 
367   val = imp_->Domain_;
368 
369   return true;
370 } // sb_Cats::getDomain
371 
372 
373 bool
getMap(string & val) const374 sb_Cats::getMap( string& val ) const
375 {
376   if ( imp_->Map_ == UNVALUED_STRING )
377     return false;
378 
379   val = imp_->Map_;
380 
381   return true;
382 } // sb_Cats::getMap
383 
384 
385 bool
getThem(string & val) const386 sb_Cats::getThem( string& val ) const
387 {
388   if ( imp_->Them_ == UNVALUED_STRING )
389     return false;
390 
391   val = imp_->Them_;
392 
393   return true;
394 } // sb_Cats::getThem
395 
396 
397 bool
getAggregateObject(string & val) const398 sb_Cats::getAggregateObject( string& val ) const
399 {
400   if ( imp_->AggregateObject_ == UNVALUED_STRING )
401     return false;
402 
403   val = imp_->AggregateObject_;
404 
405   return true;
406 } // sb_Cats::getAggregateObject
407 
408 
409 bool
getAggregateObjectType(string & val) const410 sb_Cats::getAggregateObjectType( string& val ) const
411 {
412   if ( imp_->AggregateObjectType_ == UNVALUED_STRING )
413     return false;
414 
415   val = imp_->AggregateObjectType_;
416 
417   return true;
418 } // sb_Cats::getAggregateObjectType
419 
420 
421 bool
getComment(string & val) const422 sb_Cats::getComment( string& val ) const
423 {
424   if ( imp_->Comment_ == UNVALUED_STRING )
425     return false;
426 
427   val = imp_->Comment_;
428 
429   return true;
430 } // sb_Cats::getComment
431 
432 
433 
434 
435 
436 bool
getRecord(sc_Record & record) const437 sb_Cats::getRecord( sc_Record & record ) const
438 {
439   record.clear();               // start with a clean slate
440 
441   // first field, which contains module name and record number
442 
443   record.push_back( sc_Field() );
444 
445   record.back().setMnemonic( "CATS" );
446 
447   record.back().setName( "Catalog/Spatial Domain" );
448 
449   string tmp_str;
450 
451   getMnemonic( tmp_str );
452   sb_Utils::add_subfield( record.back(), "MODN", tmp_str );
453   sb_Utils::add_subfield( record.back(), "RCID", getID() );
454 
455   if ( getName( tmp_str ) )
456   {
457     sb_Utils::add_subfield( record.back(),"NAME", tmp_str );
458   }
459   else
460   {
461     sb_Utils::add_empty_subfield( record.back(), "NAME", sc_Subfield::is_A );
462   }
463 
464 
465   if ( getType( tmp_str ) )
466   {
467     sb_Utils::add_subfield( record.back(),"TYPE", tmp_str );
468   }
469   else
470   {
471     sb_Utils::add_empty_subfield( record.back(), "TYPE", sc_Subfield::is_A );
472   }
473 
474 
475   if ( getDomain( tmp_str ) )
476   {
477     sb_Utils::add_subfield( record.back(),"DOMN", tmp_str );
478   }
479   else
480   {
481     sb_Utils::add_empty_subfield( record.back(), "DOMN", sc_Subfield::is_A );
482   }
483 
484 
485   if ( getMap( tmp_str ) )
486   {
487     sb_Utils::add_subfield( record.back(),"MAP", tmp_str );
488   }
489   else
490   {
491     sb_Utils::add_empty_subfield( record.back(), "MAP", sc_Subfield::is_A );
492   }
493 
494 
495   if ( getThem( tmp_str ) )
496   {
497      sb_Utils::add_subfield( record.back(),"THEM", tmp_str );
498   }
499   else
500   {
501      sb_Utils::add_empty_subfield( record.back(), "THEM", sc_Subfield::is_A );
502   }
503 
504 
505   if ( getAggregateObject( tmp_str ) )
506   {
507     sb_Utils::add_subfield( record.back(),"AGOB", tmp_str );
508   }
509   else
510   {
511     sb_Utils::add_empty_subfield( record.back(), "AGOB", sc_Subfield::is_A );
512   }
513 
514 
515   if ( getAggregateObjectType( tmp_str ) )
516   {
517     sb_Utils::add_subfield( record.back(),"AGTP", tmp_str );
518   }
519   else
520   {
521     sb_Utils::add_empty_subfield( record.back(), "AGTP", sc_Subfield::is_A );
522   }
523 
524 
525   if ( getComment( tmp_str ) )
526   {
527     sb_Utils::add_subfield( record.back(),"COMT", tmp_str );
528   }
529   else
530   {
531     sb_Utils::add_empty_subfield( record.back(), "COMT", sc_Subfield::is_A );
532   }
533 
534 
535   return true;
536 
537 
538 } // Cats::getRecord
539 
540 
541 
542 
543 bool
setName(string const & val)544 sb_Cats::setName( string const& val )
545 {
546   imp_->Name_ = val;
547 
548   return true;
549 } // sb_Cats::setName
550 
551 
552 bool
setType(string const & val)553 sb_Cats::setType( string const& val )
554 {
555   imp_->Type_ = val;
556 
557   return true;
558 } // sb_Cats::setType
559 
560 
561 bool
setDomain(string const & val)562 sb_Cats::setDomain( string const& val )
563 {
564   imp_->Domain_ = val;
565 
566   return true;
567 } // sb_Cats::setDomain
568 
569 
570 bool
setMap(string const & val)571 sb_Cats::setMap( string const& val )
572 {
573   imp_->Map_ = val;
574 
575   return true;
576 } // sb_Cats::setMap
577 
578 
579 bool
setThem(string const & val)580 sb_Cats::setThem( string const& val )
581 {
582   imp_->Them_ = val;
583 
584   return true;
585 } // sb_Cats::setThem
586 
587 
588 bool
setAggregateObject(string const & val)589 sb_Cats::setAggregateObject( string const& val )
590 {
591   imp_->AggregateObject_ = val;
592 
593   return true;
594 } // sb_Cats::setAggregateObject
595 
596 
597 bool
setAggregateObjectType(string const & val)598 sb_Cats::setAggregateObjectType( string const& val )
599 {
600   imp_->AggregateObjectType_ = val;
601 
602   return true;
603 } // sb_Cats::setAggregateObjectType
604 
605 
606 bool
setComment(string const & val)607 sb_Cats::setComment( string const& val )
608 {
609   imp_->Comment_ = val;
610 
611   return true;
612 } // sb_Cats::setComment
613 
614 
615 bool
setRecord(sc_Record const & record)616 sb_Cats::setRecord( sc_Record const& record )
617 {
618   return ingest_record_( *this, *imp_, record );
619 } // sb_Cats::setRecord
620 
621 
622 
623 
624 void
unDefineName()625 sb_Cats::unDefineName( )
626 {
627   imp_->Name_ = UNVALUED_STRING;
628 } // sb_Cats::unDefineName
629 
630 
631 void
unDefineType()632 sb_Cats::unDefineType( )
633 {
634   imp_->Type_ = UNVALUED_STRING;
635 } // sb_Cats::unDefineType
636 
637 
638 void
unDefineDomain()639 sb_Cats::unDefineDomain( )
640 {
641   imp_->Domain_ = UNVALUED_STRING;
642 } // sb_Cats::unDefineDomain
643 
644 
645 void
unDefineMap()646 sb_Cats::unDefineMap( )
647 {
648   imp_->Map_ = UNVALUED_STRING;
649 } // sb_Cats::unDefineMap
650 
651 
652 void
unDefineThem()653 sb_Cats::unDefineThem( )
654 {
655   imp_->Them_ = UNVALUED_STRING;
656 } // sb_Cats::unDefineThem
657 
658 
659 void
unDefineAggregateObject()660 sb_Cats::unDefineAggregateObject( )
661 {
662   imp_->AggregateObject_ = UNVALUED_STRING;
663 } // sb_Cats::unDefineAggregateObject
664 
665 
666 void
unDefineAggregateObjectType()667 sb_Cats::unDefineAggregateObjectType( )
668 {
669   imp_->AggregateObjectType_ = UNVALUED_STRING;
670 } // sb_Cats::unDefineAggregateObjectType
671 
672 
673 void
unDefineComment()674 sb_Cats::unDefineComment( )
675 {
676   imp_->Comment_ = UNVALUED_STRING;
677 } // sb_Cats::unDefineComment
678 
679 
680