tuple.h

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

      get( T1* ) const
      { 
        if( M_t1_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t1_holder; 
      }
        
      const T2&
      get( T2* ) const
      { 
        if( M_t2_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t2_holder; 
      }
        
      const T3&
      get( T3* ) const
      { 
        if( M_t3_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t3_holder; 
      }
        
      const T4&
      get( T4* ) const
      { 
        if( M_t4_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t4_holder; 
      }
        
      const T5&
      get( T5* ) const
      { 
        if( M_t5_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t5_holder; 
      }
        
      const T6&
      get( T6* ) const
      { 
        if( M_t6_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t6_holder; 
      }
        
      const T7&
      get( T7* ) const
      { 
        if( M_t7_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t7_holder; 
      }
        
      const T8&
      get( T8* ) const
      { 
        if( M_t8_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t8_holder; 
      }
        
      const T9&
      get( T9* ) const
      { 
        if( M_t9_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t9_holder; 
      }
        
      const T10&
      get( T10* ) const
      { 
        if( M_t10_holder == 0 )
          throw NullErr( __FILE__, __LINE__,
                         "Tried to access null element in Tuple" );
        else
          return *M_t10_holder; 
      }

    protected:

      void
      clear()
      { 
        delete M_t1_holder; M_t1_holder = 0;
        delete M_t2_holder; M_t2_holder = 0;
        delete M_t3_holder; M_t3_holder = 0;
        delete M_t4_holder; M_t4_holder = 0;
        delete M_t5_holder; M_t5_holder = 0;
        delete M_t6_holder; M_t6_holder = 0;
        delete M_t7_holder; M_t7_holder = 0;
        delete M_t8_holder; M_t8_holder = 0;
        delete M_t9_holder; M_t9_holder = 0;
        delete M_t10_holder; M_t10_holder = 0;
      }
        
    public:
      Tuple10()
        : M_t1_holder( 0 ),
          M_t2_holder( 0 ),
          M_t3_holder( 0 ),
          M_t4_holder( 0 ),
          M_t5_holder( 0 ),
          M_t6_holder( 0 ),
          M_t7_holder( 0 ),
          M_t8_holder( 0 ),
          M_t9_holder( 0 ),
          M_t10_holder( 0 )
      {}
        
      template< typename T >
      Tuple10( const T& t )
        : M_t1_holder( 0 ),
          M_t2_holder( 0 ),
          M_t3_holder( 0 ),
          M_t4_holder( 0 ),
          M_t5_holder( 0 ),
          M_t6_holder( 0 ),
          M_t7_holder( 0 ),
          M_t8_holder( 0 ),
          M_t9_holder( 0 ),
          M_t10_holder( 0 )
      { setValue( t ); }

      Tuple10( const Tuple10< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >& tuple )
        : M_t1_holder( 0 ),
          M_t2_holder( 0 ),
          M_t3_holder( 0 ),
          M_t4_holder( 0 ),
          M_t5_holder( 0 ),
          M_t6_holder( 0 ),
          M_t7_holder( 0 ),
          M_t8_holder( 0 ),
          M_t9_holder( 0 ),
          M_t10_holder( 0 )
      { setValue( tuple ); }

      ~Tuple10()
      {}
        
      Tuple10< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >&
      operator=( const Tuple10< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >& tuple )
      { return setValue( tuple ); }

      template< class T >
      bool
      isTypeOf() const
      { T* t = NULL; return isTypeOf( t ); }
       
      template< class T >
      T&
      get()
      { T* t = NULL; return get( t ); }
        
      template< class T >
      const T&
      get() const
      { T* t = NULL; return get( t ); }
        
      T1&
      setValue( const T1& t1 )
      { clear(); M_t1_holder = new T1( t1 ); return *M_t1_holder; }
        
      T2&
      setValue( const T2& t2 )
      { clear(); M_t2_holder = new T2( t2 ); return *M_t2_holder; }
        
      T3&
      setValue( const T3& t3 )
      { clear(); M_t3_holder = new T3( t3 ); return *M_t3_holder; }
        
      T4&
      setValue( const T4& t4 )
      { clear(); M_t4_holder = new T4( t4 ); return *M_t4_holder; }
        
      T5&
      setValue( const T5& t5 )
      { clear(); M_t5_holder = new T5( t5 ); return *M_t5_holder; }
        
      T6&
      setValue( const T6& t6 )
      { clear(); M_t6_holder = new T6( t6 ); return *M_t6_holder; }
        
      T7&
      setValue( const T7& t7 )
      { clear(); M_t7_holder = new T7( t7 ); return *M_t7_holder; }
        
      T8&
      setValue( const T8& t8 )
      { clear(); M_t8_holder = new T8( t8 ); return *M_t8_holder; }
        
      T9&
      setValue( const T9& t9 )
      { clear(); M_t9_holder = new T9( t9 ); return *M_t9_holder; }
        
      T10&
      setValue( const T10& t10 )
      { clear(); M_t10_holder = new T10( t10 ); return *M_t10_holder; }
        
      Tuple10< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >&
      setValue( const Tuple10< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >& tuple )
      {
        if( tuple.template isTypeOf< T1 >() )
          setValue( tuple.template get< T1 >() );
        else if( tuple.template isTypeOf< T2 >() )
          setValue( tuple.template get< T2 >() );
        else if( tuple.template isTypeOf< T3 >() )
          setValue( tuple.template get< T3 >() );
        else if( tuple.template isTypeOf< T4 >() )
          setValue( tuple.template get< T4 >() );
        else if( tuple.template isTypeOf< T5 >() )
          setValue( tuple.template get< T5 >() );
        else if( tuple.template isTypeOf< T6 >() )
          setValue( tuple.template get< T6 >() );
        else if( tuple.template isTypeOf< T7 >() )
          setValue( tuple.template get< T7 >() );
        else if( tuple.template isTypeOf< T8 >() )
          setValue( tuple.template get< T8 >() );
        else if( tuple.template isTypeOf< T9 >() )
          setValue( tuple.template get< T9 >() );
        else if( tuple.template isTypeOf< T10 >() )
          setValue( tuple.template get< T10 >() );
        else
          clear();
        return *this;
      }
 
      void
      clearAll()
      { clear(); }
 
      template< class X >
      X&
      operator=( const X& x )
      { return setValue( x ); }
    };


    class NullType11
    {};
    class NullType12
    {};
    class NullType13
    {};
    class NullType14
    {};
    class NullType15
    {};
    class NullType16
    {};
    class NullType17
    {};
    class NullType18
    {};
    class NullType19
    {};
    class NullType20
    {};

    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 >
    class Tuple20
    {
    private:
      typedef Tuple20< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
        T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > 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;
        
    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; }
               
      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; 
      }