src/FormatGroup.h

   1 #ifndef UTIL_FORMAT_GROUP_H
   2 #define UTIL_FORMAT_GROUP_H
   3
   4 namespace util {
   5         namespace format_interal {
   6                 // empty group, but useful even though.
   7                 struct group0 {
   8                         group0()      {}
   9                 };
  10
  11                 inline std::ostream & operator << ( std::ostream & os, const group0 & ) {
  12                         return os;
  13                 }
  14
  15                 template <class T1>
  16                 struct group1 {
  17                         T1 a1_;
  18
  19                         group1(T1 a1) : a1_(a1) {}
  20                 };
  21
  22                 template <class T1>
  23                 inline std::ostream & operator <<(std::ostream & os, const group1<T1> & x) {
  24                         os << x.a1_;
  25                         return os;
  26                 }
  27
  28                 template <class T1,class T2>
  29                 struct group2 {
  30                         T1 a1_;
  31                         T2 a2_;
  32
  33                         group2(T1 a1,T2 a2) : a1_(a1),a2_(a2) {}
  34                 };
  35
  36                 template <class T1,class T2>
  37                 inline std::ostream & operator <<(std::ostream & os, const group2<T1,T2>& x) {
  38                         os << x.a1_<< x.a2_;
  39                         return os;
  40                 }
  41
  42                 template <class T1,class T2,class T3>
  43                 struct group3 {
  44                         T1 a1_;
  45                         T2 a2_;
  46                         T3 a3_;
  47
  48                         group3(T1 a1,T2 a2,T3 a3) : a1_(a1),a2_(a2),a3_(a3) {}
  49                 };
  50
  51                 template <class T1,class T2,class T3>
  52                 inline std::ostream & operator << (std::ostream & os, const group3<T1,T2,T3>& x) {
  53                         os << x.a1_<< x.a2_<< x.a3_;
  54                         return os;
  55                 }
  56
  57                 template <class T1,class T2,class T3,class T4>
  58                 struct group4 {
  59                         T1 a1_;
  60                         T2 a2_;
  61                         T3 a3_;
  62                         T4 a4_;
  63
  64                         group4(T1 a1,T2 a2,T3 a3,T4 a4) : a1_(a1),a2_(a2),a3_(a3),a4_(a4) {}
  65                 };
  66
  67                 template <class Ch, class Tr, class T1,class T2,class T3,class T4>
  68                 inline std::ostream & operator <<(std::ostream & os, const group4<T1,T2,T3,T4>& x) {
  69                         os << x.a1_<< x.a2_<< x.a3_<< x.a4_;
  70                         return os;
  71                 }
  72
  73                 template <class T1,class T2>
  74                 inline group1<T1> group_head( group2<T1,T2> const& x) {
  75                         return group1<T1> (x.a1_);
  76                 }
  77
  78                 template <class T1,class T2>
  79                 inline group1<T2> group_last( group2<T1,T2> const& x) {
  80                         return group1<T2> (x.a2_);
  81                 }
  82
  83                 template <class T1,class T2,class T3>
  84                 inline group2<T1,T2> group_head( group3<T1,T2,T3> const& x) {
  85                         return group2<T1,T2> (x.a1_,x.a2_);
  86                 }
  87
  88                 template <class T1,class T2,class T3>
  89                 inline group1<T3> group_last( group3<T1,T2,T3> const& x) {
  90                         return group1<T3> (x.a3_);
  91                 }
  92
  93                 template <class T1,class T2,class T3,class T4>
  94                 inline group3<T1,T2,T3> group_head( group4<T1,T2,T3,T4> const& x) {
  95                         return group3<T1,T2,T3> (x.a1_,x.a2_,x.a3_);
  96                 }
  97
  98                 template <class T1,class T2,class T3,class T4>
  99                 inline group1<T4> group_last( group4<T1,T2,T3,T4> const& x) {
 100                         return group1<T4> (x.a4_);
 101                 }
 102         }
 103
 104         inline format_interal::group1< format_interal::group0 > group() {
 105                 return format_interal::group1< format_interal::group0 > ( format_interal::group0() );
 106         }
 107
 108         template  <class T1, class Var>
 109         inline format_interal::group1< format_interal::group2<T1, Var const&> >
 110                                         group(T1 a1, Var const& var) {
 111                 return format_interal::group1< format_interal::group2<T1, Var const&> >
 112                 ( format_interal::group2<T1, Var const&>
 113                 (a1, var)
 114                 );
 115         }
 116
 117         template  <class T1,class T2, class Var>
 118         inline format_interal::group1< format_interal::group3<T1,T2, Var const&> >
 119                                 group(T1 a1,T2 a2, Var const& var) {
 120                 return format_interal::group1< format_interal::group3<T1,T2, Var const&> >
 121                 ( format_interal::group3<T1,T2, Var const&>
 122                 (a1,a2, var)
 123                 );
 124         }
 125
 126         template  <class T1,class T2,class T3, class Var>
 127         inline format_interal::group1< format_interal::group4<T1,T2,T3, Var const&> >
 128                                 group(T1 a1,T2 a2,T3 a3, Var const& var) {
 129                 return format_interal::group1< format_interal::group4<T1,T2,T3, Var const&> >
 130                 ( format_interal::group4<T1,T2,T3, Var const&>
 131                 (a1,a2,a3, var)
 132                 );
 133         }
 134 }
 135 #endif