diff options
Diffstat (limited to 'cvs/cvsweb.cgi/code/nel/src/net/transport_class.cpp?rev=1.12&content-type=text/x-cvsweb-markup&sortby=date/index.html')
| -rw-r--r-- | cvs/cvsweb.cgi/code/nel/src/net/transport_class.cpp?rev=1.12&content-type=text/x-cvsweb-markup&sortby=date/index.html | 414 |
1 files changed, 414 insertions, 0 deletions
diff --git a/cvs/cvsweb.cgi/code/nel/src/net/transport_class.cpp?rev=1.12&content-type=text/x-cvsweb-markup&sortby=date/index.html b/cvs/cvsweb.cgi/code/nel/src/net/transport_class.cpp?rev=1.12&content-type=text/x-cvsweb-markup&sortby=date/index.html new file mode 100644 index 00000000..cb3cf9c1 --- /dev/null +++ b/cvs/cvsweb.cgi/code/nel/src/net/transport_class.cpp?rev=1.12&content-type=text/x-cvsweb-markup&sortby=date/index.html @@ -0,0 +1,414 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><HTML> +<HEAD><style> A { color:black }</style> +<!-- hennerik CVSweb $Revision: 1.93 $ --> +<TITLE>code/nel/src/net/transport_class.cpp - view - 1.12</TITLE></HEAD> +<BODY BGCOLOR="#eeeeee"> +<table width="100%" border=0 cellspacing=0 cellpadding=1 bgcolor="#aaaaaa"><tr valign=bottom><td><a href="transport_class.cpp?sortby=date"><IMG SRC="http://www.nevrax.org/inc/img/picto-up.gif" ALT="[BACK]" BORDER="0" WIDTH="14" HEIGHT="13"></a> <b>Return to <A HREF="transport_class.cpp?sortby=date">transport_class.cpp</A> + CVS log</b> <IMG SRC="http://www.nevrax.org/inc/img/picto-news.gif" ALT="[TXT]" BORDER="0" WIDTH="13" HEIGHT="15"></td><td align=right><IMG SRC="http://www.nevrax.org/inc/img/picto-dir.gif" ALT="[DIR]" BORDER="0" WIDTH="15" HEIGHT="13"> <b>Up to <a href="/cvs/cvsweb.cgi/?sortby=date">Nevrax</a> / <a href="/cvs/cvsweb.cgi/code/?sortby=date">code</a> / <a href="/cvs/cvsweb.cgi/code/nel/?sortby=date">nel</a> / <a href="/cvs/cvsweb.cgi/code/nel/src/?sortby=date">src</a> / <a href="/cvs/cvsweb.cgi/code/nel/src/net/?sortby=date">net</a></b></td></tr></table><HR noshade><table width="100%"><tr><td bgcolor="#ffffff">File: <a href="/cvs/cvsweb.cgi/?sortby=date">Nevrax</a> / <a href="/cvs/cvsweb.cgi/code/?sortby=date">code</a> / <a href="/cvs/cvsweb.cgi/code/nel/?sortby=date">nel</a> / <a href="/cvs/cvsweb.cgi/code/nel/src/?sortby=date">src</a> / <a href="/cvs/cvsweb.cgi/code/nel/src/net/?sortby=date">net</a> / <a href="/cvs/cvsweb.cgi/code/nel/src/net/transport_class.cpp?sortby=date">transport_class.cpp</a> (<A HREF="/cvs/cvsweb.cgi/~checkout~/code/nel/src/net/transport_class.cpp?rev=1.12&sortby=date" target="cvs_checkout" onClick="window.open('/cvs/cvsweb.cgi/~checkout~/code/nel/src/net/transport_class.cpp?rev=1.12','cvs_checkout','resizeable,scrollbars');"><b>download</b></A>)<BR> +Revision <B>1.12</B>, <i>Tue Jul 2 17:27:30 2002 UTC</i> (3 weeks, 6 days ago) by <i>miller</i> +<BR>Branch: <b>MAIN</b> +<BR>CVS Tags: <b>HEAD</b><BR>Changes since <b>1.11: +3 -2 + lines</b><PRE> +bug fix by Vianney +</PRE> +</td></tr></table><HR noshade><PRE>/** \file transport_class.cpp + * <File description> + * + * $Id: transport_class.cpp,v 1.12 2002/07/02 17:27:30 miller Exp $ + */ + +/* Copyright, 2000-2002 Nevrax Ltd. + * + * This file is part of NEVRAX NeL Network Services. + * NEVRAX NeL Network Services is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + + * NEVRAX NeL Network Services is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with NEVRAX NeL Network Services; see the file COPYING. If not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + * MA 02111-1307, USA. + */ + +/* + * Limitations: Not threadsafe, not reentrant. + */ + + +// +// Includes +// + +#include "stdnet.h" + +#include "nel/misc/types_nl.h" +#include "nel/misc/debug.h" +#include "nel/misc/entity_id.h" +#include "nel/misc/sheet_id.h" + +#include "nel/net/unified_network.h" + +#include "nel/net/transport_class.h" + +// +// Namespace +// + +using namespace std; +using namespace NLMISC; +using namespace NLNET; + +namespace NLNET { + +// +// Variables +// + +uint CTransportClass::Mode = 0; // 0=nothing 1=read 2=write 3=register + +map<string, CTransportClass::CRegisteredClass> CTransportClass::LocalRegisteredClass; // registered class that are in my program + +CTransportClass::CRegisteredClass CTransportClass::TempRegisteredClass; + +NLNET::CMessage CTransportClass::TempMessage; + +vector<CTransportClass::CRegisteredBaseProp *> CTransportClass::DummyProp; + +bool CTransportClass::Init = false; + + +// +// Functions +// + +string typeToString (CTransportClass::TProp type) +{ + string conv[] = { + "PropUInt8", "PropUInt16", "PropUInt32", "PropUInt64", + "PropSInt8", "PropSInt16", "PropSInt32", "PropSInt64", + "PropBool", "PropFloat", "PropDouble", "PropString", "PropEntityId", "PropSheetId", "PropUKN" }; + + if (type > CTransportClass::PropUKN) + return "<InvalidType>"; + else + return conv[type]; +} + +void CTransportClass::displayDifferentClass (uint8 sid, const string &className, const vector<CRegisteredBaseProp> &otherClass, const vector<CRegisteredBaseProp *> &myClass) +{ + nlinfo ("Service with sid %u send me the TransportClass '%s' with differents properties:", sid, className.c_str()); + uint i; + nlinfo (" My local TransportClass is:"); + for (i = 0; i < myClass.size(); i++) + { + nlinfo (" Property: %d Name: '%s' type: '%s'", i, myClass[i]->Name.c_str(), typeToString(myClass[i]->Type).c_str()); + } + + nlinfo (" The other side TransportClass is:"); + for (i = 0; i < otherClass.size(); i++) + { + nlinfo (" Property: %d Name: '%s' type: '%s'", i, otherClass[i].Name.c_str(), typeToString(otherClass[i].Type).c_str()); + } +} + +void CTransportClass::registerOtherSideClass (uint8 sid, TOtherSideRegisteredClass &osrc) +{ + for (TOtherSideRegisteredClass::iterator it = osrc.begin(); it != osrc.end (); it++) + { + // find the class name in the map + + TRegisteredClass::iterator res = LocalRegisteredClass.find ((*it).first); + if (res == LocalRegisteredClass.end ()) + { + // it s a class that the other side have but not me, can't send this class + nlwarning ("CTransportClass::registerOtherSideClass(): the other side class '%s' is not registered in my system, skip it", (*it).first.c_str()); + continue; + } + + if (sid >= (*res).second.Instance->States.size ()) + (*res).second.Instance->States.resize (sid+1); + + (*res).second.Instance->States[sid].clear (); + + for (sint j = 0; j < (sint)(*it).second.size (); j++) + { + // check each prop to see the correspondance + + // try to find the prop name in the array + uint k; + for (k = 0; k < (*res).second.Instance->Prop.size(); k++) + { + if ((*it).second[j].Name == (*res).second.Instance->Prop[k]->Name) + { + if ((*it).second[j].Type != (*res).second.Instance->Prop[k]->Type) + { + 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()); + } + break; + } + } + if (k == (*res).second.Instance->Prop.size()) + { + // not found, put -1 + (*res).second.Instance->States[sid].push_back (make_pair (-1, (*it).second[j].Type)); + } + else + { + // same, store the index + (*res).second.Instance->States[sid].push_back (make_pair (k, PropUKN)); + } + } + + // check if the version are the same + if ((*it).second.size () != (*res).second.Instance->Prop.size ()) + { + // 2 class don't have the same number of prop => different class => display class + displayDifferentClass (sid, (*it).first.c_str(), (*it).second, (*res).second.Instance->Prop); + } + else + { + // check if the prop are same + for (uint i = 0; i < (*res).second.Instance->Prop.size (); i++) + { + if ((*res).second.Instance->Prop[i]->Name != (*it).second[i].Name) + { + // different name => different class => display class + displayDifferentClass (sid, (*it).first.c_str(), (*it).second, (*res).second.Instance->Prop); + break; + } + else if ((*res).second.Instance->Prop[i]->Type != (*it).second[i].Type) + { + // different type => different class => display class + displayDifferentClass (sid, (*it).first.c_str(), (*it).second, (*res).second.Instance->Prop); + break; + } + } + } + } + + displayLocalRegisteredClass (); +} + + +void CTransportClass::registerClass (CTransportClass &instance) +{ + nlassert (Init); + nlassert (Mode == 0); + + // set the mode to register + Mode = 3; + + // clear the current class + TempRegisteredClass.clear (); + + // set the instance pointer + TempRegisteredClass.Instance = &instance; + + // fill name and props + TempRegisteredClass.Instance->description (); + + // add the new registered class in the array + LocalRegisteredClass[TempRegisteredClass.Instance->Name] = TempRegisteredClass; + + // set to mode none + Mode = 0; +} + +void CTransportClass::unregisterClass () +{ + for (TRegisteredClass::iterator it = LocalRegisteredClass.begin(); it != LocalRegisteredClass.end (); it++) + { + for (uint j = 0; j < (*it).second.Instance->Prop.size (); j++) + { + delete (*it).second.Instance->Prop[j]; + } + (*it).second.Instance->Prop.clear (); + (*it).second.Instance = NULL; + } + LocalRegisteredClass.clear (); +} + +void CTransportClass::displayLocalRegisteredClass (CRegisteredClass &c) +{ + nldebug ("NETTC: > %s", c.Instance->Name.c_str()); + for (uint j = 0; j < c.Instance->Prop.size (); j++) + { + nldebug ("NETTC: > %s %s", c.Instance->Prop[j]->Name.c_str(), typeToString(c.Instance->Prop[j]->Type).c_str()); + } + + for (uint l = 0; l < c.Instance->States.size (); l++) + { + if (c.Instance->States[l].size () != 0) + { + nldebug ("NETTC: > sid: %u", l); + for (uint k = 0; k < c.Instance->States[l].size (); k++) + { + nldebug ("NETTC: - %d type : %s", c.Instance->States[l][k].first, typeToString(c.Instance->States[l][k].second).c_str()); + } + } + } +} + +void CTransportClass::displayLocalRegisteredClass () +{ + nldebug ("NETTC:> LocalRegisteredClass:"); + for (TRegisteredClass::iterator it = LocalRegisteredClass.begin(); it != LocalRegisteredClass.end (); it++) + { + displayLocalRegisteredClass ((*it).second); + } +} + +void cbTCReceiveMessage (CMessage &msgin, const string &name, uint16 sid) +{ + nldebug ("NETTC: cbReceiveMessage"); + + CTransportClass::TempMessage = msgin; + + string className; + CTransportClass::TempMessage.serial (className); + + CTransportClass::TRegisteredClass::iterator it = CTransportClass::LocalRegisteredClass.find (className); + if (it == CTransportClass::LocalRegisteredClass.end ()) + { + nlwarning ("receive unknown class '%s', skip it", className.c_str()); + return; + } + + nlassert ((*it).second.Instance != NULL); + (*it).second.Instance->read (name, (uint8)sid); +} + +void cbTCReceiveOtherSideClass (CMessage &msgin, const string &name, uint16 sid) +{ + nldebug ("NETTC: cbReceiveOtherSideClass"); + + CTransportClass::TOtherSideRegisteredClass osrc; + + uint32 nbClass; + msgin.serial (nbClass); + + nldebug ("NETTC: %d class", nbClass); + + for (uint i = 0; i < nbClass; i++) + { + string className; + msgin.serial (className); + + osrc.push_back(make_pair (className, vector<CTransportClass::CRegisteredBaseProp>())); + + uint32 nbProp; + msgin.serial (nbProp); + + nldebug ("NETTC: %s (%d prop)", className.c_str(), nbProp); + + for (uint j = 0; j < nbProp; j++) + { + CTransportClass::CRegisteredBaseProp prop; + msgin.serial (prop.Name); + msgin.serialEnum (prop.Type); + nldebug ("NETTC: %s %s", prop.Name.c_str(), typeToString(prop.Type).c_str()); + osrc[osrc.size()-1].second.push_back (prop); + } + } + + // we have the good structure + CTransportClass::registerOtherSideClass ((uint8)sid, osrc); +} + +static TUnifiedCallbackItem CallbackArray[] = +{ + { "CT_LRC", cbTCReceiveOtherSideClass }, + { "CT_MSG", cbTCReceiveMessage }, +}; + +void cbTCUpService (const std::string &serviceName, uint16 sid, void *arg) +{ + nldebug ("NETTC: CTransportClass Service %s %d is up", serviceName.c_str(), sid); + if (sid >= 256) + return; + CTransportClass::sendLocalRegisteredClass ((uint8)sid); +} + +void CTransportClass::init () +{ + // this isn't an error! + if (Init) return; + + // filter all my debug stuffs + DebugLog->addNegativeFilter ("NETTC"); + + + CUnifiedNetwork::getInstance()->addCallbackArray (CallbackArray, sizeof (CallbackArray) / sizeof (CallbackArray[0])); + + // create an instance of all d'ifferent prop types + + DummyProp.resize (PropUKN); + + nlassert (PropUInt8 < PropUKN); DummyProp[PropUInt8] = new CTransportClass::CRegisteredProp<uint8>; + nlassert (PropUInt16 < PropUKN); DummyProp[PropUInt16] = new CTransportClass::CRegisteredProp<uint16>; + nlassert (PropUInt32 < PropUKN); DummyProp[PropUInt32] = new CTransportClass::CRegisteredProp<uint32>; + nlassert (PropUInt64 < PropUKN); DummyProp[PropUInt64] = new CTransportClass::CRegisteredProp<uint64>; + nlassert (PropSInt8 < PropUKN); DummyProp[PropSInt8] = new CTransportClass::CRegisteredProp<sint8>; + nlassert (PropSInt16 < PropUKN); DummyProp[PropSInt16] = new CTransportClass::CRegisteredProp<sint16>; + nlassert (PropSInt32 < PropUKN); DummyProp[PropSInt32] = new CTransportClass::CRegisteredProp<sint32>; + nlassert (PropSInt64 < PropUKN); DummyProp[PropSInt64] = new CTransportClass::CRegisteredProp<sint64>; + nlassert (PropBool < PropUKN); DummyProp[PropBool] = new CTransportClass::CRegisteredProp<bool>; + nlassert (PropFloat < PropUKN); DummyProp[PropFloat] = new CTransportClass::CRegisteredProp<float>; + nlassert (PropDouble < PropUKN); DummyProp[PropDouble] = new CTransportClass::CRegisteredProp<double>; + nlassert (PropString < PropUKN); DummyProp[PropString] = new CTransportClass::CRegisteredProp<string>; + nlassert (PropEntityId < PropUKN); DummyProp[PropEntityId] = new CTransportClass::CRegisteredProp<CEntityId>; + nlassert (PropSheetId < PropUKN); DummyProp[PropSheetId] = new CTransportClass::CRegisteredProp<CSheetId>; + + // 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) + CUnifiedNetwork::getInstance()->setServiceUpCallback("*", cbTCUpService, NULL, false); + + Init = true; +} + +void CTransportClass::release () +{ + unregisterClass (); + + for (uint i = 0; i < DummyProp.size (); i++) + { + delete DummyProp[i]; + } + DummyProp.clear (); +} + +void CTransportClass::createLocalRegisteredClassMessage () +{ + TempMessage.clear (); + if (TempMessage.isReading()) + TempMessage.invert(); + TempMessage.setType ("CT_LRC"); + + uint32 nbClass = LocalRegisteredClass.size (); + TempMessage.serial (nbClass); + + for (TRegisteredClass::iterator it = LocalRegisteredClass.begin(); it != LocalRegisteredClass.end (); it++) + { + nlassert ((*it).first == (*it).second.Instance->Name); + + TempMessage.serial ((*it).second.Instance->Name); + + uint32 nbProp = (*it).second.Instance->Prop.size (); + TempMessage.serial (nbProp); + + for (uint j = 0; j < (*it).second.Instance->Prop.size (); j++) + { + // send the name and the type of the prop + TempMessage.serial ((*it).second.Instance->Prop[j]->Name); + TempMessage.serialEnum ((*it).second.Instance->Prop[j]->Type); + } + } +} + +} // NLNET +</PRE>
\ No newline at end of file |