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 /*
00027  * Limitations: Not threadsafe, not reentrant.
00028  */
00029 
00030 
00031 //
00032 // Includes
00033 //
00034 
00035 #include "stdnet.h"
00036 
00037 #include "nel/misc/types_nl.h"
00038 #include "nel/misc/debug.h"
00039 #include "nel/misc/entity_id.h"
00040 #include "nel/misc/sheet_id.h"
00041 
00042 #include "nel/net/unified_network.h"
00043 
00044 #include "nel/net/transport_class.h"
00045 
00046 //
00047 // Namespace
00048 //
00049 
00050 using namespace std;
00051 using namespace NLMISC;
00052 using namespace NLNET;
00053 
00054 namespace NLNET {
00055 
00056 //
00057 // Variables
00058 //
00059 
00060 uint CTransportClass::Mode = 0; // 0=nothing 1=read 2=write 3=register
00061 
00062 map<string, CTransportClass::CRegisteredClass>  CTransportClass::LocalRegisteredClass;  // registered class that are in my program
00063 
00064 CTransportClass::CRegisteredClass       CTransportClass::TempRegisteredClass;
00065 
00066 NLNET::CMessage CTransportClass::TempMessage;
00067 
00068 vector<CTransportClass::CRegisteredBaseProp *> CTransportClass::DummyProp;
00069 
00070 bool CTransportClass::Init = false;
00071 
00072 
00073 //
00074 // Functions
00075 //
00076 
00077 string typeToString (CTransportClass::TProp type)
00078 {
00079         string conv[] = {
00080                 "PropUInt8", "PropUInt16", "PropUInt32", "PropUInt64",
00081                 "PropSInt8", "PropSInt16", "PropSInt32", "PropSInt64",
00082                 "PropBool", "PropFloat", "PropDouble", "PropString", "PropEntityId", "PropSheetId", "PropUKN" };
00083 
00084         if (type > CTransportClass::PropUKN)
00085                 return "<InvalidType>";
00086         return conv[type];
00087 }
00088 
00089 void CTransportClass::displayDifferentClass (uint8 sid, const string &className, const vector<CRegisteredBaseProp> &otherClass, const vector<CRegisteredBaseProp *> &myClass)
00090 {
00091         nlinfo ("Service with sid %u send me the TransportClass '%s' with differents properties:", sid, className.c_str());
00092         uint i;
00093         nlinfo ("  My local TransportClass is:");
00094         for (i = 0; i < myClass.size(); i++)
00095         {
00096                 nlinfo ("    Property: %d Name: '%s' type: '%s'", i, myClass[i]->Name.c_str(), typeToString(myClass[i]->Type).c_str());
00097         }
00098 
00099         nlinfo ("  The other side TransportClass is:");
00100         for (i = 0; i < otherClass.size(); i++)
00101         {
00102                 nlinfo ("    Property: %d Name: '%s' type: '%s'", i, otherClass[i].Name.c_str(), typeToString(otherClass[i].Type).c_str());
00103         }
00104 }
00105 
00106 void CTransportClass::registerOtherSideClass (uint8 sid, TOtherSideRegisteredClass &osrc)
00107 {
00108         for (TOtherSideRegisteredClass::iterator it = osrc.begin(); it != osrc.end (); it++)
00109         {
00110                 // find the class name in the map
00111 
00112                 TRegisteredClass::iterator res = LocalRegisteredClass.find ((*it).first);
00113                 if (res == LocalRegisteredClass.end ())
00114                 {
00115                         // it s a class that the other side have but not me, can't send this class
00116                         nlwarning ("CTransportClass::registerOtherSideClass(): the other side class '%s' is not registered in my system, skip it", (*it).first.c_str());
00117                         continue;
00118                 }
00119 
00120                 if (sid >= (*res).second.Instance->States.size ())
00121                         (*res).second.Instance->States.resize (sid+1);
00122 
00123                 (*res).second.Instance->States[sid].clear ();
00124 
00125                 for (sint j = 0; j < (sint)(*it).second.size (); j++)
00126                 {
00127                         // check each prop to see the correspondance
00128 
00129                         // try to find the prop name in the array
00130                         uint k;
00131                         for (k = 0; k < (*res).second.Instance->Prop.size(); k++)
00132                         {
00133                                 if ((*it).second[j].Name == (*res).second.Instance->Prop[k]->Name)
00134                                 {
00135                                         if ((*it).second[j].Type != (*res).second.Instance->Prop[k]->Type)
00136                                         {
00137                                                 nlwarning ("Property '%s' of the class '%s' have not the same type in the 2 sides (%s %s)", (*it).second[j].Name.c_str(), (*it).first.c_str(), typeToString((*it).second[j].Type).c_str(), typeToString((*res).second.Instance->Prop[k]->Type).c_str());
00138                                         }
00139                                         break;
00140                                 }
00141                         }
00142                         if (k == (*res).second.Instance->Prop.size())
00143                         {
00144                                 // not found, put -1
00145                                 (*res).second.Instance->States[sid].push_back (make_pair (-1, (*it).second[j].Type));
00146                         }
00147                         else
00148                         {
00149                                 // same, store the index
00150                                 (*res).second.Instance->States[sid].push_back (make_pair (k, PropUKN));
00151                         }
00152                 }
00153 
00154                 // check if the version are the same
00155                 if ((*it).second.size () != (*res).second.Instance->Prop.size ())
00156                 {
00157                         // 2 class don't have the same number of prop => different class => display class
00158                         displayDifferentClass (sid, (*it).first.c_str(), (*it).second, (*res).second.Instance->Prop);
00159                 }
00160                 else
00161                 {
00162                         // check if the prop are same
00163                         for (uint i = 0; i < (*res).second.Instance->Prop.size (); i++)
00164                         {
00165                                 if ((*res).second.Instance->Prop[i]->Name != (*it).second[i].Name)
00166                                 {
00167                                         // different name => different class => display class
00168                                         displayDifferentClass (sid, (*it).first.c_str(), (*it).second, (*res).second.Instance->Prop);
00169                                         break;
00170                                 }
00171                                 else if ((*res).second.Instance->Prop[i]->Type != (*it).second[i].Type)
00172                                 {
00173                                         // different type => different class => display class
00174                                         displayDifferentClass (sid, (*it).first.c_str(), (*it).second, (*res).second.Instance->Prop);
00175                                         break;
00176                                 }
00177                         }
00178                 }
00179         }
00180 
00181         displayLocalRegisteredClass ();
00182 }
00183 
00184 
00185 void CTransportClass::registerClass (CTransportClass &instance)
00186 {
00187         nlassert (Init);
00188         nlassert (Mode == 0);
00189 
00190         // set the mode to register
00191         Mode = 3;
00192         
00193         // clear the current class
00194         TempRegisteredClass.clear ();
00195 
00196         // set the instance pointer
00197         TempRegisteredClass.Instance = &instance;
00198 
00199         // fill name and props
00200         TempRegisteredClass.Instance->description ();
00201 
00202         // add the new registered class in the array
00203         LocalRegisteredClass[TempRegisteredClass.Instance->Name] = TempRegisteredClass;
00204 
00205         // set to mode none
00206         Mode = 0;
00207 }
00208 
00209 void CTransportClass::unregisterClass ()
00210 {
00211         for (TRegisteredClass::iterator it = LocalRegisteredClass.begin(); it != LocalRegisteredClass.end (); it++)
00212         {
00213                 for (uint j = 0; j < (*it).second.Instance->Prop.size (); j++)
00214                 {
00215                         delete (*it).second.Instance->Prop[j];
00216                 }
00217                 (*it).second.Instance->Prop.clear ();
00218                 (*it).second.Instance = NULL;
00219         }
00220         LocalRegisteredClass.clear ();
00221 }
00222 
00223 void CTransportClass::displayLocalRegisteredClass (CRegisteredClass &c)
00224 {
00225         nldebug ("NETTC:  > %s", c.Instance->Name.c_str());
00226         for (uint j = 0; j < c.Instance->Prop.size (); j++)
00227         {
00228                 nldebug ("NETTC:    > %s %s", c.Instance->Prop[j]->Name.c_str(), typeToString(c.Instance->Prop[j]->Type).c_str());
00229         }
00230 
00231         for (uint l = 0; l < c.Instance->States.size (); l++)
00232         {
00233                 if (c.Instance->States[l].size () != 0)
00234                 {
00235                         nldebug ("NETTC:      > sid: %u", l);
00236                         for (uint k = 0; k < c.Instance->States[l].size (); k++)
00237                         {
00238                                 nldebug ("NETTC:      - %d type : %s", c.Instance->States[l][k].first, typeToString(c.Instance->States[l][k].second).c_str());
00239                         }
00240                 }
00241         }
00242 }
00243 
00244 void CTransportClass::displayLocalRegisteredClass ()
00245 {
00246         nldebug ("NETTC:> LocalRegisteredClass:");
00247         for (TRegisteredClass::iterator it = LocalRegisteredClass.begin(); it != LocalRegisteredClass.end (); it++)
00248         {
00249                 displayLocalRegisteredClass ((*it).second);
00250         }
00251 }
00252 
00253 void cbTCReceiveMessage (CMessage &msgin, const string &name, uint16 sid)
00254 {
00255         nldebug ("NETTC: cbReceiveMessage");
00256 
00257         CTransportClass::TempMessage = msgin;
00258 
00259         string className;
00260         CTransportClass::TempMessage.serial (className);
00261 
00262         CTransportClass::TRegisteredClass::iterator it = CTransportClass::LocalRegisteredClass.find (className);
00263         if (it == CTransportClass::LocalRegisteredClass.end ())
00264         {
00265                 nlwarning ("receive unknown class '%s', skip it", className.c_str());
00266                 return;
00267         }
00268 
00269         nlassert ((*it).second.Instance != NULL);
00270         (*it).second.Instance->read (name, (uint8)sid);
00271 }
00272 
00273 void cbTCReceiveOtherSideClass (CMessage &msgin, const string &name, uint16 sid)
00274 {
00275         nldebug ("NETTC: cbReceiveOtherSideClass");
00276 
00277         CTransportClass::TOtherSideRegisteredClass osrc;
00278 
00279         uint32 nbClass;
00280         msgin.serial (nbClass);
00281 
00282         nldebug ("NETTC: %d class", nbClass);
00283 
00284         for (uint i = 0; i < nbClass; i++)
00285         {
00286                 string className;
00287                 msgin.serial (className);
00288 
00289                 osrc.push_back(make_pair (className, vector<CTransportClass::CRegisteredBaseProp>()));
00290 
00291                 uint32 nbProp;
00292                 msgin.serial (nbProp);
00293 
00294                 nldebug ("NETTC:   %s (%d prop)", className.c_str(), nbProp);
00295 
00296                 for (uint j = 0; j < nbProp; j++)
00297                 {
00298                         CTransportClass::CRegisteredBaseProp prop;
00299                         msgin.serial (prop.Name);
00300                         msgin.serialEnum (prop.Type);
00301                         nldebug ("NETTC:     %s %s", prop.Name.c_str(), typeToString(prop.Type).c_str());
00302                         osrc[osrc.size()-1].second.push_back (prop);
00303                 }
00304         }
00305 
00306         // we have the good structure
00307         CTransportClass::registerOtherSideClass ((uint8)sid, osrc);
00308 }
00309 
00310 static TUnifiedCallbackItem CallbackArray[] =
00311 {
00312         { "CT_LRC", cbTCReceiveOtherSideClass },
00313         { "CT_MSG", cbTCReceiveMessage },
00314 };
00315 
00316 void cbTCUpService (const std::string &serviceName, uint16 sid, void *arg)
00317 {
00318         nldebug ("NETTC: CTransportClass Service %s %d is up", serviceName.c_str(), sid);
00319         if (sid >= 256)
00320                 return;
00321         CTransportClass::sendLocalRegisteredClass ((uint8)sid);
00322 }
00323 
00324 void CTransportClass::init ()
00325 {
00326         // this isn't an error!
00327         if (Init) return;
00328 
00329         // filter all my debug stuffs
00330         DebugLog->addNegativeFilter ("NETTC");
00331 
00332 
00333         CUnifiedNetwork::getInstance()->addCallbackArray (CallbackArray, sizeof (CallbackArray) / sizeof (CallbackArray[0]));
00334 
00335         // create an instance of all d'ifferent prop types
00336 
00337         DummyProp.resize (PropUKN);
00338 
00339         nlassert (PropUInt8 < PropUKN); DummyProp[PropUInt8] = new CTransportClass::CRegisteredProp<uint8>;
00340         nlassert (PropUInt16 < PropUKN); DummyProp[PropUInt16] = new CTransportClass::CRegisteredProp<uint16>;
00341         nlassert (PropUInt32 < PropUKN); DummyProp[PropUInt32] = new CTransportClass::CRegisteredProp<uint32>;
00342         nlassert (PropUInt64 < PropUKN); DummyProp[PropUInt64] = new CTransportClass::CRegisteredProp<uint64>;
00343         nlassert (PropSInt8 < PropUKN); DummyProp[PropSInt8] = new CTransportClass::CRegisteredProp<sint8>;
00344         nlassert (PropSInt16 < PropUKN); DummyProp[PropSInt16] = new CTransportClass::CRegisteredProp<sint16>;
00345         nlassert (PropSInt32 < PropUKN); DummyProp[PropSInt32] = new CTransportClass::CRegisteredProp<sint32>;
00346         nlassert (PropSInt64 < PropUKN); DummyProp[PropSInt64] = new CTransportClass::CRegisteredProp<sint64>;
00347         nlassert (PropBool < PropUKN); DummyProp[PropBool] = new CTransportClass::CRegisteredProp<bool>;
00348         nlassert (PropFloat < PropUKN); DummyProp[PropFloat] = new CTransportClass::CRegisteredProp<float>;
00349         nlassert (PropDouble < PropUKN); DummyProp[PropDouble] = new CTransportClass::CRegisteredProp<double>;
00350         nlassert (PropString < PropUKN); DummyProp[PropString] = new CTransportClass::CRegisteredProp<string>;
00351         nlassert (PropEntityId < PropUKN); DummyProp[PropEntityId] = new CTransportClass::CRegisteredProp<CEntityId>;
00352         nlassert (PropSheetId < PropUKN); DummyProp[PropSheetId] = new CTransportClass::CRegisteredProp<CSheetId>;
00353 
00354         // we have to know when a service comes, so add callback (put the callback before all other one because we have to send this message first)
00355         CUnifiedNetwork::getInstance()->setServiceUpCallback("*", cbTCUpService, NULL, false);
00356 
00357         Init = true;
00358 }
00359 
00360 void CTransportClass::release ()
00361 {
00362         unregisterClass ();
00363 
00364         for (uint i = 0; i < DummyProp.size (); i++)
00365         {
00366                 delete DummyProp[i];
00367         }
00368         DummyProp.clear ();
00369 }
00370 
00371 void CTransportClass::createLocalRegisteredClassMessage ()
00372 {
00373         TempMessage.clear ();
00374         if (TempMessage.isReading())
00375                 TempMessage.invert();
00376         TempMessage.setType ("CT_LRC");
00377 
00378         uint32 nbClass = LocalRegisteredClass.size ();
00379         TempMessage.serial (nbClass);
00380 
00381         for (TRegisteredClass::iterator it = LocalRegisteredClass.begin(); it != LocalRegisteredClass.end (); it++)
00382         {
00383                 nlassert ((*it).first == (*it).second.Instance->Name);
00384 
00385                 TempMessage.serial ((*it).second.Instance->Name);
00386 
00387                 uint32 nbProp = (*it).second.Instance->Prop.size ();
00388                 TempMessage.serial (nbProp);
00389 
00390                 for (uint j = 0; j < (*it).second.Instance->Prop.size (); j++)
00391                 {
00392                         // send the name and the type of the prop
00393                         TempMessage.serial ((*it).second.Instance->Prop[j]->Name);
00394                         TempMessage.serialEnum ((*it).second.Instance->Prop[j]->Type);
00395                 }
00396         }
00397 }
00398 
00399 } // NLNET
transport_class.cpp
