nevrax.org : docs

00001 
00007 /* Copyright, 2000-2002 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NeL Network Services.
00010  * NEVRAX NeL Network Services 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 Network Services 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 Network Services; 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 #ifndef NL_TRANSPORT_CLASS_H
00027 #define NL_TRANSPORT_CLASS_H
00028 
00029 
00030 //
00031 // Includes
00032 //
00033 
00034 #include "nel/misc/types_nl.h"
00035 #include "nel/misc/stream.h"
00036 #include "nel/misc/entity_id.h"
00037 
00038 #include "nel/net/unified_network.h"
00039 #include "nel/net/message.h"
00040 
00041 #include <vector>
00042 #include <string>
00043 
00044 
00045 //
00046 // Macros
00047 //
00048 
00053 #define TRANSPORT_CLASS_REGISTER(_c) \
00054         static _c _c##Instance; \
00055         CTransportClass::registerClass (_c##Instance);
00056 
00057 
00058 //
00059 // Classes
00060 //
00061 
00069 class CTransportClass
00070 {
00071 public:
00072 
00077         enum TProp {
00078                 PropUInt8, PropUInt16, PropUInt32, PropUInt64,
00079                 PropSInt8, PropSInt16, PropSInt32, PropSInt64,
00080                 PropBool, PropFloat, PropDouble, PropString, PropEntityId, PropUKN };
00081 
00082 
00083         //
00084         // Static methods
00085         //
00086 
00088         static void init ();
00089 
00091         static void release ();
00092 
00096         static void registerClass (CTransportClass &instance);
00097 
00099         static void displayLocalRegisteredClass ();
00100 
00101 
00102         //
00103         // Virtual methods
00104         //
00105 
00118         virtual void description () = 0;
00119 
00123         virtual void callback (const std::string &name, uint8 sid) { };
00124 
00125 
00126         //
00127         // Other methods
00128         //
00129 
00131         void send (uint8 sid);
00132 
00134         void send (std::string serviceName);
00135 
00138         void className (const std::string &name);
00139 
00146         template <class T> void property (const std::string &name, TProp type, T defaultValue, T &value)
00147         {
00148                 switch (type)
00149                 {
00150                 case PropUInt8: case PropSInt8: case PropBool: nlassert(sizeof(T) == sizeof (uint8)); break;
00151                 case PropUInt16: case PropSInt16: nlassert(sizeof(T) == sizeof (uint16)); break;
00152                 case PropUInt32: case PropSInt32: nlassert(sizeof(T) == sizeof (uint32)); break;
00153                 case PropUInt64: case PropSInt64: nlassert(sizeof(T) == sizeof (uint64)); break;
00154                 case PropFloat: nlassert(sizeof(T) == sizeof (float)); break;
00155                 case PropDouble: nlassert(sizeof(T) == sizeof (double)); break;
00156                 case PropString: nlassert(sizeof(T) == sizeof (std::string)); break;
00157                 case PropEntityId: nlassert(sizeof(T) == sizeof (NLMISC::CEntityId)); break;
00158                 default: nlerror ("property %s have unknown type %d", name.c_str(), type);
00159                 }
00160 
00161                 if (Mode == 2)                  // write
00162                 {
00163                         // send only if needed
00164                         // todo manage unknown prop
00165                         TempMessage.serial (value);
00166                 }
00167                 else if (Mode == 3)     // register
00168                 {
00169                         // add a new prop to the current class
00170                         nlassert (TempRegisteredClass.Instance != NULL);
00171                         TempRegisteredClass.Instance->Prop.push_back (new CRegisteredProp<T> (name, type, defaultValue, &value));
00172                 }
00173                 else if (Mode == 4)     // display
00174                 {
00175                         std::string val;
00176                         val = "defval: ";
00177                         val += NLMISC::toString (defaultValue);
00178                         val += " val: ";
00179                         val += NLMISC::toString (value);
00180                         nldebug ("NETTC:   prop %s %d: %s", name.c_str(), type, val.c_str());
00181                 }
00182                 else
00183                 {
00184                         nlstop;
00185                 }
00186         }
00187         
00188         template <class T> void propertyCont (const std::string &name, TProp type, T &value)
00189         {
00190                 if (Mode == 2)                  // write
00191                 {
00192                         // send only if needed
00193                         // todo manage unknown prop
00194                         TempMessage.serialCont (value);
00195                 }
00196                 else if (Mode == 3)     // register
00197                 {
00198                         // add a new prop to the current class
00199                         nlassert (TempRegisteredClass.Instance != NULL);
00200                         TempRegisteredClass.Instance->Prop.push_back (new CRegisteredPropCont<T> (name, type, &value));
00201                 }
00202                 else if (Mode == 4)     // display
00203                 {
00204                         typedef typename T::iterator __iterator;
00205                         std::string val;
00206                         for (__iterator it = value.begin (); it != value.end(); it++)
00207                         {
00208                                 val += NLMISC::toString (*it);
00209                                 val += " ";
00210                         }
00211                         nldebug ("NETTC:   prop %s %d: %d elements ( %s)", name.c_str(), type, value.size(), val.c_str());
00212                 }
00213                 else
00214                 {
00215                         nlstop;
00216                 }
00217         }
00218 
00219         
00221         void display ();
00222 
00223 private:
00224 
00225         //
00226         // Structures
00227         //
00228 
00229         struct CRegisteredBaseProp
00230         {
00231                 CRegisteredBaseProp () : Type(PropUKN) { }
00232 
00233                 CRegisteredBaseProp (const std::string &name, TProp type) : Name(name), Type(type) { }
00234                 
00235                 std::string     Name;
00236                 TProp Type;
00237 
00238                 virtual void serialDefaultValue (NLMISC::IStream &f) { }
00239 
00240                 virtual void serialValue (NLMISC::IStream &f) { }
00241 
00242                 virtual void setDefaultValue () { }
00243         };
00244 
00245         typedef std::vector<std::pair<std::string, std::vector <CRegisteredBaseProp> > > TOtherSideRegisteredClass;
00246 
00247         struct CRegisteredClass
00248         {
00249                 CTransportClass *Instance;
00250 
00251                 CRegisteredClass () { clear (); }
00252 
00253                 void clear () { Instance = NULL; }
00254         };
00255 
00256         typedef std::map<std::string, CRegisteredClass> TRegisteredClass;
00257 
00258         template <class T> struct CRegisteredProp : public CRegisteredBaseProp
00259         {
00260                 CRegisteredProp () : Value(NULL) { }
00261 
00262                 CRegisteredProp (const std::string &name, TProp type, T defaultValue, T *value = NULL) :
00263                         CRegisteredBaseProp (name, type), DefaultValue(defaultValue), Value (value) { }
00264                 
00265                 T DefaultValue, *Value;
00266 
00267                 virtual void serialDefaultValue (NLMISC::IStream &f)
00268                 {
00269                         f.serial (DefaultValue);
00270                 }
00271 
00272                 virtual void serialValue (NLMISC::IStream &f)
00273                 {
00274                         nlassert (Value != NULL);
00275                         f.serial (*Value);
00276                 }
00277 
00278                 virtual void setDefaultValue ()
00279                 {
00280                         nlassert (Value != NULL);
00281                         *Value = DefaultValue;
00282                 }
00283         };
00284 
00285         template <class T> struct CRegisteredPropCont : public CRegisteredBaseProp
00286         {
00287                 CRegisteredPropCont () : Value(NULL) { }
00288 
00289                 CRegisteredPropCont (const std::string &name, TProp type, T *value = NULL) :
00290                         CRegisteredBaseProp (name, type), Value (value) { }
00291                 
00292                 T *Value;
00293 
00294                 virtual void serialDefaultValue (NLMISC::IStream &f)
00295                 {
00296                         // nothing
00297                 }
00298 
00299                 virtual void serialValue (NLMISC::IStream &f)
00300                 {
00301                         nlassert (Value != NULL);
00302                         f.serialCont (*Value);
00303                 }
00304 
00305                 virtual void setDefaultValue ()
00306                 {
00307                         nlassert (Value != NULL);
00308                         Value->clear ();
00309                 }
00310         };
00311 
00312 
00313         //
00314         // Variables
00315         //
00316 
00317         // Name of the class
00318         std::string     Name;
00319 
00320         // States to decode the stream from the network
00321         std::vector<std::vector<std::pair<sint, TProp> > > States;
00322 
00323         // Contains all propterties for this class
00324         std::vector<CRegisteredBaseProp *> Prop;
00325 
00326 
00327         //
00328         // Methods
00329         //
00330         
00331         // Read the TempMessage and call the callback
00332         void read (const std::string &name, uint8 sid);
00333 
00334         // Used to create a TempMessage with this class
00335         NLNET::CMessage &write ();
00336         
00337 
00338         //
00339         // Static Variables
00340         //
00341 
00342         // Used to serialize unused properties from the TempMessage
00343         static std::vector<CRegisteredBaseProp *>       DummyProp;
00344 
00345         // Select what the description() must do
00346         static uint                                                                     Mode;   // 0=nothing 1=read 2=write 3=register 4=display
00347 
00348         // Contains all registered transport class
00349         static TRegisteredClass                                         LocalRegisteredClass;   // registered class that are in my program
00350 
00351         // The registered class that is currently filled (before put in LocalRegisteredClass)
00352         static CRegisteredClass                                         TempRegisteredClass;
00353 
00354         // The message that is currently filled/emptyed
00355         static NLNET::CMessage                                          TempMessage;
00356 
00357         static bool                                                                     Init;
00358 
00359         //
00360         // Static methods
00361         //
00362 
00363         // Called by release() to delete all structures
00364         static void unregisterClass ();
00365 
00366         // Fill the States merging local and other side class
00367         static void registerOtherSideClass (uint8 sid, TOtherSideRegisteredClass &osrc);
00368 
00369         // Create a message with local transport classes to send to the other side
00370         static void createLocalRegisteredClassMessage ();
00371 
00372         // Send the local transport classes to another service using the service id
00373         static void sendLocalRegisteredClass (uint8 sid)
00374         {
00375                 nlassert (Init);
00376                 nldebug ("NETTC: sendLocalRegisteredClass to %d", sid);
00377                 createLocalRegisteredClassMessage ();
00378                 NLNET::CUnifiedNetwork::getInstance()->send (sid, TempMessage);
00379         }
00380 
00381         // Display a specific registered class (debug purpose)
00382         static void displayLocalRegisteredClass (CRegisteredClass &c);
00383         static void displayDifferentClass (uint8 sid, const std::string &className, const std::vector<CRegisteredBaseProp> &otherClass, const std::vector<CRegisteredBaseProp *> &myClass);
00384 
00385 
00386         //
00387         // Friends
00388         //
00389 
00390         friend void cbTCReceiveMessage (NLNET::CMessage &msgin, const std::string &name, uint16 sid);
00391         friend void cbTCUpService (const std::string &serviceName, uint16 sid, void *arg);
00392         friend void cbTCReceiveOtherSideClass (NLNET::CMessage &msgin, const std::string &name, uint16 sid);
00393 };
00394 
00395 
00396 //
00397 // Inlines
00398 //
00399 
00400 inline void CTransportClass::className (const std::string &name)
00401 {
00402         if (Mode == 2)          // write
00403         {
00404                 TempMessage.serial (const_cast<std::string &> (name));
00405         }
00406         else if (Mode == 3) // register
00407         {
00408                 // add a new entry in my registered class
00409                 nlassert (TempRegisteredClass.Instance != NULL);
00410                 TempRegisteredClass.Instance->Name = name;
00411         }
00412         else if (Mode == 4) // display
00413         {
00414                 nldebug ("NETTC: class %s:", name.c_str());
00415         }
00416         else
00417         {
00418                 nlstop;
00419         }
00420 }
00421 
00422 
00423 inline void CTransportClass::send (uint8 sid)
00424 {
00425         nlassert (Init);
00426         NLNET::CUnifiedNetwork::getInstance()->send (sid, write ());
00427 }
00428 
00429 
00430 inline void CTransportClass::send (std::string serviceName)
00431 {
00432         nlassert (Init);
00433         NLNET::CUnifiedNetwork::getInstance()->send (serviceName, write ());
00434 }
00435 
00436 inline void CTransportClass::display ()
00437 {
00438         nlassert (Mode == 0);
00439 
00440         // set the mode to register
00441         Mode = 4;
00442         
00443         description ();
00444 
00445         // set to mode none
00446         Mode = 0;
00447 }
00448 
00449 inline NLNET::CMessage &CTransportClass::write ()
00450 {
00451         nlassert (Init);
00452         nlassert (Mode == 0);
00453 
00454         // set the mode to register
00455         Mode = 2;
00456 
00457         TempMessage.clear ();
00458         if (TempMessage.isReading())
00459                 TempMessage.invert();
00460         TempMessage.setType ("CT_MSG");
00461 
00462         description ();
00463 
00464         // set to mode none
00465         Mode = 0;
00466 
00467         display ();
00468 
00469         return TempMessage;
00470 }
00471 
00472 inline void CTransportClass::read (const std::string &name, uint8 sid)
00473 {
00474         nlassert (Init);
00475         nlassert (Mode == 0);
00476         nlassert (States.size() > sid);
00477 
00478         // set flag of all prop
00479 
00480         std::vector<uint8> bitfield;
00481         bitfield.resize (Prop.size(), 0);
00482 
00483         // init prop from the stream
00484         uint i;
00485         for (i = 0; i < States[sid].size(); i++)
00486         {
00487                 if (States[sid][i].first == -1)
00488                 {
00489                         // skip the value from the stream
00490                         DummyProp[States[sid][i].second]->serialDefaultValue (TempMessage);
00491                 }
00492                 else
00493                 {
00494                         // get the good value
00495                         Prop[States[sid][i].first]->serialValue (TempMessage);
00496                         bitfield[States[sid][i].first] = 1;
00497                 }
00498         }
00499 
00500         // set default value for unknown prop
00501         for (i = 0; i < Prop.size(); i++)
00502         {
00503                 if (bitfield[i] == 0)
00504                 {
00505                         Prop[i]->setDefaultValue ();
00506                 }
00507         }
00508 
00509         display ();
00510 
00511         // call the user callback
00512         callback (name, sid);
00513 }
00514 
00515 
00516 #endif // NL_TRANSPORT_CLASS_H
00517 
00518 /* End of transport_class.h */