Sierra Toolkit  Version of the Day
String.hpp
Go to the documentation of this file.
1 /*--------------------------------------------------------------------*/
2 /* Copyright 2003 - 2008 Sandia Corporation. */
3 /* Under the terms of Contract DE-AC04-94AL85000, there is a */
4 /* non-exclusive license for use of this work by or on behalf */
5 /* of the U.S. Government. Export of this program may require */
6 /* a license from the United States Government. */
7 /*--------------------------------------------------------------------*/
8 
9 #ifndef STK_UTIL_DIAG_String_h
10 #define STK_UTIL_DIAG_String_h
11 
12 #ifdef USE_CISTRING
13 
14 #include <stk_util/util/cistring.hpp>
15 
16 namespace sierra {
17 
18 typedef cistring String;
19 typedef cistring Identifier;
20 typedef cistring ParamId;
21 
22 } // namespace sierra
23 
24 #else
25 
84 #include <iosfwd>
85 #include <string>
86 
87 namespace sierra {
88 
93 
94 struct char_simple_traits ;
95 
96 struct char_label_traits ;
97 
99 template<typename T1, typename T2> struct Precedence ;
100 
101 template<typename T> struct Precedence<T, T> { typedef T Type ; };
102 
103 template<>
105  typedef char_label_traits Type ;
106 };
107 
108 template<>
109 struct Precedence<char_label_traits, char_simple_traits> {
110  typedef char_label_traits Type ;
111 };
112 
116 template<class CharTraits> class StringBase ;
117 
124 
125 }
126 
127 //----------------------------------------------------------------------
128 // Binary Operators:
129 
130 namespace sierra {
131 
132 template<class CT1, class CT2>
133 bool operator== ( const StringBase<CT1> &, const StringBase<CT2> & );
134 
135 template<class CT1, class CT2>
136 bool operator!= ( const StringBase<CT1> &, const StringBase<CT2> & );
137 
138 template<class CT1, class CT2>
139 bool operator< ( const StringBase<CT1> &, const StringBase<CT2> & );
140 
141 template<class CT1, class CT2>
142 bool operator> ( const StringBase<CT1> &, const StringBase<CT2> & );
143 
144 template<class CT1, class CT2>
145 bool operator<= ( const StringBase<CT1> &, const StringBase<CT2> & );
146 
147 template<class CT1, class CT2>
148 bool operator>= ( const StringBase<CT1> &, const StringBase<CT2> & );
149 
150 
151 template<class CT1>
152 bool operator== ( const StringBase<CT1> &, const std::string & );
153 
154 template<class CT1>
155 bool operator!= ( const StringBase<CT1> &, const std::string & );
156 
157 template<class CT1>
158 bool operator< ( const StringBase<CT1> &, const std::string & );
159 
160 template<class CT1>
161 bool operator> ( const StringBase<CT1> &, const std::string & );
162 
163 template<class CT1>
164 bool operator<= ( const StringBase<CT1> &, const std::string & );
165 
166 template<class CT1>
167 bool operator>= ( const StringBase<CT1> &, const std::string & );
168 
169 
170 template<class CT1>
171 bool operator== ( const StringBase<CT1> &, const char * );
172 
173 template<class CT1>
174 bool operator!= ( const StringBase<CT1> &, const char * );
175 
176 template<class CT1>
177 bool operator< ( const StringBase<CT1> &, const char * );
178 
179 template<class CT1>
180 bool operator> ( const StringBase<CT1> &, const char * );
181 
182 template<class CT1>
183 bool operator<= ( const StringBase<CT1> &, const char * );
184 
185 template<class CT1>
186 bool operator>= ( const StringBase<CT1> &, const char * );
187 
188 
189 template<class CT1>
190 bool operator== (const char *, const StringBase<CT1> & );
191 
192 template<class CT1>
193 bool operator!= (const char *, const StringBase<CT1> & );
194 
195 template<class CT1>
196 bool operator< (const char *, const StringBase<CT1> & );
197 
198 template<class CT1>
199 bool operator> (const char *, const StringBase<CT1> & );
200 
201 template<class CT1>
202 bool operator<= (const char *, const StringBase<CT1> & );
203 
204 template<class CT1>
205 bool operator>= (const char *, const StringBase<CT1> & );
206 
207 
208 template<class CT1>
209 bool operator== (const std::string &, const StringBase<CT1> &);
210 
211 template<class CT1>
212 bool operator!= (const std::string &, const StringBase<CT1> &);
213 
214 template<class CT1>
215 bool operator< (const std::string &, const StringBase<CT1> &);
216 
217 template<class CT1>
218 bool operator> (const std::string &, const StringBase<CT1> &);
219 
220 template<class CT1>
221 bool operator<= (const std::string &, const StringBase<CT1> &);
222 
223 template<class CT1>
224 bool operator>= (const std::string &, const StringBase<CT1> &);
225 
226 
227 
228 std::ostream &
229 operator<<( std::ostream & os, const sierra::String &s);
230 
231 std::istream &
232 operator>>( std::istream & is, sierra::String &s );
233 
234 std::ostream &
235 operator<<( std::ostream & os, const sierra::Identifier &s);
236 
237 std::istream &
238 operator>>( std::istream & is, sierra::Identifier &s );
239 
240 }
241 
242 //----------------------------------------------------------------------
243 
244 namespace sierra {
245 
246 namespace implementation {
247 
248 union StringData {
249 
250  // Required: buf_len % sizeof(long) == 0 && buf_len > sizeof(Large)
251  enum { buf_len = 32 };
252  enum { off_len = buf_len - 1 };
253  enum { max_len = buf_len - 2 };
254 
255  struct Large {
256  char * ptr ; // Pointer to allocated memory
257  size_t len ; // Length of string
258  size_t siz ; // Allocated size
259  } large ;
260 
261  char small[ buf_len ];
262 
263  StringData();
264  ~StringData();
265 
266  size_t len() const ;
267  const char * c_str() const ;
268  char * c_str();
269 
271  char * mem( const char *, size_t n );
272 };
273 
274 }
275 
276 //----------------------------------------------------------------------
277 
278 template<class CT>
279 class StringBase {
280 public:
281  typedef const char * const_iterator;
282  typedef char * iterator;
283 
284  // Types:
285  typedef CT traits_type ;
286  typedef char value_type ;
287  typedef size_t size_type ;
288 
289  // Construct/copy/destroy:
290 
291  ~StringBase();
292 
293  StringBase();
294  explicit StringBase( const std::string &);
295 
296  StringBase( const_iterator );
297  template <class It>
298  StringBase( It, It );
299  StringBase( const char *, size_type );
300 
301  StringBase( const StringBase & );
302  StringBase & operator= ( const StringBase & );
303 
304  template<class CT2>
305  StringBase( const StringBase<CT2> & );
306 
307  StringBase<CT> & operator= ( const char * );
308  StringBase<CT> & operator= ( const std::string & );
309 
310  template<class CT2>
311  StringBase<CT> & operator= ( const StringBase<CT2> & );
312 
313  StringBase<CT> & operator+= ( const char * );
314  StringBase<CT> & operator+= ( const std::string & );
315 
316  template<class CT2>
317  StringBase<CT> & operator+= ( const StringBase<CT2> & );
318 
319  // Capacity:
320  size_type size() const;
321  size_type length() const;
322  bool empty() const ;
323 
324  const_iterator begin() const;
325  iterator begin();
326  const_iterator end() const;
327  iterator end();
328 
329  // Modifiers:
330 
331  StringBase<CT> & assign( const char * );
332  StringBase<CT> & assign( const char *, const size_type );
333  StringBase<CT> & assign( const std::string& );
334 
335  template<class CT2>
336  StringBase<CT> & assign( const StringBase<CT2> & );
337 
338  StringBase<CT> & append( const char * );
339  StringBase<CT> & append( const char *, const typename StringBase<CT>::size_type );
340  StringBase<CT> & append( const std::string& );
341 
342  template<class CT2>
343  StringBase<CT> & append( const StringBase<CT2> & );
344 
345  void swap( StringBase<CT> & );
346 
347  // string operations
348  const char* c_str() const;
349  std::string s_str() const ;
350 
351  int compare( const char * ) const ;
352  int compare( const std::string & ) const ;
353 
354  template<class CT2>
355  int compare( const StringBase<CT2> & ) const ;
356 
357 private:
359 };
360 
365 public:
367  static size_t length( const char * c1 );
368 
370  static void convert( char *, size_t )
371  {}
372 
374  static int compare( const char * c1, const char * c2 );
375 };
376 
382 public:
384  static size_t length( const char * c1 );
385 
387  static void convert( char * c, size_t n );
388 
390  static int compare( const char * c1, const char * c2 );
391 };
392 
393 //----------------------------------------------------------------------
394 
395 template<class CT>
396 bool StringBase<CT>::empty() const
397 { return data.len() == 0 ; }
398 
399 template<class CT>
400 typename StringBase<CT>::size_type StringBase<CT>::length() const
401 { return data.len(); }
402 
403 template<class CT>
404 typename StringBase<CT>::size_type StringBase<CT>::size() const
405 { return data.len(); }
406 
407 template<class CT>
408 typename StringBase<CT>::iterator
409 StringBase<CT>::begin()
410 { return data.c_str(); }
411 
412 template<class CT>
413 typename StringBase<CT>::const_iterator
414 StringBase<CT>::begin() const
415 { return data.c_str(); }
416 
417 template<class CT>
418 typename StringBase<CT>::iterator
419 StringBase<CT>::end()
420 { return data.c_str() + data.len(); }
421 
422 template<class CT>
423 typename StringBase<CT>::const_iterator
424 StringBase<CT>::end() const
425 { return data.c_str() + data.len(); }
426 
427 
428 template<class CT>
429 const char* StringBase<CT>::c_str() const
430 { return data.c_str(); }
431 
432 template<class CT>
433 std::string StringBase<CT>::s_str() const
434 { return std::string(c_str()) ; }
435 
436 template<class CT>
437 StringBase<CT>::~StringBase()
438 {}
439 
440 //----------------------------------------------------------------------
441 
442 template<class CT>
443 StringBase<CT>::StringBase() {}
444 
445 template<class CT>
446 template<class CT2>
447 StringBase<CT>::StringBase( const StringBase<CT2> & cs )
448 {
449  const size_type n = cs.length();
450  traits_type::convert( data.mem(cs.c_str(), n), n );
451 }
452 
453 template<class CT>
454 StringBase<CT>::StringBase( const std::string& cs )
455 {
456  const size_type n = cs.length();
457  traits_type::convert( data.mem(cs.c_str(), n), n );
458 }
459 
460 template<class CT>
461 StringBase<CT>::StringBase( const char * cs, typename StringBase<CT>::size_type n )
462 {
463  traits_type::convert( data.mem(cs, n), n );
464 }
465 
466 template<class CT>
467 template<class It>
468 StringBase<CT>::StringBase( It l_begin, It l_end )
469 {
470  traits_type::convert( data.mem(&(*l_begin), l_end - l_begin), l_end - l_begin );
471 }
472 
473 template<class CT>
474 StringBase<CT>::StringBase( const char * cs )
475 {
476  const size_type n = traits_type::length(cs);
477  traits_type::convert( data.mem(cs, n), n );
478 }
479 
480 template<class CT>
481 StringBase<CT>::StringBase( const StringBase & cs )
482 {
483  data.mem(cs.c_str(), cs.size());
484 }
485 
486 //----------------------------------------------------------------------
487 
488 template<class CT>
489 StringBase<CT> &
490 StringBase<CT>::assign( const char * cs, const typename StringBase<CT>::size_type n )
491 {
492  traits_type::convert( data.mem(cs, n), n );
493  return *this ;
494 }
495 
496 template<class CT>
497 StringBase<CT> & StringBase<CT>::assign( const char * cs )
498 { return assign( cs, traits_type::length(cs) ); }
499 
500 template<class CT>
501 StringBase<CT> & StringBase<CT>::assign( const std::string & cs )
502 { return assign( cs.c_str(), cs.length() ); }
503 
504 template<class CT>
505 template<class CT2>
506 StringBase<CT> & StringBase<CT>::assign( const StringBase<CT2> & cs )
507 { return assign( cs.c_str(), cs.length() ); }
508 
509 template<class CT>
510 StringBase<CT>&
511 StringBase<CT>::operator= ( const StringBase & cs ) {
512  if (this == &cs)
513  return *this;
514  return assign( cs.c_str(), cs.length() );
515 }
516 
517 template<class CT>
518 template<class CT2>
519 StringBase<CT>&
520 StringBase<CT>::operator= ( const StringBase<CT2> & cs ) {
521  return assign( cs.c_str(), cs.length() );
522 }
523 
524 template<class CT>
525 StringBase<CT>&
526 StringBase<CT>::operator= ( const char * cs )
527 { return assign( cs, traits_type::length(cs) ); }
528 
529 template<class CT>
530 StringBase<CT>&
531 StringBase<CT>::operator= ( const std::string& cs )
532 { return assign( cs.c_str(), cs.length() ); }
533 
534 //----------------------------------------------------------------------
535 
536 template<class CT>
537 StringBase<CT> &
538 StringBase<CT>::append( const char * cs, const typename StringBase<CT>::size_type n )
539 {
540  std::string t;
541 
542  t.reserve(data.len() + n);
543  t.append(data.c_str())
544  .append(cs, n);
545  traits_type::convert( data.mem(t.data(), t.length()), t.length());
546  return *this ;
547 }
548 
549 template<>
550 inline
551 StringBase<char_label_traits> &
552 StringBase<char_label_traits>::append( const char * cs, const StringBase<char_label_traits>::size_type n )
553 {
554  std::string t;
555 
556  if (n != 0) {
557  t.reserve(data.len() + n + 1);
558  t.append(data.c_str())
559  .append(data.len() == 0 ? "" : "_")
560  .append(cs, n);
561  traits_type::convert( data.mem(t.data(), t.length()), t.length());
562  }
563  return *this ;
564 }
565 
566 template<class CT>
567 StringBase<CT> & StringBase<CT>::append( const char * cs )
568 { return append( cs, traits_type::length(cs) ); }
569 
570 template<class CT>
571 StringBase<CT> & StringBase<CT>::append( const std::string & cs )
572 { return append( cs.data(), cs.length() ); }
573 
574 template<class CT>
575 template<class CT2>
576 StringBase<CT> & StringBase<CT>::append( const StringBase<CT2> & cs )
577 { return append( cs.c_str(), cs.length() ); }
578 
579 
580 template<class CT>
581 template<class CT2>
582 StringBase<CT>&
583 StringBase<CT>::operator+= ( const StringBase<CT2> & cs )
584 { return append( cs.c_str(), cs.length() ); }
585 
586 template<class CT>
587 StringBase<CT>&
588 StringBase<CT>::operator+= ( const char * cs )
589 { return append( cs, traits_type::length(cs) ); }
590 
591 template<class CT>
592 StringBase<CT>&
593 StringBase<CT>::operator+= ( const std::string& cs )
594 { return append( cs.data(), cs.length() ); }
595 
596 //----------------------------------------------------------------------
597 
598 template<class CT>
599 template<class CT2>
600 int StringBase<CT>::compare( const StringBase<CT2> & cs ) const
601 {
602  typedef typename Precedence<CT, CT2>::Type Traits ;
603  return Traits::compare( c_str(), cs.c_str() );
604 }
605 
606 template<class CT>
607 int StringBase<CT>::compare( const std::string & cs ) const
608 {
609  return CT::compare( c_str(), cs.c_str() );
610 }
611 
612 template<class CT>
613 int StringBase<CT>::compare( const char * cs ) const
614 {
615  return CT::compare( c_str(), cs );
616 }
617 
618 template<class CT, class CT2>
619 bool operator== ( const StringBase<CT> & lhs,
620  const StringBase<CT2> & rhs )
621 { return lhs.compare(rhs) == 0 ; }
622 
623 template<class CT, class CT2>
624 bool operator!= ( const StringBase<CT> & lhs,
625  const StringBase<CT2> & rhs )
626 { return lhs.compare(rhs) != 0 ; }
627 
628 template<class CT, class CT2>
629 bool operator< ( const StringBase<CT> & lhs,
630  const StringBase<CT2> & rhs )
631 { return lhs.compare(rhs) < 0 ; }
632 
633 template<class CT, class CT2>
634 bool operator<= ( const StringBase<CT> & lhs,
635  const StringBase<CT2> & rhs )
636 { return lhs.compare(rhs) <= 0 ; }
637 
638 template<class CT, class CT2>
639 bool operator> ( const StringBase<CT> & lhs,
640  const StringBase<CT2> & rhs )
641 { return lhs.compare(rhs) > 0 ; }
642 
643 template<class CT, class CT2>
644 bool operator>= ( const StringBase<CT> & lhs,
645  const StringBase<CT2> & rhs )
646 { return lhs.compare(rhs) >= 0 ; }
647 
648 
649 template<class CT>
650 bool operator== ( const StringBase<CT> & lhs,
651  const std::string & rhs )
652 { return lhs.compare(rhs) == 0 ; }
653 
654 template<class CT>
655 bool operator!= ( const StringBase<CT> & lhs,
656  const std::string & rhs )
657 { return lhs.compare(rhs) != 0 ; }
658 
659 template<class CT>
660 bool operator< ( const StringBase<CT> & lhs,
661  const std::string & rhs )
662 { return lhs.compare(rhs) < 0 ; }
663 
664 template<class CT>
665 bool operator<= ( const StringBase<CT> & lhs,
666  const std::string & rhs )
667 { return lhs.compare(rhs) <= 0 ; }
668 
669 template<class CT>
670 bool operator> ( const StringBase<CT> & lhs,
671  const std::string & rhs )
672 { return lhs.compare(rhs) > 0 ; }
673 
674 template<class CT>
675 bool operator>= ( const StringBase<CT> & lhs,
676  const std::string & rhs )
677 { return lhs.compare(rhs) >= 0 ; }
678 
679 
680 template<class CT>
681 bool operator== ( const StringBase<CT> & lhs,
682  const char * rhs )
683 { return lhs.compare(rhs) == 0 ; }
684 
685 template<class CT>
686 bool operator!= ( const StringBase<CT> & lhs,
687  const char * rhs )
688 { return lhs.compare(rhs) != 0 ; }
689 
690 template<class CT>
691 bool operator< ( const StringBase<CT> & lhs,
692  const char * rhs )
693 { return lhs.compare(rhs) < 0 ; }
694 
695 template<class CT>
696 bool operator<= ( const StringBase<CT> & lhs,
697  const char * rhs )
698 { return lhs.compare(rhs) <= 0 ; }
699 
700 template<class CT>
701 bool operator> ( const StringBase<CT> & lhs,
702  const char * rhs )
703 { return lhs.compare(rhs) > 0 ; }
704 
705 template<class CT>
706 bool operator>= ( const StringBase<CT> & lhs,
707  const char * rhs )
708 { return lhs.compare(rhs) >= 0 ; }
709 
710 
711 template<class CT>
712 bool operator== ( const std::string & lhs,
713  const StringBase<CT> & rhs)
714 { return rhs.compare(lhs) == 0 ; }
715 
716 template<class CT>
717 bool operator!= ( const std::string & lhs,
718  const StringBase<CT> & rhs)
719 { return rhs.compare(lhs) != 0 ; }
720 
721 template<class CT>
722 bool operator< ( const std::string & lhs,
723  const StringBase<CT> & rhs)
724 { return rhs.compare(lhs) > 0 ; }
725 
726 template<class CT>
727 bool operator<= ( const std::string & lhs,
728  const StringBase<CT> & rhs)
729 { return rhs.compare(lhs) >= 0 ; }
730 
731 template<class CT>
732 bool operator> ( const std::string & lhs,
733  const StringBase<CT> & rhs)
734 { return rhs.compare(lhs) < 0 ; }
735 
736 template<class CT>
737 bool operator>= ( const std::string & lhs,
738  const StringBase<CT> & rhs)
739 { return rhs.compare(lhs) <= 0 ; }
740 
741 
742 template<class CT>
743 bool operator== ( const char * lhs,
744  const StringBase<CT> & rhs)
745 { return rhs.compare(lhs) == 0 ; }
746 
747 template<class CT>
748 bool operator!= ( const char * lhs,
749  const StringBase<CT> & rhs)
750 { return rhs.compare(lhs) != 0 ; }
751 
752 template<class CT>
753 bool operator< ( const char * lhs,
754  const StringBase<CT> & rhs)
755 { return rhs.compare(lhs) > 0 ; }
756 
757 template<class CT>
758 bool operator<= ( const char * lhs,
759  const StringBase<CT> & rhs)
760 { return rhs.compare(lhs) >= 0 ; }
761 
762 template<class CT>
763 bool operator> ( const char * lhs,
764  const StringBase<CT> & rhs)
765 { return rhs.compare(lhs) < 0 ; }
766 
767 template<class CT>
768 bool operator>= ( const char * lhs,
769  const StringBase<CT> & rhs)
770 { return rhs.compare(lhs) <= 0 ; }
771 
772 //----------------------------------------------------------------------
773 
774 template<class CT, class CT2>
775 StringBase<CT>
776 operator+( const StringBase<CT> &cs1, const StringBase<CT2> &cs2) {
777  StringBase<CT> t(cs1);
778  t.append(cs2.c_str(), cs2.size());
779  return t;
780 }
781 
782 template<class CT>
783 StringBase<CT>
784 operator+( const StringBase<CT> &cs1, const char *cs2) {
785  StringBase<CT> t(cs1);
786  t.append(cs2);
787  return t;
788 }
789 
790 template<class CT>
791 StringBase<CT>
792 operator+( const StringBase<CT> &cs1, const std::string &cs2) {
793  StringBase<CT> t(cs1);
794  t.append(cs2.c_str(), cs2.length());
795  return t;
796 }
797 
798 template<class CT>
799 StringBase<CT>
800 operator+ ( const char *cs1, const StringBase<CT> &cs2 ) {
801  StringBase<CT> t(cs1);
802  t.append(cs2.c_str(), cs2.length());
803  return t;
804 }
805 
806 template<class CT>
807 std::string operator+(const std::string & lhs, const StringBase<CT> & rhs ) {
808  std::string s( lhs ); return s.append( rhs.c_str(), rhs.length() );
809 }
810 
814 
815 } // namespace sierra
816 
817 #endif // USE_CISTRING
818 
819 #endif // STK_UTIL_DIAG_String_h
static size_t length(const char *c1)
Definition: String.cpp:64
Definition: Env.cpp:53
static int compare(const char *c1, const char *c2)
Definition: String.cpp:77
static int compare(const char *c1, const char *c2)
Definition: String.cpp:56
char * mem(const char *, size_t n)
Definition: String.cpp:119
static size_t length(const char *c1)
Definition: String.cpp:49
static void convert(char *, size_t)
Definition: String.hpp:370
static void convert(char *c, size_t n)
Definition: String.cpp:71