tuple.h

在LINUX下运行的仿真机器人服务器源代码

          setValue( tuple.get( t2 ) );
        else if( tuple.isTypeOf( t3 ) )
          setValue( tuple.get( t3 ) );
        else if( tuple.isTypeOf( t4 ) )
          setValue( tuple.get( t4 ) );
        else if( tuple.isTypeOf( t5 ) )
          setValue( tuple.get( t5 ) );
        else if( tuple.isTypeOf( t6 ) )
          setValue( tuple.get( t6 ) );
        else if( tuple.isTypeOf( t7 ) )
          setValue( tuple.get( t7 ) );
        else if( tuple.isTypeOf( t8 ) )
          setValue( tuple.get( t8 ) );
        else if( tuple.isTypeOf( t9 ) )
          setValue( tuple.get( t9 ) );
        else if( tuple.isTypeOf( t10 ) )
          setValue( tuple.get( t10 ) );
        else if( tuple.isTypeOf( t11 ) )
          setValue( tuple.get( t11 ) );
        else if( tuple.isTypeOf( t12 ) )
          setValue( tuple.get( t12 ) );
        else if( tuple.isTypeOf( t13 ) )
          setValue( tuple.get( t13 ) );
        else if( tuple.isTypeOf( t14 ) )
          setValue( tuple.get( t14 ) );
        else if( tuple.isTypeOf( t15 ) )
          setValue( tuple.get( t15 ) );
        else if( tuple.isTypeOf( t16 ) )
          setValue( tuple.get( t16 ) );
        else if( tuple.isTypeOf( t17 ) )
          setValue( tuple.get( t17 ) );
        else if( tuple.isTypeOf( t18 ) )
          setValue( tuple.get( t18 ) );
        else if( tuple.isTypeOf( t19 ) )
          setValue( tuple.get( t19 ) );
        else if( tuple.isTypeOf( t20 ) )
          setValue( tuple.get( t20 ) );
        else
          clear();
        return *this;
      }
 
      void
      clearAll()
      { clear(); }
 
      template< class X >
      X&
      operator=( const X& x )
      { return setValue( x ); }
    };

    class NullType21
    {};
    class NullType22
    {};
    class NullType23
    {};
    class NullType24
    {};
    class NullType25
    {};
    class NullType26
    {};
    class NullType27
    {};
    class NullType28
    {};
    class NullType29
    {};
    class NullType30
    {};

    template< typename T1 = NullType,
      typename T2 = NullType2,
      typename T3 = NullType3,
      typename T4 = NullType4,
      typename T5 = NullType5,
      typename T6 = NullType6,
      typename T7 = NullType7,
      typename T8 = NullType8,
      typename T9 = NullType9,
      typename T10 = NullType10,
      typename T11 = NullType11,
      typename T12 = NullType12,
      typename T13 = NullType13,
      typename T14 = NullType14,
      typename T15 = NullType15,
      typename T16 = NullType16,
      typename T17 = NullType17,
      typename T18 = NullType18,
      typename T19 = NullType19,
      typename T20 = NullType20,
      typename T21 = NullType21,
      typename T22 = NullType22,
      typename T23 = NullType23,
      typename T24 = NullType24,
      typename T25 = NullType25,
      typename T26 = NullType26,
      typename T27 = NullType27,
      typename T28 = NullType28,
      typename T29 = NullType29,
      typename T30 = NullType30 >
    class Tuple30
    {
    private:
      typedef Tuple30< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20,
        T21, T22, T23, T24, T25, T26, T27, T28, T29, T30 > ThisType;

      T1* M_t1_holder;
      T2* M_t2_holder;
      T3* M_t3_holder;
      T4* M_t4_holder;
      T5* M_t5_holder;
      T6* M_t6_holder;
      T7* M_t7_holder;
      T8* M_t8_holder;
      T9* M_t9_holder;
      T10* M_t10_holder;
      T11* M_t11_holder;
      T12* M_t12_holder;
      T13* M_t13_holder;
      T14* M_t14_holder;
      T15* M_t15_holder;
      T16* M_t16_holder;
      T17* M_t17_holder;
      T18* M_t18_holder;
      T19* M_t19_holder;
      T20* M_t20_holder;
      T21* M_t21_holder;
      T22* M_t22_holder;
      T23* M_t23_holder;
      T24* M_t24_holder;
      T25* M_t25_holder;
      T26* M_t26_holder;
      T27* M_t27_holder;
      T28* M_t28_holder;
      T29* M_t29_holder;
      T30* M_t30_holder;
        
    public:
      bool
      isTypeOf( T1* ) const
      { return M_t1_holder != 0; }
               
      bool
      isTypeOf( T2* ) const
      { return M_t2_holder != 0; }
               
      bool
      isTypeOf( T3* ) const
      { return M_t3_holder != 0; }
               
      bool
      isTypeOf( T4* ) const
      { return M_t4_holder != 0; }
               
      bool
      isTypeOf( T5* ) const
      { return M_t5_holder != 0; }
               
      bool
      isTypeOf( T6* ) const
      { return M_t6_holder != 0; }
               
      bool
      isTypeOf( T7* ) const
      { return M_t7_holder != 0; }
               
      bool
      isTypeOf( T8* ) const
      { return M_t8_holder != 0; }
               
      bool
      isTypeOf( T9* ) const
      { return M_t9_holder != 0; }
               
      bool
      isTypeOf( T10* ) const
      { return M_t10_holder != 0; }
               
      bool
      isTypeOf( T11* ) const
      { return M_t11_holder != 0; }
               
      bool
      isTypeOf( T12* ) const
      { return M_t12_holder != 0; }
               
      bool
      isTypeOf( T13* ) const
      { return M_t13_holder != 0; }
               
      bool
      isTypeOf( T14* ) const
      { return M_t14_holder != 0; }
               
      bool
      isTypeOf( T15* ) const
      { return M_t15_holder != 0; }
               
      bool
      isTypeOf( T16* ) const
      { return M_t16_holder != 0; }
               
      bool
      isTypeOf( T17* ) const
      { return M_t17_holder != 0; }
               
      bool
      isTypeOf( T18* ) const
      { return M_t18_holder != 0; }
               
      bool
      isTypeOf( T19* ) const
      { return M_t19_holder != 0; }
               
      bool
      isTypeOf( T20* ) const
      { return M_t20_holder != 0; }
               
      bool
      isTypeOf( T21* ) const
      { return M_t21_holder != 0; }
               
      bool
      isTypeOf( T22* ) const
      { return M_t22_holder != 0; }
               
      bool
      isTypeOf( T23* ) const
      { return M_t23_holder != 0; }
               
      bool
      isTypeOf( T24* ) const
      { return M_t24_holder != 0; }
               
      bool
      isTypeOf( T25* ) const
      { return M_t25_holder != 0; }
               
      bool
      isTypeOf( T26* ) const
      { return M_t26_holder != 0; }
               
      bool
      isTypeOf( T27* ) const
      { return M_t27_holder != 0; }
               
      bool
      isTypeOf( T28* ) const
      { return M_t28_holder != 0; }
               
      bool
      isTypeOf( T29* ) const
      { return M_t29_holder != 0; }
               
      bool
      isTypeOf( T30* ) const
      { return M_t30_holder != 0; }
               
      T1&
      get( T1* )
      {
        if( M_t1_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t1_holder; 
      }
        
      T2&
      get( T2* )
      {
        if( M_t2_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t2_holder; 
      }
        
      T3&
      get( T3* )
      {
        if( M_t3_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t3_holder; 
      }
        
      T4&
      get( T4* )
      {
        if( M_t4_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t4_holder; 
      }
        
      T5&
      get( T5* )
      {
        if( M_t5_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t5_holder; 
      }
        
      T6&
      get( T6* )
      {
        if( M_t6_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t6_holder; 
      }
        
      T7&
      get( T7* )
      {
        if( M_t7_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t7_holder; 
      }
        
      T8&
      get( T8* )
      {
        if( M_t8_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t8_holder; 
      }
        
      T9&
      get( T9* )
      {
        if( M_t9_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t9_holder; 
      }
        
      T10&
      get( T10* )
      {
        if( M_t10_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t10_holder; 
      }
        
      T11&
      get( T11* )
      {
        if( M_t11_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t11_holder; 
      }
        
      T12&
      get( T12* )
      {
        if( M_t12_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t12_holder; 
      }
        
      T13&
      get( T13* )
      {
        if( M_t13_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t13_holder; 
      }
        
      T14&
      get( T14* )
      {
        if( M_t14_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t14_holder; 
      }
        
      T15&
      get( T15* )
      {
        if( M_t15_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t15_holder; 
      }
        
      T16&
      get( T16* )
      {
        if( M_t16_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t16_holder; 
      }
        
      T17&
      get( T17* )
      {
        if( M_t17_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t17_holder; 
      }
        
      T18&
      get( T18* )
      {
        if( M_t18_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t18_holder; 
      }
        
      T19&
      get( T19* )
      {
        if( M_t19_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t19_holder; 
      }
        
      T20&
      get( T20* )
      {
        if( M_t20_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t20_holder; 
      }
        
      T21&
      get( T21* )
      {
        if( M_t21_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t21_holder; 
      }
        
      T22&
      get( T22* )
      {
        if( M_t22_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t22_holder; 
      }
        
      T23&
      get( T23* )
      {
        if( M_t23_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t23_holder; 
      }
        
      T24&
      get( T24* )
      {
        if( M_t24_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t24_holder; 
      }
        
      T25&
      get( T25* )
      {
        if( M_t25_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t25_holder; 
      }
        
      T26&
      get( T26* )
      {
        if( M_t26_holder == 0 )