Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

l1394_quadlet.cpp

Go to the documentation of this file.
00001 
00002 #include <string.h>
00003 #include <stdio.h>
00004 
00005 #include <string>
00006 #include <iostream>
00007 
00008 #include "l1394_quadlet.h"
00009 #include "l1394_message.h"
00010 
00011 
00012 using std::cout;
00013 using std::endl;
00014 
00015 // constructors 
00016 namespace L1394{
00017 Quadlet::Quadlet()
00018 {
00019     memset( quadlet, 0, 4 );
00020 }
00021 
00022 Quadlet::Quadlet( const char *quad_buf )
00023 {
00024     memcpy( quadlet, quad_buf, 4 );
00025 }
00026 
00027 Quadlet::Quadlet( const u_int32_t quad_int )
00028 {
00029     for( int i = 0; i <= 3; i++ ) {
00030   quadlet[ i ] = ( quad_int >> ( ( 3 - i ) * 8 ) ) & 0xff;
00031     }
00032 }
00033 
00034 Quadlet::Quadlet( const string& s )
00035 {
00036     memcpy( quadlet, s.c_str(), 4 );
00037 }
00038 
00039 Quadlet::Quadlet( const Quadlet& q )
00040 {
00041     memcpy( quadlet, q.quadlet, 4 );
00042 }
00043 
00044 
00045 const Quadlet operator+(const Quadlet& q_1, const Quadlet& q_2)
00046 {
00047   return Quadlet( q_1.toInt() + q_2.toInt());
00048 }
00049 
00050 const Quadlet operator+(const Quadlet& q_1, const unsigned int q_2)
00051 {
00052   return Quadlet ( q_1.toInt() + q_2);
00053 }
00054 
00055 const Quadlet operator-(const Quadlet& q_1, const Quadlet& q_2)
00056 {
00057   return Quadlet( q_1.toInt() - q_2.toInt());
00058 }
00059 
00060 const Quadlet operator-(const Quadlet& q_1, const unsigned int q_2)
00061 {
00062   return Quadlet ( q_1.toInt() - q_2);
00063 }
00064 
00065 Quadlet&
00066 Quadlet::operator=(const Quadlet& q )
00067 {
00068     if( *this == q ) {
00069   return *this;
00070     }
00071     memcpy( quadlet, q.quadlet, 4 );
00072     return( *this );
00073 }
00074 
00075 bool
00076 Quadlet::operator== (const Quadlet& q )
00077 {
00078     return( memcmp( quadlet, q.quadlet, 4 ) ? FALSE : TRUE );
00079 }
00080 
00081 bool Quadlet::operator!= (const Quadlet &q)
00082 {
00083   return !(*this == q);
00084 }
00085 
00086 
00087 
00088 u_int32_t
00089 Quadlet::getByte( const int byte ) const
00090 {
00091   if (byte < 0 || byte >3)
00092   {
00093     cout << "L1394 Quadlet: getByte> invalid range" << endl;
00094     return 0;
00095   }
00096   return( static_cast< unsigned int>( quadlet[ byte ] ) );
00097 }
00098 
00099 void
00100 Quadlet::setByte( const int byte, const u_int32_t value )
00101 {
00102   if (byte < 0 || byte >3)
00103   {
00104     cout << "L1394 Quadlet: setByte> invalid range" << endl;
00105     return;
00106   }
00107 
00108     if( value > 255 ) {
00109     internal::SMessage::getInstance()->errorStream() << "Quadlet > Value out of Range " << endl;
00110     }
00111 
00112     quadlet[ byte ] = value;
00113     return;
00114 }
00115 
00116 u_int32_t
00117 Quadlet::getBitRange( const int start, const int end ) const
00118 {
00119   if (start > 31 || start < 0)
00120   {
00121     cout << "L1394 Quadlet: getBitRange> invalid start value" << endl;
00122     return 0;
00123   }
00124 
00125   if (end > 31 || end < 0)
00126   {
00127     cout << "L1394 Quadlet: getBitRange> invalid end value" << endl;
00128     return 0;
00129   }
00130 
00131   if (start > end)
00132   {
00133     cout << "L1394 Quadlet: getBitRange> invalid range" << endl;
00134     return 0;
00135   }
00136 
00137 
00138     int range = end - start;
00139     unsigned int tmp = toInt();
00140     unsigned int mask = ( range == 31 ) ? 0xffffffff :
00141       ( ( 1 << ( range + 1 ) ) - 1 );
00142 
00143     return( ( tmp >> start ) & mask );
00144 }
00145 
00146 void
00147 Quadlet::setBitRange( const int start, const int end,
00148            const u_int32_t value )
00149 {
00150   if (start > 31 || start < 0)
00151   {
00152     cout << "L1394 Quadlet: setBitRange> invalid start value" << endl;
00153     return ;
00154   }
00155 
00156   if (end > 31 || end < 0)
00157   {
00158     cout << "L1394 Quadlet: setBitRange> invalid end value" << endl;
00159     return ;
00160   }
00161 
00162   if (start > end)
00163   {
00164     cout << "L1394 Quadlet: getBitRange> invalid range" << endl;
00165     return;
00166   }
00167 
00168     int range = end - start;
00169     int tmpval = value;
00170 
00171     u_int32_t mask1 = ( start + range == 31 ) ? 0x0 :
00172       ~( ( 1 << ( start + range + 1 ) ) - 1 );
00173 
00174     u_int32_t mask2 = ( start == 31 ) ?  mask2 = 0xffffffff :
00175       ( 1 << ( start ) ) - 1;
00176 
00177     // clip tmpval to range
00178     tmpval &= ( ~( mask1 | mask2 ) >> start );
00179 
00180     u_int32_t oldval = toInt();
00181     u_int32_t rs = oldval & mask2;
00182     u_int32_t ls = oldval & mask1;
00183 
00184     tmpval <<= start;
00185     fromInt( tmpval | rs | ls );
00186     return;
00187 }
00188 
00189 int
00190 Quadlet::getBit( const int location ) const
00191 {
00192   if (location > 31 || location < 0)
00193   {
00194     cout << "L1394 Quadlet: getBit> invalid range" << endl;
00195     return 0;
00196   }
00197     int byte = location / 8;
00198     int bit = location % 8;
00199 
00200     return ( (quadlet[ 3 - byte ] & ( 1 << bit )) >> bit);
00201 }
00202 
00203 void
00204 Quadlet::setBit( const int location, const int value )
00205 {
00206   if (location > 31 || location < 0)
00207   {
00208     cout << "L1394 Quadlet: setBit > invalid range" << endl;
00209     return;
00210   }
00211 
00212     int byte = 3 - ( location / 8 );
00213     int bit = location % 8;
00214     int mask = 1 << bit;
00215 
00216     if( value ) {
00217   quadlet[ byte ] |= mask;
00218     } else {
00219   quadlet[ byte ] &= ~mask;
00220     }
00221     return;
00222 }
00223 
00224 u_int32_t
00225 Quadlet::toInt() const
00226 {
00227     u_int32_t result = 0;
00228 
00229     for( int i = 0; i <= 3; i++ ) {
00230   result += quadlet[ 3 - i ] << ( i * 8 );
00231     }
00232     return( result );
00233 }
00234 
00235 void
00236 Quadlet::fromInt( u_int32_t value )
00237 {
00238     for( int i = 0; i <= 3; i++ ) {
00239   quadlet[ 3 - i ] = ( value >> ( i * 8 ) ) & 0xff ;
00240     }
00241     return;
00242 }
00243 
00244 string
00245 Quadlet::toString() const
00246 {
00247     char str_buf[ Quadlet_OUTPUTSIZE ];
00248 
00249     if( !toCharArray( str_buf, Quadlet_OUTPUTSIZE ) ) {
00250   // process error
00251     }
00252     return string( str_buf );
00253 }
00254 
00255 char *
00256 Quadlet::toCharArray( char *str_buf, int length ) const
00257 {
00258     snprintf( str_buf, length,  "%02x:%02x:%02x:%02x",
00259         quadlet[ 0 ],
00260         quadlet[ 1 ],
00261         quadlet[ 2 ],
00262             quadlet[ 3 ] );
00263     return( str_buf );
00264 }
00265 
00266 
00267 ostream&
00268 operator<< ( ostream& s, const Quadlet& q)
00269 {
00270     s << q.toString();
00271     return s;
00272 }
00273 
00274 istream&
00275 operator>> ( istream& s, Quadlet& q )
00276 {
00277     string str;    
00278     const char *c_ptr;
00279 
00280     s >> str;
00281 
00282     c_ptr = str.c_str();
00283 
00284     memcpy( q.quadlet, c_ptr, 4 );
00285     return s;
00286 }
00287 
00288 }

Generated on Wed Aug 24 00:36:40 2005 for L1394 by doxygen 1.4.2
L1394 library (NMM) grahics.cs.uni-sb.de/~repplix/l1394_home/