nevrax.org : docs

00001 /* Copyright, 2000 Nevrax Ltd.
00002  *
00003  * This file is part of NEVRAX <MODULE_NAME>.
00004  * NEVRAX <MODULE_NAME> is free software; you can redistribute it and/or modify
00005  * it under the terms of the GNU General Public License as published by
00006  * the Free Software Foundation; either version 2, or (at your option)
00007  * any later version.
00008 
00009  * NEVRAX <MODULE_NAME> is distributed in the hope that it will be useful, but
00010  * WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00012  * General Public License for more details.
00013 
00014  * You should have received a copy of the GNU General Public License
00015  * along with NEVRAX <MODULE_NAME>; see the file COPYING. If not, write to the
00016  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00017  * MA 02111-1307, USA.
00018  */
00019 
00020 #include "nel/ai/logic/operator.h"
00021 
00022 #include <list>
00023 #include <vector>
00024 #include "nel/ai/logic/ai_assert.h"
00025 #include "nel/ai/logic/varset.h"
00026 #include "nel/ai/logic/valueset.h"
00027 #include "nel/ai/logic/fact.h"
00028 
00029 namespace NLAILOGIC
00030 {
00031         using namespace NLAIAGENT;
00032 
00033         IBaseOperator::IBaseOperator()
00034         {
00035                 _Comment = NULL;
00036                 _Goal = NULL;
00037         }
00038 
00039         IBaseOperator::IBaseOperator(const char *c)
00040         {
00041                 _Comment = new char[ strlen(c) ];
00042                 strcpy( _Comment , c);
00043                 _Goal = NULL;
00044         }
00045 
00046         IBaseOperator::IBaseOperator(const IBaseOperator &c)
00047         {
00048                 if ( c._Comment != NULL )
00049                 {
00050                         _Comment = new char[strlen(c._Comment)];
00051                         strcpy(_Comment,c._Comment);
00052                 }
00053 
00054                 if ( c._Goal != NULL )
00055                 {
00056                         _Goal = c._Goal;
00057                         _Goal->release();
00058                 }
00059 
00060                 sint32 i;
00061                 for ( i = 0; i < (sint32) c._Conds.size(); i++ )
00062                         _Conds.push_back( c._Conds[i] );
00063 
00064                 for ( i = 0; i < (sint32) c._Concs.size(); i++ )
00065                         _Concs.push_back( c._Concs[i] );
00066         }
00067 
00068         IBaseOperator::~IBaseOperator()
00069         {
00070                 if ( _Comment != NULL )
00071                         delete[] _Comment;
00072 
00073                 if ( _Goal != NULL )
00074                         _Goal->release();
00075         }
00076 
00078         void IBaseOperator::setComment(char *c)
00079         {
00080                 if ( _Comment )
00081                         delete[] _Comment;
00082 
00083                 if ( c ) 
00084                 {
00085                         _Comment = new char[ strlen( c ) ];
00086                         strcpy( _Comment, c );
00087                 }
00088                 else
00089                         _Comment = NULL;
00090         }
00091 
00092         const std::vector<IBaseAssert *> &IBaseOperator::getPrecondAsserts() const
00093         {
00094                 return _Conds;
00095         }
00096 
00097         const std::vector<IBaseAssert *> &IBaseOperator::getPostCondAsserts() const
00098         {
00099                 return _Concs;
00100         }
00101 
00102         void IBaseOperator::save(NLMISC::IStream &os)
00103         {
00104                 sint32 i;
00105                 sint32 size = (sint32) _Conds.size();
00106                 os.serial( size );
00107                 for ( i = 0; i < (sint32) _Conds.size(); i++ )
00108                 {
00109                         os.serial( (NLAIC::CIdentType &) _Conds[i]->getType() );
00110                         _Conds[i]->save(os);
00111                 }
00112 
00113                 size = (sint32) _Concs.size();
00114                 os.serial( size );
00115                 for ( i = 0; i < (sint32) _Concs.size(); i++ )
00116                 {
00117                         os.serial( (NLAIC::CIdentType &) _Concs[i]->getType() );
00118                         _Concs[i]->save(os);
00119                 }
00120         }
00121 
00122         void IBaseOperator::load(NLMISC::IStream &is)
00123         {
00124                 sint32 i;
00125                 sint32 nb_vals;
00126 
00127                 is.serial( nb_vals );
00128                 for ( i = 0; i < nb_vals; i++ )
00129                 {
00130                         NLAIC::CIdentTypeAlloc id;
00131                         is.serial( id );
00132                         IBaseAssert *tmp_val = (IBaseAssert *) id.allocClass();
00133                         tmp_val->load( is );
00134                         tmp_val->incRef();
00135                         _Conds.push_back( tmp_val );
00136                 }
00137 
00138                 is.serial( nb_vals );
00139                 for ( i = 0; i < nb_vals; i++ )
00140                 {
00141                         NLAIC::CIdentTypeAlloc id;
00142                         is.serial( id );
00143                         IBaseAssert *tmp_val = (IBaseAssert *) id.allocClass();
00144                         tmp_val->load( is );
00145                         tmp_val->incRef();
00146                         _Concs.push_back( tmp_val );
00147                 }
00148         }
00149 
00150         void IBaseOperator::setGoal(IBaseAssert *goal)
00151         {
00152                 if ( _Goal )
00153                         _Goal->release();
00154 
00155                 _Goal = goal;
00156 
00157                 if ( goal != NULL )
00158                         _Goal->incRef();
00159         }
00160 }
operator.cpp
