MOOSE: basecode/SetGet.h Source File

00001 /**********************************************************************
00002 ** This program is part of 'MOOSE', the
00003 ** Messaging Object Oriented Simulation Environment.
00004 **           Copyright (C) 2003-2009 Upinder S. Bhalla. and NCBS
00005 ** It is made available under the terms of the
00006 ** GNU Lesser General Public License version 2.1
00007 ** See the file COPYING.LIB for the full notice.
00008 **********************************************************************/
00009 
00010 #ifndef _SETGET_H
00011 #define _SETGET_H
00012 
00013 // Forward declaration needed for localGet()
00014 template< class T, class A > class GetOpFunc;
00015 
00029 template< class T, class A >
00030 A localGet( const Eref& er, string field )
00031 {
00032     string fullFieldName = "get" + field;
00033     fullFieldName[3] = toupper( fullFieldName[3] );
00034     const Finfo* finfo = er.element()->cinfo()->findFinfo( fullFieldName );
00035     assert( finfo );
00036     
00037     const DestFinfo* dest = dynamic_cast< const DestFinfo* >( finfo );
00038     assert( dest );
00039     
00040     const OpFunc* op = dest->getOpFunc();
00041     assert( op );
00042     
00043     const GetOpFunc< T, A >* gop =
00044         dynamic_cast< const GetOpFunc< T, A >* >( op );
00045     assert( gop );
00046     
00047     return gop->reduceOp( er );
00048 }
00049 
00050 class SetGet
00051 {
00052     public:
00053         SetGet()
00054         {;}
00055 
00056         virtual ~SetGet()
00057         {;}
00058 
00070         static const OpFunc* checkSet( 
00071             const string& field, ObjId& tgt, FuncId& fid );
00072 
00074 
00078         static bool strGet( const ObjId& tgt, const string& field, string& ret );
00079 
00084         static bool strSet( const ObjId& dest, const string& field, const string& val );
00085 
00087         static const vector< double* >* dispatchGet( 
00088             const ObjId& tgt, FuncId tgtFid, 
00089             const double* arg, unsigned int size );
00090 
00091         virtual bool checkOpClass( const OpFunc* op ) const = 0;
00092 };
00093 
00094 class SetGet0: public SetGet
00095 {
00096     public:
00097         SetGet0()
00098         {;}
00099 
00103         static bool set( const ObjId& dest, const string& field )
00104         {
00105             FuncId fid;
00106             ObjId tgt( dest ); // checkSet may change the tgt.
00107             const OpFunc* func = checkSet( field, tgt, fid );
00108             const OpFunc0Base* op = 
00109                     dynamic_cast< const OpFunc0Base* >( func );
00110             if ( op ) {
00111                 if ( tgt.isOffNode() ) {
00112                     const OpFunc* op2 = op->makeHopFunc( 
00113                         HopIndex( op->opIndex(), MooseSetHop ) );
00114                     const OpFunc0Base* hop = 
00115                         dynamic_cast< const OpFunc0Base* >( op2 );
00116                     assert( hop );
00117                     hop->op( tgt.eref() );
00118                     delete op2;
00119                     if ( tgt.isGlobal() )
00120                         op->op( tgt.eref() );
00121                     return true;
00122                 } else {
00123                     op->op( tgt.eref() );
00124                     return true;
00125                 }
00126             }
00127             return 0;
00128         }
00129 
00133         static bool innerStrSet( const ObjId& dest, const string& field, 
00134             const string& val )
00135         {
00136             return set( dest, field );
00137         }
00138 
00139         bool checkOpClass( const OpFunc* op ) const {
00140             return dynamic_cast< const OpFunc0Base* >( op );
00141         }
00142 };
00143 
00144 template< class A > class SetGet1: public SetGet
00145 {
00146     public:
00147         SetGet1()
00148         {;}
00149 
00153         static bool set( const ObjId& dest, const string& field, A arg )
00154         {
00155             FuncId fid;
00156             ObjId tgt( dest );
00157             const OpFunc* func = checkSet( field, tgt, fid );
00158             const OpFunc1Base< A >* op = 
00159                     dynamic_cast< const OpFunc1Base< A >* >( func );
00160             if ( op ) {
00161                 if ( tgt.isOffNode() ) {
00162                     const OpFunc* op2 = op->makeHopFunc( 
00163                         HopIndex( op->opIndex(), MooseSetHop ) );
00164                     const OpFunc1Base< A >* hop = 
00165                         dynamic_cast< const OpFunc1Base< A >* >( op2 );
00166                     hop->op( tgt.eref(), arg );
00167                     delete op2;
00168                     if ( tgt.isGlobal() )
00169                         op->op( tgt.eref(), arg );
00170                     return true;
00171                 } else {
00172                     op->op( tgt.eref(), arg );
00173                     return true;
00174                 }
00175             }
00176             return false;
00177         }
00178 
00188         static bool setVec( ObjId destId, const string& field, 
00189             const vector< A >& arg )
00190         {
00191             if ( arg.size() == 0 ) return 0;
00192 
00193             ObjId tgt( destId );
00194             FuncId fid;
00195 
00196             const OpFunc* func = checkSet( field, tgt, fid );
00197             const OpFunc1Base< A >* op = dynamic_cast< const OpFunc1Base< A >* >( func );
00198             if ( op ) {
00199                 const OpFunc* op2 = op->makeHopFunc( 
00200                     HopIndex( op->opIndex(), MooseSetVecHop ) );
00201                 const OpFunc1Base< A >* hop = 
00202                     dynamic_cast< const OpFunc1Base< A >* >( op2 );
00203                 hop->opVec( tgt.eref(), arg, op );
00204                 delete op2;
00205                 return true;
00206             }
00207             return false;
00208         }
00209 
00213         static bool setRepeat( ObjId destId, const string& field, 
00214             const A& arg )
00215         {
00216             vector< A >temp ( 1, arg );
00217             return setVec( destId, field, temp );
00218         }
00219 
00223         static bool innerStrSet( const ObjId& dest, const string& field, 
00224             const string& val )
00225         {
00226             A arg;
00227             Conv< A >::str2val( arg, val );
00228             return set( dest, field, arg );
00229         }
00230 
00231         bool checkOpClass( const OpFunc* op ) const {
00232             return dynamic_cast< const OpFunc1Base< A > * >( op );
00233         }
00234 };
00235 
00236 template< class A > class Field: public SetGet1< A >
00237 {
00238     public:
00239         Field()
00240         {;}
00241 
00245         static bool set( const ObjId& dest, const string& field, A arg )
00246         {
00247             string temp = "set" + field;
00248             temp[3] = toupper( temp[3] );
00249             return SetGet1< A >::set( dest, temp, arg );
00250         }
00251 
00252         static bool setVec( ObjId destId, const string& field, 
00253             const vector< A >& arg )
00254         {
00255             string temp = "set" + field;
00256             temp[3] = toupper( temp[3] );
00257             return SetGet1< A >::setVec( destId, temp, arg );
00258         }
00259 
00260         static bool setRepeat( ObjId destId, const string& field, 
00261             A arg )
00262         {
00263             string temp = "set" + field;
00264             temp[3] = toupper( temp[3] );
00265             return SetGet1< A >::setRepeat( destId, temp, arg );
00266         }
00267 
00271         static bool innerStrSet( const ObjId& dest, const string& field, 
00272             const string& arg )
00273         {
00274             A val;
00275             // Do NOT add 'set_' to the field name, as the 'set' func
00276             // does it anyway.
00277             Conv< A >::str2val( val, arg );
00278             return set( dest, field, val );
00279         }
00280 
00282 
00283         // Returns a field value.
00284         static A get( const ObjId& dest, const string& field)
00285         { 
00286             ObjId tgt( dest );
00287             FuncId fid;
00288             string fullFieldName = "get" + field;
00289             fullFieldName[3] = toupper( fullFieldName[3] );
00290             const OpFunc* func = SetGet::checkSet( fullFieldName, tgt, fid );
00291             const GetOpFuncBase< A >* gof = 
00292                     dynamic_cast< const GetOpFuncBase< A >* >( func );
00293             if ( gof ) {
00294                 if ( tgt.isDataHere() ) {
00295                     return gof->returnOp( tgt.eref() );
00296                 } else {
00297                     const OpFunc* op2 = gof->makeHopFunc( 
00298                         HopIndex( gof->opIndex(), MooseGetHop ) );
00299                     const OpFunc1Base< A* >* hop = 
00300                         dynamic_cast< const OpFunc1Base< A* >* >( op2 );
00301                     assert( hop );
00302                     // Blocking function.
00303                     A ret; 
00304                     hop->op( tgt.eref(), &ret );
00305                     delete op2;
00306                     return ret;
00307                 }
00308             }
00309             cout << "Warning: Field::Get conversion error for " << 
00310                     dest.id.path() << "." << field << endl;
00311             return A();
00312         }
00313 
00317         static void getVec( ObjId dest, const string& field, vector< A >& vec)
00318         {
00319 
00320             vec.resize( 0 );
00321             ObjId tgt( dest );
00322             FuncId fid;
00323             string fullFieldName = "get" + field;
00324             fullFieldName[3] = toupper( fullFieldName[3] );
00325             const OpFunc* func = SetGet::checkSet( fullFieldName, tgt, fid );
00326             const GetOpFuncBase< A >* gof = 
00327                     dynamic_cast< const GetOpFuncBase< A >* >( func );
00328             if ( gof ) {
00329                 const OpFunc* op2 = gof->makeHopFunc( 
00330                     HopIndex( gof->opIndex(), MooseGetVecHop ) );
00331                 const GetHopFunc< A >* hop = 
00332                     dynamic_cast< const GetHopFunc< A >* >( op2 );
00333                 hop->opGetVec( tgt.eref(), vec, gof );
00334                 delete op2;
00335                 return;
00336             }
00337             cout << "Warning: Field::getVec conversion error for " <<
00338                 dest.path() << endl;
00339         }
00340 
00345         static bool innerStrGet( const ObjId& dest, const string& field, 
00346             string& str )
00347         {
00348             Conv< A >::val2str( str, get( dest, field ) );
00349             return 1;
00350         }
00351 };
00352 
00356 template< class A1, class A2 > class SetGet2: public SetGet
00357 {
00358     public:
00359         SetGet2()
00360         {;}
00361 
00365         static bool set( const ObjId& dest, const string& field, 
00366             A1 arg1, A2 arg2 )
00367         {
00368             FuncId fid;
00369             ObjId tgt( dest );
00370             const OpFunc* func = checkSet( field, tgt, fid );
00371             const OpFunc2Base< A1, A2 >* op = 
00372                     dynamic_cast< const OpFunc2Base< A1, A2 >* >( func );
00373             if ( op ) {
00374                 if ( tgt.isOffNode() ) {
00375                     const OpFunc* op2 = op->makeHopFunc( 
00376                         HopIndex( op->opIndex(), MooseSetHop ) );
00377                     const OpFunc2Base< A1, A2 >* hop = 
00378                         dynamic_cast< const OpFunc2Base< A1, A2 >* >( op2 );
00379                     hop->op( tgt.eref(), arg1, arg2 );
00380                     delete op2;
00381                     if ( tgt.isGlobal() )
00382                         op->op( tgt.eref(), arg1, arg2 );
00383                     return true;
00384                 } else {
00385                     op->op( tgt.eref(), arg1, arg2 );
00386                     return true;
00387                 }
00388             }
00389             return false;
00390         }
00391 
00404         static bool setVec( Id destId, const string& field, 
00405             const vector< A1 >& arg1, const vector< A2 >& arg2 )
00406         {
00407             ObjId tgt( destId, 0 );
00408             FuncId fid;
00409             const OpFunc* func = checkSet( field, tgt, fid );
00410             const OpFunc2Base< A1, A2 >* op = 
00411                     dynamic_cast< const OpFunc2Base< A1, A2 >* >( func );
00412             if ( op ) {
00413                 /*
00414                 unsigned int size = tgt.element()->numData(); 
00415                 // total # of entries on element and maybe to include fields
00416                 for ( unsigned int i = 0; i < size; ++i ) {
00417                     Eref er( tgt.element(), i );
00418                     op->op( er, arg1[ i % arg1.size() ], 
00419                                     arg2[ i % arg2.size() ] );
00420                 }
00421                 return true;
00422                 */
00423                 const OpFunc* op2 = op->makeHopFunc( 
00424                     HopIndex( op->opIndex(), MooseSetVecHop ) );
00425                 const OpFunc2Base< A1, A2 >* hop = 
00426                     dynamic_cast< const OpFunc2Base< A1, A2 >* >( op2 );
00427                 hop->opVec( tgt.eref(), arg1, arg2, op );
00428                 delete op2;
00429                 return true;
00430             }
00431             return false;
00432         }
00433 
00437         static bool innerStrSet( const ObjId& dest, const string& field, 
00438             const string& val )
00439         {
00440             A1 arg1;
00441             A2 arg2;
00442             string::size_type pos = val.find_first_of( "," );
00443             Conv< A1 >::str2val( arg1, val.substr( 0, pos ) );
00444             Conv< A2 >::str2val( arg2, val.substr( pos + 1 ) );
00445             return set( dest, field, arg1, arg2 );
00446         }
00447 };
00448 
00457 template< class L, class A > class LookupField: public SetGet2< L, A >
00458 {
00459     public:
00460         LookupField( const ObjId& dest )
00461             : SetGet2< L, A >( dest )
00462         {;}
00463 
00467         static bool set( const ObjId& dest, const string& field, 
00468             L index, A arg )
00469         {
00470             string temp = "set" + field;
00471             temp[3] = toupper( temp[3] );
00472             return SetGet2< L, A >::set( dest, temp, index, arg );
00473         }
00474 
00479         static bool setVec( Id destId, const string& field, 
00480             const vector< L >& index, const vector< A >& arg )
00481         {
00482             string temp = "set" + field;
00483             temp[3] = toupper( temp[3] );
00484             return SetGet2< L, A >::setVec( destId, temp, index, arg );
00485         }
00486 
00493         static bool setVec( ObjId dest, const string& field, 
00494             const vector< L >& index, const vector< A >& arg )
00495         {
00496             string temp = "set" + field;
00497             temp[3] = toupper( temp[3] );
00498             return SetGet2< L, A >::setVec( dest, temp, index, arg );
00499         }
00500 
00504         static bool setRepeat( Id destId, const string& field, 
00505             const vector< L >& index, A arg )
00506         {
00507             vector< A > avec( index.size(), arg );
00508             return setVec( destId, field, index, avec );
00509         }
00510 
00514         static bool innerStrSet( const ObjId& dest, const string& field, 
00515             const string& indexStr, const string& val )
00516         {
00517             L index;
00518             Conv< L >::str2val( index, indexStr );
00519 
00520             A arg;
00521             // Do NOT add 'set_' to the field name, as the 'set' func
00522             // does it anyway.
00523             Conv< A >::str2val( arg, val );
00524             return set( dest, field, index, arg );
00525         }
00526 
00531         // Returns a field value.
00532         static A get( const ObjId& dest, const string& field, L index )
00533         {
00534             ObjId tgt( dest );
00535             FuncId fid;
00536             string fullFieldName = "get" + field;
00537             fullFieldName[3] = toupper( fullFieldName[3] );
00538             const OpFunc* func = SetGet::checkSet( fullFieldName, tgt, fid);
00539             const LookupGetOpFuncBase< L, A >* gof = 
00540                 dynamic_cast< const LookupGetOpFuncBase< L, A >* >( func );
00541             if ( gof ) {
00542                 if ( tgt.isDataHere() ) {
00543                     return gof->returnOp( tgt.eref(), index );
00544                 } else {
00545                         /*
00546                     const OpFunc* op2 = gof->makeHopFunc( 
00547                         HopIndex( gof->opIndex(), MooseGetHop ), index );
00548                     const OpFunc1Base< A* >* hop = 
00549                         dynamic_cast< const OpFunc1Base< A* >* >( op2 );
00550                         */
00551                     cout << "Warning: LookupField::get: cannot cross nodes yet\n";
00552                     return A();
00553                     /*
00554                     assert( hop );
00555                     // Blocking function.
00556                     hop->op( tgt.eref(), &ret );
00557                     delete op2;
00558                     return ret;
00559                     */
00560                 }
00561             }
00562             cout << "LookupField::get: Warning: Field::Get conversion error for " << 
00563                 dest.id.path() << "." << field << endl;
00564             return A();
00565         }
00566 
00573         static void getVec( Id dest, const string& field, 
00574             vector< L >& index, vector< A >& vec )
00575         {
00576             vec.resize( 0 );
00577             ObjId tgt( dest );
00578             FuncId fid;
00579             string fullFieldName = "get" + field;
00580             fullFieldName[3] = toupper( fullFieldName[3] );
00581             const OpFunc* func = SetGet::checkSet( fullFieldName, tgt, fid );
00582             const LookupGetOpFuncBase< L, A >* gof = 
00583                 dynamic_cast< const LookupGetOpFuncBase< L, A >* >( func );
00584             if ( gof ) {
00585                 Element* elm = dest.element();
00586                 unsigned int size = vec.size(); // temporary. See SetVec.
00587                 vec.resize( size );
00588                 for ( unsigned int i = 0; i < size; ++i ) {
00589                     Eref e( elm, i );
00590                     vec[i] = gof->returnOp( e, index );
00591                 }
00592                 return;
00593             }
00594             cout << "Warning: Field::getVec conversion error for " <<
00595                 dest.path() << endl;
00596         }
00597 
00602         static bool innerStrGet( const ObjId& dest, const string& field, 
00603             const string& indexStr, string& str )
00604         {
00605             L index;
00606             Conv< L >::str2val( index, indexStr );
00607 
00608             A ret = get( dest, field, index );
00609             Conv<A>::val2str( str, ret );
00610             return 1;
00611         }
00612 };
00613 
00617 template< class A1, class A2, class A3 > class SetGet3: public SetGet
00618 {
00619     public:
00620         SetGet3()
00621         {;}
00622 
00626         static bool set( const ObjId& dest, const string& field, 
00627             A1 arg1, A2 arg2, A3 arg3 )
00628         {
00629             FuncId fid;
00630             ObjId tgt( dest );
00631             const OpFunc* func = checkSet( field, tgt, fid );
00632             const OpFunc3Base< A1, A2, A3 >* op = 
00633                     dynamic_cast< const OpFunc3Base< A1, A2, A3 >* >( func);
00634             if ( op ) {
00635                 if ( tgt.isOffNode() ) {
00636                     const OpFunc* op2 = op->makeHopFunc( 
00637                         HopIndex( op->opIndex(), MooseSetHop ) );
00638                     const OpFunc3Base< A1, A2, A3 >* hop = 
00639                         dynamic_cast< const OpFunc3Base< A1, A2, A3 >* >( 
00640                                         op2 );
00641                     hop->op( tgt.eref(), arg1, arg2, arg3 );
00642                     delete op2;
00643                     if ( tgt.isGlobal() )
00644                         op->op( tgt.eref(), arg1, arg2, arg3 );
00645                     return true;
00646                 } else {
00647                     op->op( tgt.eref(), arg1, arg2, arg3 );
00648                     return true;
00649                 }
00650             }
00651             return 0;
00652         }
00653 
00659         static bool innerStrSet( const ObjId& dest, const string& field, 
00660             const string& val )
00661         {
00662             A1 arg1;
00663             A2 arg2;
00664             A3 arg3;
00665             string::size_type pos = val.find_first_of( "," );
00666             Conv< A1 >::str2val( arg1, val.substr( 0, pos ) );
00667             string temp = val.substr( pos + 1 );
00668             pos = temp.find_first_of( "," );
00669             Conv< A2 >::str2val( arg2, temp.substr( 0,pos ) );
00670             Conv< A3 >::str2val( arg3, temp.substr( pos + 1 ) );
00671             return set( dest, field, arg1, arg2, arg3 );
00672         }
00673 };
00674 
00678 template< class A1, class A2, class A3, class A4 > class SetGet4: public SetGet
00679 {
00680     public:
00681         SetGet4()
00682         {;}
00683 
00687         static bool set( const ObjId& dest, const string& field, 
00688             A1 arg1, A2 arg2, A3 arg3, A4 arg4 )
00689         {
00690             FuncId fid;
00691             ObjId tgt( dest );
00692             const OpFunc* func = checkSet( field, tgt, fid );
00693             const OpFunc4Base< A1, A2, A3, A4 >* op = 
00694                 dynamic_cast< const OpFunc4Base< A1, A2, A3, A4 >* >( func);
00695             if ( op ) {
00696                 if ( tgt.isOffNode() ) {
00697                     const OpFunc* op2 = op->makeHopFunc( 
00698                         HopIndex( op->opIndex(), MooseSetHop ) );
00699                     const OpFunc4Base< A1, A2, A3, A4 >* hop = 
00700                         dynamic_cast< const OpFunc4Base< A1, A2, A3, A4 >* >( op2 );
00701                     hop->op( tgt.eref(), arg1, arg2, arg3, arg4 );
00702                     delete op2;
00703                     if ( tgt.isGlobal() )
00704                         op->op( tgt.eref(), arg1, arg2, arg3, arg4 );
00705                     return true;
00706                 } else {
00707                     op->op( tgt.eref(), arg1, arg2, arg3, arg4 );
00708                     return true;
00709                 }
00710             }
00711             return 0;
00712         }
00713 
00719         static bool innerStrSet( const ObjId& dest, const string& field, 
00720             const string& val )
00721         {
00722             A1 arg1;
00723             A2 arg2;
00724             A3 arg3;
00725             A4 arg4;
00726             string::size_type pos = val.find_first_of( "," );
00727             Conv< A1 >::str2val( arg1, val.substr( 0, pos ) );
00728             string temp = val.substr( pos + 1 );
00729             pos = temp.find_first_of( "," );
00730             Conv< A2 >::str2val( arg2, temp.substr( 0, pos ) );
00731             temp = temp.substr( pos + 1 );
00732             pos = temp.find_first_of( "," );
00733             Conv< A3 >::str2val( arg3, temp.substr( 0, pos ) );
00734             Conv< A4 >::str2val( arg4, temp.substr( pos + 1 ) );
00735             return set( dest, field, arg1, arg2, arg3, arg4 );
00736         }
00737 };
00738 
00742 template< class A1, class A2, class A3, class A4, class A5 > class SetGet5:
00743     public SetGet
00744 {
00745     public:
00746         SetGet5()
00747         {;}
00748 
00749         static bool set( const ObjId& dest, const string& field, 
00750             A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5 )
00751         {
00752             FuncId fid;
00753             ObjId tgt( dest );
00754             const OpFunc* func = checkSet( field, tgt, fid );
00755             const OpFunc5Base< A1, A2, A3, A4, A5 >* op = 
00756                 dynamic_cast< const OpFunc5Base< A1, A2, A3, A4, A5 >* >( func);
00757             if ( op ) {
00758                 if ( tgt.isOffNode() ) {
00759                     const OpFunc* op2 = op->makeHopFunc( 
00760                         HopIndex( op->opIndex(), MooseSetHop ) );
00761                     const OpFunc5Base< A1, A2, A3, A4, A5 >* hop = 
00762                         dynamic_cast< const OpFunc5Base< A1, A2, A3, A4, A5 >* >( op2 );
00763                     hop->op( tgt.eref(), arg1, arg2, arg3, arg4, arg5 );
00764                     delete op2;
00765                     if ( tgt.isGlobal() )
00766                         op->op( tgt.eref(), arg1, arg2, arg3, arg4, arg5 );
00767                     return true;
00768                 } else {
00769                     op->op( tgt.eref(), arg1, arg2, arg3, arg4, arg5 );
00770                     return true;
00771                 }
00772             }
00773             return 0;
00774         }
00775 
00781         static bool innerStrSet( const ObjId& dest, const string& field, 
00782             const string& val )
00783         {
00784             A1 arg1;
00785             A2 arg2;
00786             A3 arg3;
00787             A4 arg4;
00788             A5 arg5;
00789             string::size_type pos = val.find_first_of( "," );
00790             Conv< A1 >::str2val( arg1, val.substr( 0, pos ) );
00791             string temp = val.substr( pos + 1 );
00792             pos = temp.find_first_of( "," );
00793             Conv< A2 >::str2val( arg2, temp.substr( 0, pos ) );
00794             temp = temp.substr( pos + 1 );
00795             pos = temp.find_first_of( "," );
00796             Conv< A3 >::str2val( arg3, temp.substr( 0, pos ) );
00797             temp = temp.substr( pos + 1 );
00798             pos = temp.find_first_of( "," );
00799             Conv< A4 >::str2val( arg4, temp.substr( 0, pos ) );
00800             Conv< A5 >::str2val( arg5, temp.substr( pos + 1 ) );
00801             return set( dest, field, arg1, arg2, arg3, arg4, arg5 );
00802         }
00803 };
00804 
00808 template< class A1, class A2, class A3, class A4, class A5, class A6 > class SetGet6:
00809     public SetGet
00810 {
00811     public:
00812         SetGet6()
00813         {;}
00814 
00818         static bool set( const ObjId& dest, const string& field, 
00819             A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6 )
00820         {
00821             FuncId fid;
00822             ObjId tgt( dest );
00823             const OpFunc* func = checkSet( field, tgt, fid );
00824             const OpFunc6Base< A1, A2, A3, A4, A5, A6 >* op = 
00825                 dynamic_cast< const OpFunc6Base< A1, A2, A3, A4, A5, A6 >* >( func);
00826             if ( op ) {
00827                 if ( tgt.isOffNode() ) {
00828                     const OpFunc* op2 = op->makeHopFunc( 
00829                         HopIndex( op->opIndex(), MooseSetHop ) );
00830                     const OpFunc6Base< A1, A2, A3, A4, A5, A6 >* hop = 
00831                         dynamic_cast< const OpFunc6Base< A1, A2, A3, A4, A5, A6 >* >( op2 );
00832                     hop->op( tgt.eref(), arg1, arg2, arg3, arg4, arg5, arg6 );
00833                     delete op2;
00834                     if ( tgt.isGlobal() )
00835                         op->op( tgt.eref(), arg1, arg2, arg3, arg4, arg5, arg6 );
00836                     return true;
00837                 } else {
00838                     op->op( tgt.eref(), arg1, arg2, arg3, arg4, arg5, arg6);
00839                     return true;
00840                 }
00841             }
00842             return 0;
00843         }
00844 
00848         static bool innerStrSet( const ObjId& dest, const string& field, 
00849             const string& val )
00850         {
00851             A1 arg1;
00852             A2 arg2;
00853             A3 arg3;
00854             A4 arg4;
00855             A5 arg5;
00856             A6 arg6;
00857             string::size_type pos = val.find_first_of( "," );
00858             Conv< A1 >::str2val( arg1, val.substr( 0, pos ) );
00859             string temp = val.substr( pos + 1 );
00860             pos = temp.find_first_of( "," );
00861             Conv< A2 >::str2val( arg2, temp.substr( 0, pos ) );
00862             temp = temp.substr( pos + 1 );
00863             pos = temp.find_first_of( "," );
00864             Conv< A3 >::str2val( arg3, temp.substr( 0, pos ) );
00865             temp = temp.substr( pos + 1 );
00866             pos = temp.find_first_of( "," );
00867             Conv< A4 >::str2val( arg4, temp.substr( 0, pos ) );
00868             temp = temp.substr( pos + 1 );
00869             pos = temp.find_first_of( "," );
00870             Conv< A5 >::str2val( arg5, temp.substr( 0, pos ) );
00871             Conv< A6 >::str2val( arg6, temp.substr( pos + 1 ) );
00872             return set( dest, field, arg1, arg2, arg3, arg4, arg5, arg6 );
00873         }
00874 };
00875 
00876 #endif // _SETGET_H