nevrax.org : docs

00001 
00006 /* Copyright, 2000 Nevrax Ltd.
00007  *
00008  * This file is part of NEVRAX NEL.
00009  * NEVRAX NEL is free software; you can redistribute it and/or modify
00010  * it under the terms of the GNU General Public License as published by
00011  * the Free Software Foundation; either version 2, or (at your option)
00012  * any later version.
00013 
00014  * NEVRAX NEL is distributed in the hope that it will be useful, but
00015  * WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00017  * General Public License for more details.
00018 
00019  * You should have received a copy of the GNU General Public License
00020  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00021  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00022  * MA 02111-1307, USA.
00023  */
00024 #include "nel/ai/agent/msg_stream.h"
00025 #include "nel/ai/agent/agent_digital.h"
00026 
00027 namespace NLAIAGENT
00028 {
00029 
00030         template<class X, class Y>
00031         X getValue(const IObjectIA *o)
00032         {               
00033                 return (X)((const Y *)o)->getValue();
00034         }
00035 
00036         template<class X, class Y>
00037         Y *getValue(X v)
00038         {               
00039                 return new Y(v);
00040         }
00041 
00042 //####################
00043 //class CMsgIStream
00044 //####################
00045         void CMsgIStream::serial(uint8 &b) throw(NLMISC::EStream)
00046         {               
00047                 b = getValue<uint8, UInt8Type>(_It++);
00048                 _Pos ++;
00049         }
00050 
00051         void CMsgIStream::serial(sint8 &b) throw(NLMISC::EStream)
00052         {
00053                 b = getValue<sint8, CharType>(_It++);
00054                 _Pos ++;
00055         }
00056 
00057         void CMsgIStream::serial(uint16 &b) throw(NLMISC::EStream)
00058         {
00059                 b = getValue<uint16, UInt16Type>(_It++);
00060                 _Pos ++;
00061         }
00062 
00063         void CMsgIStream::serial(sint16 &b) throw(NLMISC::EStream)
00064         {
00065                 b = getValue<sint16, ShortIntegerType>(_It++);
00066                 _Pos ++;
00067         }
00068 
00069         void CMsgIStream::serial(uint32 &b) throw(NLMISC::EStream)
00070         {
00071                 b = getValue<uint32, UInt32Type>(_It++);
00072                 _Pos ++;
00073         }
00074 
00075         void CMsgIStream::serial(sint32 &b) throw(NLMISC::EStream)
00076         {
00077                 b = getValue<sint32, IntegerType>(_It++);
00078                 _Pos ++;
00079         }
00080 
00081         void CMsgIStream::serial(uint64 &b) throw(NLMISC::EStream)
00082         {
00083                 b = getValue<uint64, UInt64Type>(_It++);
00084                 _Pos ++;
00085         }
00086 
00087         void CMsgIStream::serial(sint64 &b) throw(NLMISC::EStream)
00088         {
00089                 b = getValue<sint64, UInt64Type>(_It++);
00090                 _Pos ++;
00091         }
00092 
00093         void CMsgIStream::serial(float &b) throw(NLMISC::EStream)
00094         {
00095                 b = getValue<float, DigitalType>(_It++);
00096                 _Pos ++;
00097         }
00098 
00099         void CMsgIStream::serial(double &b) throw(NLMISC::EStream)
00100         {
00101                 b = getValue<double, DDigitalType>(_It++);
00102                 _Pos ++;
00103         }
00104 
00105         void CMsgIStream::serial(bool &b) throw(NLMISC::EStream)
00106         {
00107                 b = getValue<uint8, UInt8Type>(_It++) ? true : false;
00108                 _Pos ++;
00109         }
00110 
00111 #ifndef NL_OS_CYGWIN
00112         void CMsgIStream::serial(char &b) throw(NLMISC::EStream)
00113         {
00114                 b = getValue<sint8, CharType>(_It++);
00115                 _Pos ++;
00116         }
00117 #endif
00118 
00119         void CMsgIStream::serial(std::string &b) throw(NLMISC::EStream)
00120         {
00121                 CStringType *s= (CStringType *)(_It++);
00122                 b = s->getStr().getString();
00123                 _Pos ++;
00124         }
00125 
00126         void CMsgIStream::serial(ucstring &b) throw(NLMISC::EStream)
00127         {
00128                 throw NLMISC::EReadError((const char *)_List.getType());
00129         }
00130 
00131         void CMsgIStream::serial(IObjectIA &b) throw(NLMISC::EStream)
00132         {               
00133                 const IObjectIA *o= (const IObjectIA *)(_It++);
00134                 b = *o;         
00135         }
00136 
00137         void CMsgIStream::serial(IObjectIA* &b) throw(NLMISC::EStream)
00138         {               
00139                 IObjectIA *o= (IObjectIA *)(_It++);
00140                 b = o;
00141         }
00142 
00143 //####################
00144 //class CMsgIStream
00145 //####################
00146 
00147         void CMsgOStream::serial(uint8 &b) throw(NLMISC::EStream)
00148         {
00149                 _List.push(getValue<uint8, UInt8Type>(b));
00150         }
00151 
00152         void CMsgOStream::serial(sint8 &b) throw(NLMISC::EStream)
00153         {
00154                 _List.push(getValue<sint8, CharType>(b));
00155         }
00156 
00157         void CMsgOStream::serial(uint16 &b) throw(NLMISC::EStream)
00158         {
00159                 _List.push(getValue<uint16, UInt16Type>(b));
00160         }
00161 
00162         void CMsgOStream::serial(sint16 &b) throw(NLMISC::EStream)
00163         {
00164                 _List.push(getValue<sint16, ShortIntegerType>(b));
00165         }
00166 
00167         void CMsgOStream::serial(uint32 &b) throw(NLMISC::EStream)
00168         {
00169                 _List.push(getValue<uint32, UInt32Type>(b));
00170         }
00171 
00172         void CMsgOStream::serial(sint32 &b) throw(NLMISC::EStream)
00173         {               
00174                 _List.push(getValue<sint32, IntegerType>(b));
00175         }
00176 
00177         void CMsgOStream::serial(uint64 &b) throw(NLMISC::EStream)
00178         {
00179                 _List.push(getValue<uint64, UInt64Type>(b));
00180         }
00181         void CMsgOStream::serial(sint64 &b) throw(NLMISC::EStream)
00182         {
00183                 _List.push(getValue<sint64, UInt64Type>(b));
00184         }
00185         void CMsgOStream::serial(float &b) throw(NLMISC::EStream)
00186         {
00187                 _List.push(getValue<float, DigitalType>(b));
00188         }
00189         void CMsgOStream::serial(double &b) throw(NLMISC::EStream)
00190         {
00191                 _List.push(getValue<double, DDigitalType>(b));
00192         }
00193 
00194         void CMsgOStream::serial(bool &b) throw(NLMISC::EStream)
00195         {
00196                 _List.push(getValue<uint8, UInt8Type>(b ? true : false));
00197         }
00198 
00199 #ifndef NL_OS_CYGWIN
00200         void CMsgOStream::serial(char &b) throw(NLMISC::EStream)
00201         {
00202                 _List.push(getValue<sint8, CharType>(b));
00203         }
00204 #endif
00205 
00206         void CMsgOStream::serial(std::string &b) throw(NLMISC::EStream)
00207         {
00208                 CStringType *s= new CStringType(CStringVarName(b.c_str()));
00209                 _List.push(s);
00210         }
00211 
00212         void CMsgOStream::serial(ucstring &b) throw(NLMISC::EStream)
00213         {
00214                 throw NLMISC::EReadError((const char *)_List.getType());
00215         }
00216 
00217         void CMsgOStream::serial(IObjectIA &b) throw(NLMISC::EStream)
00218         {
00219                 /*((NLAIC::CIdentType &)b.getType()).serial(*this);
00220                 b.serial(*this);*/
00221                 _List.push((IObjectIA*)b.clone());
00222         }
00223 
00224         void CMsgOStream::serial(IObjectIA* &b) throw(NLMISC::EStream)
00225         {
00226                 /*((NLAIC::CIdentType &)b->getType()).serial(*this);
00227                 b->serial(*this);*/
00228                 _List.push(b);
00229                 b->incRef();
00230         }
00231 }
msg_stream.cpp
