nevrax.org : docs

00001 
00007 /* Copyright, 2000 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #include "stdgeorges.h"
00027 #include "nel/georges/type_unit_int_unsigned.h"
00028 #include "nel/misc/common.h"
00029 
00030 using namespace NLMISC;
00031 
00032 
00033 namespace NLGEORGES
00034 {
00035 
00037 // Construction/Destruction
00039 
00040 CTypeUnitIntUnsigned::CTypeUnitIntUnsigned( const CStringEx _sxll, const CStringEx _sxhl, const CStringEx _sxdv, const CStringEx _sxf ) : CTypeUnit( _sxll, _sxhl, _sxdv, _sxf )
00041 {
00042         ilowlimit = atoiInt64( sxlowlimit.c_str() ); 
00043         ihighlimit = atoiInt64( sxhighlimit.c_str() ); 
00044         idefaultvalue = atoiInt64( sxdefaultvalue.c_str() ); 
00045         if( sxformula.empty() )
00046                 sxformula = CStringEx( "uint(" +_sxll +"," +_sxhl +")" );
00047 }
00048 
00049 CTypeUnitIntUnsigned::~CTypeUnitIntUnsigned()
00050 {
00051 }
00052 
00053 /*
00054 CStringEx CTypeUnitIntUnsigned::Format( const CStringEx _sxvalue ) const
00055 {
00056         if( _sxvalue.empty() )
00057                 return( sxdefaultvalue );
00058 
00059         unsigned __int64 ivalue = _atoi64( _sxvalue.c_str() );
00060         if( ivalue < ilowlimit )
00061                 ivalue = ilowlimit;
00062         if( ivalue > ihighlimit )
00063                 ivalue = ihighlimit;
00064 
00065         char pc[256];
00066         _ui64toa( ivalue, pc, 10 );
00067         return( CStringEx( pc ) );
00068 }
00069 */
00070 
00071 CStringEx CTypeUnitIntUnsigned::Format( const CStringEx _sxvalue ) const
00072 {
00073         if( _sxvalue.empty() )
00074                 return( sxdefaultvalue );
00075 
00076         std::vector< std::pair< CStringEx, CStringEx > > modificationValues;
00077         CStringEx value( _sxvalue );
00078         value.purge();
00079         while( value[0] == '<' )
00080         {
00081                 unsigned int pos = value.find( '>' );
00082                 if( pos == -1 )
00083                         break;
00084                 CStringEx sxoperateur = value.get_mid( 1, 1 );
00085                 CStringEx sxoperande = value.get_mid( 2, pos-2);
00086                 value.right( value.size()-pos-1 );
00087                 modificationValues.push_back( std::make_pair( sxoperateur, sxoperande ) );
00088         }
00089         if( modificationValues.size() )
00090         {
00091                 CStringEx sxr;
00092                 for( std::vector< std::pair< CStringEx, CStringEx > >::iterator it = modificationValues.begin(); it != modificationValues.end(); ++it )
00093                 {
00094                         sxr += CStringEx( "<" );
00095                         sxr += it->first;
00096                         sxr += it->second;
00097                         sxr += CStringEx( ">" );
00098                 }
00099                 return( sxr );
00100         }
00101         else
00102         {
00103                 uint64 ivalue = atoiInt64( _sxvalue.c_str() );
00104                 if( ivalue < ilowlimit )
00105                         ivalue = ilowlimit;
00106                 if( ivalue > ihighlimit )
00107                         ivalue = ihighlimit;
00108 
00109                 char pc[256];
00110                 itoaInt64( ivalue, pc, 10 );
00111                 return( CStringEx( pc ) );
00112         }
00113 }
00114 
00115 /*                                                                      
00116 CStringEx CTypeUnitIntUnsigned::CalculateResult( const CStringEx _sxbasevalue, const CStringEx _sxvalue ) const 
00117 {
00118         nlassert( !_sxbasevalue.empty() );
00119         if( _sxvalue.empty() )
00120                 return( _sxbasevalue );
00121         return( Format( _sxvalue ) );
00122 }
00123 */
00124 
00125 CStringEx CTypeUnitIntUnsigned::CalculateResult( const CStringEx _sxbasevalue, const CStringEx _sxvalue ) const 
00126 {
00127         nlassert( !_sxbasevalue.empty() );
00128         if( _sxvalue.empty() )
00129                 return( _sxbasevalue );
00130 
00131         std::vector< std::pair< CStringEx, CStringEx > > modificationValues;
00132         CStringEx value( _sxvalue );
00133         value.purge();
00134         while( value[0] == '<' )
00135         {
00136                 unsigned int pos = value.find( '>' );
00137                 if( pos == -1 )
00138                         break;
00139                 CStringEx sxoperateur = value.get_mid( 1, 1 );
00140                 CStringEx sxoperande = value.get_mid( 2, pos-2);
00141                 value.right( value.size()-pos-1 );
00142                 modificationValues.push_back( std::make_pair( sxoperateur, sxoperande ) );
00143         }
00144         if( modificationValues.size() )
00145         {
00146                 sint64 ir = atoiInt64( _sxbasevalue.c_str() );
00147                 for( std::vector< std::pair< CStringEx, CStringEx > >::iterator it = modificationValues.begin(); it != modificationValues.end(); ++it )
00148                 {
00149                         sint64 ivalue = atoiInt64( it->second.c_str() );
00150                         if( it->first == "+" )
00151                                 ir += ivalue;
00152                         else if( it->first == "*" )
00153                                         ir *= ivalue;
00154                                 else if( it->first == "-" )
00155                                                 ir -= ivalue;
00156                                         else if( it->first == "/" )
00157                                                         ir /= ivalue;   
00158                                                 else if( it->first == "^" )
00159                                                 {
00160                                                         ir = (sint64)( pow( (double)(ir), (double)(ivalue) ) );   
00161                                                 }
00162                 }
00163                 uint64 uir = ir;
00164                 if( uir < ilowlimit )
00165                         uir = ilowlimit;
00166                 if( uir > ihighlimit )
00167                         uir = ihighlimit;
00168                 char pc[256];
00169                 itoaInt64( uir, pc, 10 );
00170                 return( CStringEx( pc ) );
00171         }
00172         else
00173         {
00174                 uint64 ivalue = atoiInt64( _sxvalue.c_str() );
00175                 if( ivalue < ilowlimit )
00176                         ivalue = ilowlimit;
00177                 if( ivalue > ihighlimit )
00178                         ivalue = ihighlimit;
00179                 char pc[256];
00180                 itoaInt64( ivalue, pc, 10 );
00181                 return( CStringEx( pc ) );
00182         }
00183         return( Format( _sxvalue ) );
00184 }
00185 
00186 void CTypeUnitIntUnsigned::SetDefaultValue( const CStringEx _sxdv )
00187 {
00188         sxdefaultvalue = _sxdv;
00189         idefaultvalue = atoiInt64( sxdefaultvalue.c_str() ); 
00190 }
00191 
00192 void CTypeUnitIntUnsigned::SetLowLimit( const CStringEx _sxll )
00193 {
00194         sxlowlimit = _sxll;
00195         ilowlimit = atoiInt64( sxlowlimit.c_str() ); 
00196 }
00197 
00198 void CTypeUnitIntUnsigned::SetHighLimit( const CStringEx _sxhl )
00199 {
00200         sxhighlimit = _sxhl;
00201         ihighlimit = atoiInt64( sxhighlimit.c_str() ); 
00202 }
00203 
00204 }
00205 
00206
type_unit_int_unsigned.cpp
