ryzom/server/src/server_share/logger_service_itf.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /////////////////////////////////////////////////////////////////
  18 // WARNING : this is a generated file, don't change it !
  19 /////////////////////////////////////////////////////////////////
  20
  21 #ifndef LOGGER_SERVICE_ITF
  22 #define LOGGER_SERVICE_ITF
  23 #include "nel/misc/types_nl.h"
  24 #include <memory>
  25 #include "nel/misc/hierarchical_timer.h"
  26 #include "nel/misc/string_conversion.h"
  27 #include "nel/net/message.h"
  28 #include "nel/net/module.h"
  29 #include "nel/net/module_builder_parts.h"
  30 #include "nel/net/module_message.h"
  31 #include "nel/net/module_gateway.h"
  32
  33 #include "nel/misc/entity_id.h"
  34
  35 #include "nel/misc/sheet_id.h"
  36
  37 #include "game_share/inventories.h"
  38
  39 #include <vector>
  40
  41 namespace LGS
  42 {
  43
  44         class TParamDesc;
  45
  46         class TListParamValues;
  47
  48         class TLogDefinition;
  49
  50         class TLogInfo;
  51
  52
  53
  54         struct TSupportedParamType
  55         {
  56                 enum TValues
  57                 {
  58                         spt_uint32,
  59                         spt_uint64,
  60                         spt_sint32,
  61                         spt_float,
  62                         spt_string,
  63                         spt_entityId,
  64                         spt_sheetId,
  65                         spt_itemId,
  66                         /// the highest valid value in the enum
  67                         last_enum_item = spt_itemId,
  68                         /// a value equal to the last enum item +1
  69                         end_of_enum,
  70
  71                         invalid_val,
  72
  73                         /// Number of enumerated values
  74                         nb_enum_items = 8
  75                 };
  76
  77                 /// Index table to convert enum value to linear index table
  78                 const std::map<TValues, uint32> &getIndexTable() const
  79                 {
  80                         static std::map<TValues, uint32> indexTable;
  81                         static bool init = false;
  82                         if (!init)
  83                         {
  84                                 // fill the index table
  85                                 indexTable.insert(std::make_pair(spt_uint32, 0));
  86                                 indexTable.insert(std::make_pair(spt_uint64, 1));
  87                                 indexTable.insert(std::make_pair(spt_sint32, 2));
  88                                 indexTable.insert(std::make_pair(spt_float, 3));
  89                                 indexTable.insert(std::make_pair(spt_string, 4));
  90                                 indexTable.insert(std::make_pair(spt_entityId, 5));
  91                                 indexTable.insert(std::make_pair(spt_sheetId, 6));
  92                                 indexTable.insert(std::make_pair(spt_itemId, 7));
  93
  94                                 init = true;
  95                         }
  96
  97                         return indexTable;
  98                 }
  99
 100
 101                 static const NLMISC::CStringConversion<TValues> &getConversionTable()
 102                 {
 103                         NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
 104                                 NL_STRING_CONVERSION_TABLE_ENTRY(spt_uint32)
 105                                 NL_STRING_CONVERSION_TABLE_ENTRY(spt_uint64)
 106                                 NL_STRING_CONVERSION_TABLE_ENTRY(spt_sint32)
 107                                 NL_STRING_CONVERSION_TABLE_ENTRY(spt_float)
 108                                 NL_STRING_CONVERSION_TABLE_ENTRY(spt_string)
 109                                 NL_STRING_CONVERSION_TABLE_ENTRY(spt_entityId)
 110                                 NL_STRING_CONVERSION_TABLE_ENTRY(spt_sheetId)
 111                                 NL_STRING_CONVERSION_TABLE_ENTRY(spt_itemId)
 112                                 NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
 113                         };
 114                         static NLMISC::CStringConversion<TValues>
 115                         conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
 116                         / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);
 117
 118                         return conversionTable;
 119                 }
 120
 121                 TValues _Value;
 122
 123         public:
 124                 TSupportedParamType()
 125                         : _Value(invalid_val)
 126                 {
 127                 }
 128                 TSupportedParamType(TValues value)
 129                         : _Value(value)
 130                 {
 131                 }
 132
 133                 TSupportedParamType(const std::string &str)
 134                 {
 135                         _Value = getConversionTable().fromString(str);
 136                 }
 137
 138                 void serial(NLMISC::IStream &s)
 139                 {
 140                         s.serialEnum(_Value);
 141                 }
 142
 143                 bool operator == (const TSupportedParamType &other) const
 144                 {
 145                         return _Value == other._Value;
 146                 }
 147                 bool operator != (const TSupportedParamType &other) const
 148                 {
 149                         return ! (_Value == other._Value);
 150                 }
 151                 bool operator < (const TSupportedParamType &other) const
 152                 {
 153                         return _Value < other._Value;
 154                 }
 155
 156                 bool operator <= (const TSupportedParamType &other) const
 157                 {
 158                         return _Value <= other._Value;
 159                 }
 160
 161                 bool operator > (const TSupportedParamType &other) const
 162                 {
 163                         return !(_Value <= other._Value);
 164                 }
 165                 bool operator >= (const TSupportedParamType &other) const
 166                 {
 167                         return !(_Value < other._Value);
 168                 }
 169
 170                 const std::string &toString() const
 171                 {
 172                         return getConversionTable().toString(_Value);
 173                 }
 174                 static const std::string &toString(TValues value)
 175                 {
 176                         return getConversionTable().toString(value);
 177                 }
 178
 179                 TValues getValue() const
 180                 {
 181                         return _Value;
 182                 }
 183
 184                 // return true if the actual value of the enum is valid, otherwise false
 185                 bool isValid()
 186                 {
 187                         if (_Value == invalid_val)
 188                                 return false;
 189
 190                         // not invalid, check other enum value
 191                         return getConversionTable().isValid(_Value);
 192                 }
 193
 194
 195                 uint32 asIndex()
 196                 {
 197                         std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
 198                         nlassert(it != getIndexTable().end());
 199                         return it->second;
 200                 }
 201
 202         };
 203
 204
 205
 206 //      template <class T>      LGS::TSupportedParamType getParamType();
 207 //      template <class T>      LGS::TSupportedParamType getParamType<uint32>() { return LGS::TSupportedParamType::spt_uint32;}
 208 //      template <class T>      LGS::TSupportedParamType getParamType<uint64>() { return LGS::TSupportedParamType::spt_uint64;}
 209 //      template <class T>      LGS::TSupportedParamType getParamType<sint32>() { return LGS::TSupportedParamType::spt_sint32;}
 210 //      template <class T>      LGS::TSupportedParamType getParamType<float>() { return LGS::TSupportedParamType::spt_float;}
 211 //      template <class T>      LGS::TSupportedParamType getParamType<std::string>() { return LGS::TSupportedParamType::spt_string;}
 212 //      template <class T>      LGS::TSupportedParamType getParamType<NLMISC::CEntityId>() { return LGS::TSupportedParamType::spt_entityId;}
 213 //      template <class T>      LGS::TSupportedParamType getParamType<NLMISC::CSheetId>() { return LGS::TSupportedParamType::spt_sheetId;}
 214 //      template <class T>      LGS::TSupportedParamType getParamType<INVENTORIES::TItemId>() { return LGS::TSupportedParamType::spt_itemId;}
 215
 216         struct TParamValue
 217         {
 218                 TParamValue()
 219                         :       _Type(TSupportedParamType::invalid_val)
 220                 {}
 221
 222                 TParamValue(uint32 value)
 223                 {
 224                         _Type = TSupportedParamType::spt_uint32;
 225                         _UInt32Val = value;
 226                 }
 227
 228                 TParamValue(uint64 value)
 229                 {
 230                         _Type = TSupportedParamType::spt_uint64;
 231                         _UInt64Val = value;
 232                 }
 233
 234                 TParamValue(bool value)
 235                 {
 236                         _Type = TSupportedParamType::spt_uint32;
 237                         _UInt32Val = value ? 1 : 0;
 238                 }
 239
 240                 TParamValue(sint32 value)
 241                 {
 242                         _Type = TSupportedParamType::spt_sint32;
 243                         _SInt32Val = value;
 244                 }
 245
 246                 TParamValue(float value)
 247                 {
 248                         _Type = TSupportedParamType::spt_float;
 249                         _FloatVal = value;
 250                 }
 251
 252                 TParamValue(const std::string &value)
 253                 {
 254                         _Type = TSupportedParamType::spt_string;
 255                         _StringVal = value;
 256                 }
 257
 258                 TParamValue(const NLMISC::CEntityId &value)
 259                 {
 260                         _Type = TSupportedParamType::spt_entityId;
 261                         _EntityId = value;
 262                 }
 263
 264                 TParamValue(const NLMISC::CSheetId &value)
 265                 {
 266                         _Type = TSupportedParamType::spt_sheetId;
 267                         _SheetId = value;
 268                 }
 269
 270                 TParamValue(INVENTORIES::TItemId itemId)
 271                 {
 272                         _Type = TSupportedParamType::spt_itemId;
 273                         _ItemId = itemId;
 274                 }
 275
 276                 TParamValue &operator = (const TParamValue &other)
 277                 {
 278                         _Type = other._Type;
 279
 280                         switch (_Type.getValue())
 281                         {
 282                         case TSupportedParamType::spt_uint32:
 283                                 _UInt32Val = other._UInt32Val;
 284                                 break;
 285                         case TSupportedParamType::spt_uint64:
 286                                 _UInt64Val = other._UInt64Val;
 287                                 break;
 288                         case TSupportedParamType::spt_sint32:
 289                                 _SInt32Val = other._SInt32Val;
 290                                 break;
 291                         case TSupportedParamType::spt_float:
 292                                 _FloatVal = other._FloatVal;
 293                                 break;
 294                         case TSupportedParamType::spt_string:
 295                                 _StringVal = other._StringVal;
 296                                 break;
 297                         case TSupportedParamType::spt_entityId:
 298                                 _EntityId = other._EntityId;
 299                                 break;
 300                         case TSupportedParamType::spt_sheetId:
 301                                 _SheetId = other._SheetId;
 302                                 break;
 303                         case TSupportedParamType::spt_itemId:
 304                                 _ItemId = other._ItemId;
 305                                 break;
 306                         default:
 307                                 nlstop;
 308                         };
 309
 310                         return *this;
 311                 }
 312
 313                 void serial(NLMISC::IStream &s)
 314                 {
 315                         // read the type
 316                         s.serial(_Type);
 317
 318                         // serial the value
 319                         switch (_Type.getValue())
 320                         {
 321                         case TSupportedParamType::spt_uint32:
 322                                 s.serial(_UInt32Val);
 323                                 break;
 324                         case TSupportedParamType::spt_uint64:
 325                                 s.serial(_UInt64Val);
 326                                 break;
 327                         case TSupportedParamType::spt_sint32:
 328                                 s.serial(_SInt32Val);
 329                                 break;
 330                         case TSupportedParamType::spt_float:
 331                                 s.serial(_FloatVal);
 332                                 break;
 333                         case TSupportedParamType::spt_string:
 334                                 s.serial(_StringVal);
 335                                 break;
 336                         case TSupportedParamType::spt_entityId:
 337                                 s.serial(_EntityId);
 338                                 break;
 339                         case TSupportedParamType::spt_sheetId:
 340                                 s.serial(_SheetId);
 341                                 break;
 342                         case TSupportedParamType::spt_itemId:
 343                                 s.serial(_ItemId);
 344                                 break;
 345                         default:
 346                                 nlstop;
 347                         };
 348                 }
 349
 350                 std::string toString() const
 351                 {
 352                         switch (_Type.getValue())
 353                         {
 354                         case TSupportedParamType::spt_uint32:
 355                                 return NLMISC::toString(_UInt32Val);
 356                                 break;
 357                         case TSupportedParamType::spt_uint64:
 358                                 return NLMISC::toString(_UInt64Val);
 359                                 break;
 360                         case TSupportedParamType::spt_sint32:
 361                                 return NLMISC::toString(_SInt32Val);
 362                                 break;
 363                         case TSupportedParamType::spt_float:
 364                                 return NLMISC::toString(_FloatVal);
 365                                 break;
 366                         case TSupportedParamType::spt_string:
 367                                 return _StringVal;
 368                                 break;
 369                         case TSupportedParamType::spt_entityId:
 370                                 return _EntityId.toString();
 371                                 break;
 372                         case TSupportedParamType::spt_sheetId:
 373                                 return _SheetId.toString();
 374                                 break;
 375                         case TSupportedParamType::spt_itemId:
 376                                 return NLMISC::toString(_ItemId);
 377                                 break;
 378                         default:
 379                                 nlstop;
 380
 381                                 return "";
 382                         };
 383                 }
 384
 385                 TSupportedParamType getType() const
 386                 {
 387                         return _Type;
 388                 }
 389
 390                 uint32 get_uint32() const
 391                 {
 392                         nlassert(_Type == TSupportedParamType::spt_uint32);
 393                         return _UInt32Val;
 394                 }
 395                 uint64 get_uint64() const
 396                 {
 397                         nlassert(_Type == TSupportedParamType::spt_uint64);
 398                         return _UInt64Val;
 399                 }
 400                 sint32 get_sint32() const
 401                 {
 402                         nlassert(_Type == TSupportedParamType::spt_sint32);
 403                         return _SInt32Val;
 404                 }
 405                 float get_float() const
 406                 {
 407                         nlassert(_Type == TSupportedParamType::spt_float);
 408                         return _FloatVal;
 409                 }
 410                 const std::string &get_string() const
 411                 {
 412                         nlassert(_Type == TSupportedParamType::spt_string);
 413                         return _StringVal;
 414                 }
 415                 const NLMISC::CEntityId &get_entityId() const
 416                 {
 417                         nlassert(_Type == TSupportedParamType::spt_entityId);
 418                         return _EntityId;
 419                 }
 420                 const NLMISC::CSheetId &get_sheetId() const
 421                 {
 422                         nlassert(_Type == TSupportedParamType::spt_sheetId);
 423                         return _SheetId;
 424                 }
 425                 const INVENTORIES::TItemId &get_itemId() const
 426                 {
 427                         nlassert(_Type == TSupportedParamType::spt_itemId);
 428                         return _ItemId;
 429                 }
 430
 431
 432                 const uint32 &get(const uint32 *typeTag) const
 433                 {
 434                         nlassert(_Type == TSupportedParamType::spt_uint32);
 435                         return _UInt32Val;
 436                 }
 437
 438                 const uint64 &get(const uint64 *typeTag) const
 439                 {
 440                         nlassert(_Type == TSupportedParamType::spt_uint64);
 441                         return _UInt64Val;
 442                 }
 443
 444                 const sint32 &get(const sint32 *typeTag) const
 445                 {
 446                         nlassert(_Type == TSupportedParamType::spt_sint32);
 447                         return _SInt32Val;
 448                 }
 449
 450                 const float &get(const float *typeTag) const
 451                 {
 452                         nlassert(_Type == TSupportedParamType::spt_float);
 453                         return _FloatVal;
 454                 }
 455
 456                 const std::string &get(const std::string *typeTag) const
 457                 {
 458                         nlassert(_Type == TSupportedParamType::spt_string);
 459                         return _StringVal;
 460                 }
 461
 462                 const NLMISC::CEntityId &get(const NLMISC::CEntityId *typeTag) const
 463                 {
 464                         nlassert(_Type == TSupportedParamType::spt_entityId);
 465                         return _EntityId;
 466                 }
 467
 468                 const NLMISC::CSheetId &get(const NLMISC::CSheetId *typeTag) const
 469                 {
 470                         nlassert(_Type == TSupportedParamType::spt_sheetId);
 471                         return _SheetId;
 472                 }
 473
 474                 const INVENTORIES::TItemId &get(const INVENTORIES::TItemId *typeTag) const
 475                 {
 476                         nlassert(_Type == TSupportedParamType::spt_itemId);
 477                         return _ItemId;
 478                 }
 479
 480                 bool operator == (const TParamValue &other) const
 481                 {
 482                         if (_Type != other._Type)
 483                                 return false;
 484
 485                         switch (_Type.getValue())
 486                         {
 487                         case TSupportedParamType::spt_uint32:
 488                                 return _UInt32Val == other._UInt32Val;
 489                                 break;
 490                         case TSupportedParamType::spt_uint64:
 491                                 return _UInt64Val == other._UInt64Val;
 492                                 break;
 493                         case TSupportedParamType::spt_sint32:
 494                                 return _SInt32Val == other._SInt32Val;
 495                                 break;
 496                         case TSupportedParamType::spt_float:
 497                                 return _FloatVal == other._FloatVal;
 498                                 break;
 499                         case TSupportedParamType::spt_string:
 500                                 return _StringVal == other._StringVal;
 501                                 break;
 502                         case TSupportedParamType::spt_entityId:
 503                                 return _EntityId == other._EntityId;
 504                                 break;
 505                         case TSupportedParamType::spt_sheetId:
 506                                 return _SheetId == other._SheetId;
 507                                 break;
 508                         case TSupportedParamType::spt_itemId:
 509                                 return _ItemId == other._ItemId;
 510                                 break;
 511                         default:
 512                                 return false;;
 513                         };
 514                 }
 515
 516                 bool operator < (const TParamValue &other) const
 517                 {
 518                         if (_Type != other._Type)
 519                                 return false;
 520
 521                         switch (_Type.getValue())
 522                         {
 523                         case TSupportedParamType::spt_uint32:
 524                                 return _UInt32Val < other._UInt32Val;
 525                                 break;
 526                         case TSupportedParamType::spt_uint64:
 527                                 return _UInt64Val < other._UInt64Val;
 528                                 break;
 529                         case TSupportedParamType::spt_sint32:
 530                                 return _SInt32Val < other._SInt32Val;
 531                                 break;
 532                         case TSupportedParamType::spt_float:
 533                                 return _FloatVal < other._FloatVal;
 534                                 break;
 535                         case TSupportedParamType::spt_string:
 536                                 return _StringVal < other._StringVal;
 537                                 break;
 538                         case TSupportedParamType::spt_entityId:
 539                                 return _EntityId < other._EntityId;
 540                                 break;
 541                         case TSupportedParamType::spt_sheetId:
 542                                 return _SheetId < other._SheetId;
 543                                 break;
 544                         case TSupportedParamType::spt_itemId:
 545                                 return _ItemId < other._ItemId;
 546                                 break;
 547                         default:
 548                                 return false;;
 549                         };
 550                 }
 551
 552         private:
 553                 TSupportedParamType     _Type;
 554
 555                 union
 556                 {
 557                         uint32          _UInt32Val;
 558                         uint64          _UInt64Val;
 559                         sint32          _SInt32Val;
 560                         float           _FloatVal;
 561                 };
 562                 std::string                             _StringVal;
 563                 NLMISC::CEntityId               _EntityId;
 564                 NLMISC::CSheetId                _SheetId;
 565                 INVENTORIES::TItemId    _ItemId;
 566         };
 567
 568
 569                         // Describe a param for a log entry
 570         /////////////////////////////////////////////////////////////////
 571         // WARNING : this is a generated file, don't change it !
 572         /////////////////////////////////////////////////////////////////
 573         class TParamDesc
 574         {
 575         protected:
 576                 // Name of the parameter
 577                 std::string     _Name;
 578                 // Type of the parameter
 579                 TSupportedParamType     _Type;
 580                 // Flag indicating that this parameter is a list
 581                 bool    _List;
 582         public:
 583                 // Name of the parameter
 584                 const std::string &getName() const
 585                 {
 586                         return _Name;
 587                 }
 588
 589                 std::string &getName()
 590                 {
 591                         return _Name;
 592                 }
 593
 594
 595                 void setName(const std::string &value)
 596                 {
 597
 598
 599                                 _Name = value;
 600
 601
 602                 }
 603                         // Type of the parameter
 604                 TSupportedParamType getType() const
 605                 {
 606                         return _Type;
 607                 }
 608
 609                 void setType(TSupportedParamType value)
 610                 {
 611
 612                                 _Type = value;
 613
 614                 }
 615                         // Flag indicating that this parameter is a list
 616                 bool getList() const
 617                 {
 618                         return _List;
 619                 }
 620
 621                 void setList(bool value)
 622                 {
 623
 624                                 _List = value;
 625
 626                 }
 627
 628                 bool operator == (const TParamDesc &other) const
 629                 {
 630                         return _Name == other._Name
 631                                 && _Type == other._Type
 632                                 && _List == other._List;
 633                 }
 634
 635
 636                 // constructor
 637                 TParamDesc()
 638                 {
 639                         // Default initialisation
 640                         _List = false;
 641
 642                 }
 643
 644                 void serial(NLMISC::IStream &s)
 645                 {
 646                         s.serial(_Name);
 647                         s.serial(_Type);
 648                         s.serial(_List);
 649
 650                 }
 651
 652
 653         private:
 654
 655
 656         };
 657
 658
 659                 // A vector of parameter value
 660         /////////////////////////////////////////////////////////////////
 661         // WARNING : this is a generated file, don't change it !
 662         /////////////////////////////////////////////////////////////////
 663         class TListParamValues
 664         {
 665         protected:
 666                 //
 667                 std::list < TParamValue >       _Params;
 668         public:
 669                 //
 670                 const std::list < TParamValue > &getParams() const
 671                 {
 672                         return _Params;
 673                 }
 674
 675                 std::list < TParamValue > &getParams()
 676                 {
 677                         return _Params;
 678                 }
 679
 680
 681                 void setParams(const std::list < TParamValue > &value)
 682                 {
 683
 684
 685                                 _Params = value;
 686
 687
 688                 }
 689
 690                 bool operator == (const TListParamValues &other) const
 691                 {
 692                         return _Params == other._Params;
 693                 }
 694
 695
 696                 // constructor
 697                 TListParamValues()
 698                 {
 699
 700                 }
 701
 702                 void serial(NLMISC::IStream &s)
 703                 {
 704                         s.serialCont(_Params);
 705
 706                 }
 707
 708
 709         private:
 710
 711
 712         };
 713
 714
 715                 // Definition of a log entry
 716         /////////////////////////////////////////////////////////////////
 717         // WARNING : this is a generated file, don't change it !
 718         /////////////////////////////////////////////////////////////////
 719         class TLogDefinition
 720         {
 721         protected:
 722                 // The name of the log, used to identify the log
 723                 std::string     _LogName;
 724                 // This log is a context log
 725                 bool    _Context;
 726                 // The textual content of the log, contains '__CLOSE_CONTEXT__' to close a log context
 727                 std::string     _LogText;
 728                 //
 729                 std::vector < TParamDesc >      _Params;
 730                 //
 731                 std::vector < TParamDesc >      _ListParams;
 732         public:
 733                 // The name of the log, used to identify the log
 734                 std::string getLogName() const
 735                 {
 736                         return _LogName;
 737                 }
 738
 739                 void setLogName(std::string value)
 740                 {
 741
 742                                 _LogName = value;
 743
 744                 }
 745                         // This log is a context log
 746                 bool getContext() const
 747                 {
 748                         return _Context;
 749                 }
 750
 751                 void setContext(bool value)
 752                 {
 753
 754                                 _Context = value;
 755
 756                 }
 757                         // The textual content of the log, contains '__CLOSE_CONTEXT__' to close a log context
 758                 std::string getLogText() const
 759                 {
 760                         return _LogText;
 761                 }
 762
 763                 void setLogText(std::string value)
 764                 {
 765
 766                                 _LogText = value;
 767
 768                 }
 769                         //
 770                 const std::vector < TParamDesc > &getParams() const
 771                 {
 772                         return _Params;
 773                 }
 774
 775                 std::vector < TParamDesc > &getParams()
 776                 {
 777                         return _Params;
 778                 }
 779
 780
 781                 void setParams(const std::vector < TParamDesc > &value)
 782                 {
 783
 784
 785                                 _Params = value;
 786
 787
 788                 }
 789                         //
 790                 const std::vector < TParamDesc > &getListParams() const
 791                 {
 792                         return _ListParams;
 793                 }
 794
 795                 std::vector < TParamDesc > &getListParams()
 796                 {
 797                         return _ListParams;
 798                 }
 799
 800
 801                 void setListParams(const std::vector < TParamDesc > &value)
 802                 {
 803
 804
 805                                 _ListParams = value;
 806
 807
 808                 }
 809
 810                 bool operator == (const TLogDefinition &other) const
 811                 {
 812                         return _LogName == other._LogName
 813                                 && _Context == other._Context
 814                                 && _LogText == other._LogText
 815                                 && _Params == other._Params
 816                                 && _ListParams == other._ListParams;
 817                 }
 818
 819
 820                 // constructor
 821                 TLogDefinition()
 822                 {
 823                         // Default initialisation
 824                         _Context = false;
 825
 826                 }
 827
 828                 void serial(NLMISC::IStream &s)
 829                 {
 830                         s.serial(_LogName);
 831                         s.serial(_Context);
 832                         s.serial(_LogText);
 833                         s.serialCont(_Params);
 834                         s.serialCont(_ListParams);
 835
 836                 }
 837
 838
 839         private:
 840
 841
 842         };
 843
 844
 845                 // A log entry data. This contains the parameter of a log
 846         // entry to be stored in the log archive
 847         /////////////////////////////////////////////////////////////////
 848         // WARNING : this is a generated file, don't change it !
 849         /////////////////////////////////////////////////////////////////
 850         class TLogInfo
 851         {
 852         protected:
 853                 //
 854                 std::string     _LogName;
 855                 //
 856                 uint32  _TimeStamp;
 857                 //
 858                 std::vector < TParamValue >     _Params;
 859                 //
 860                 std::vector < TListParamValues >        _ListParams;
 861         public:
 862                 //
 863                 std::string getLogName() const
 864                 {
 865                         return _LogName;
 866                 }
 867
 868                 void setLogName(std::string value)
 869                 {
 870
 871                                 _LogName = value;
 872
 873                 }
 874                         //
 875                 uint32 getTimeStamp() const
 876                 {
 877                         return _TimeStamp;
 878                 }
 879
 880                 void setTimeStamp(uint32 value)
 881                 {
 882
 883                                 _TimeStamp = value;
 884
 885                 }
 886                         //
 887                 const std::vector < TParamValue > &getParams() const
 888                 {
 889                         return _Params;
 890                 }
 891
 892                 std::vector < TParamValue > &getParams()
 893                 {
 894                         return _Params;
 895                 }
 896
 897
 898                 void setParams(const std::vector < TParamValue > &value)
 899                 {
 900
 901
 902                                 _Params = value;
 903
 904
 905                 }
 906                         //
 907                 const std::vector < TListParamValues > &getListParams() const
 908                 {
 909                         return _ListParams;
 910                 }
 911
 912                 std::vector < TListParamValues > &getListParams()
 913                 {
 914                         return _ListParams;
 915                 }
 916
 917
 918                 void setListParams(const std::vector < TListParamValues > &value)
 919                 {
 920
 921
 922                                 _ListParams = value;
 923
 924
 925                 }
 926
 927                 bool operator == (const TLogInfo &other) const
 928                 {
 929                         return _LogName == other._LogName
 930                                 && _TimeStamp == other._TimeStamp
 931                                 && _Params == other._Params
 932                                 && _ListParams == other._ListParams;
 933                 }
 934
 935
 936                 // constructor
 937                 TLogInfo()
 938                 {
 939
 940                 }
 941
 942                 void serial(NLMISC::IStream &s)
 943                 {
 944                         s.serial(_LogName);
 945                         s.serial(_TimeStamp);
 946                         s.serialCont(_Params);
 947                         s.serialCont(_ListParams);
 948
 949                 }
 950
 951
 952         private:
 953
 954
 955         };
 956
 957
 958
 959         /////////////////////////////////////////////////////////////////
 960         // WARNING : this is a generated file, don't change it !
 961         /////////////////////////////////////////////////////////////////
 962         class CLoggerServiceSkel
 963         {
 964         public:
 965                 /// the interceptor type
 966                 typedef NLNET::CInterceptorForwarder < CLoggerServiceSkel>      TInterceptor;
 967         protected:
 968                 CLoggerServiceSkel()
 969                 {
 970                         // do early run time check for message table
 971                         getMessageHandlers();
 972                 }
 973                 virtual ~CLoggerServiceSkel()
 974                 {
 975                 }
 976
 977                 void init(NLNET::IModule *module)
 978                 {
 979                         _Interceptor.init(this, module);
 980                 }
 981
 982                 // unused interceptors
 983                 std::string                     fwdBuildModuleManifest() const  { return std::string(); }
 984                 void                            fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
 985                 void                            fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
 986                 void                            fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}
 987
 988                 // process module message interceptor
 989                 bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 990         private:
 991
 992                 typedef void (CLoggerServiceSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
 993                 typedef std::map<std::string, TMessageHandler>  TMessageHandlerMap;
 994
 995                 const TMessageHandlerMap &getMessageHandlers() const;
 996
 997
 998                 void registerClient_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
 999
1000                 void reportLog_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
1001
1002                 // declare one interceptor member of the skeleton
1003                 TInterceptor    _Interceptor;
1004
1005                 // declare the interceptor forwarder as friend of this class
1006                 friend          class NLNET::CInterceptorForwarder < CLoggerServiceSkel>;
1007         public:
1008                 /////////////////////////////////////////////////////////////////
1009                 // WARNING : this is a generated file, don't change it !
1010                 /////////////////////////////////////////////////////////////////
1011
1012                 // A logger client register itself wy providing it's definition of
1013                 // the log content. It is mandatory that ALL client share
1014                 // Exactly the same definition of log.
1015                 virtual void registerClient(NLNET::IModuleProxy *sender, uint32 shardId, const std::vector < TLogDefinition > &logDef) =0;
1016                 // A client send a log
1017                 virtual void reportLog(NLNET::IModuleProxy *sender, const std::vector < TLogInfo > &logInfos) =0;
1018
1019
1020         };
1021
1022         /////////////////////////////////////////////////////////////////
1023         // WARNING : this is a generated file, don't change it !
1024         /////////////////////////////////////////////////////////////////
1025         class CLoggerServiceProxy
1026         {
1027                 /// Smart pointer on the module proxy
1028                 NLNET::TModuleProxyPtr  _ModuleProxy;
1029
1030                 // Pointer on the local module that implement the interface (if the proxy is for a local module)
1031                 NLNET::TModulePtr                                       _LocalModule;
1032                 // Direct pointer on the server implementation interface for collocated module
1033                 CLoggerServiceSkel      *_LocalModuleSkel;
1034
1035
1036         public:
1037                 CLoggerServiceProxy(NLNET::IModuleProxy *proxy)
1038                 {
1039                         nlassert(proxy->getModuleClassName() == "LoggerService");
1040                         _ModuleProxy = proxy;
1041
1042                         // initialize collocated servant interface
1043                         if (proxy->getModuleDistance() == 0)
1044                         {
1045                                 _LocalModule = proxy->getLocalModule();
1046                                 nlassert(_LocalModule != NULL);
1047                                 CLoggerServiceSkel::TInterceptor *interceptor = NULL;
1048                                 interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
1049                                 nlassert(interceptor != NULL);
1050
1051                                 _LocalModuleSkel = interceptor->getParent();
1052                                 nlassert(_LocalModuleSkel != NULL);
1053                         }
1054                         else
1055                                 _LocalModuleSkel = 0;
1056
1057                 }
1058                 virtual ~CLoggerServiceProxy()
1059                 {
1060                 }
1061
1062                 NLNET::IModuleProxy *getModuleProxy()
1063                 {
1064                         return _ModuleProxy;
1065                 }
1066
1067                 // A logger client register itself wy providing it's definition of
1068                 // the log content. It is mandatory that ALL client share
1069                 // Exactly the same definition of log.
1070                 void registerClient(NLNET::IModule *sender, uint32 shardId, const std::vector < TLogDefinition > &logDef);
1071                 // A client send a log
1072                 void reportLog(NLNET::IModule *sender, const std::vector < TLogInfo > &logInfos);
1073
1074                 // Message serializer. Return the message received in reference for easier integration
1075                 static const NLNET::CMessage &buildMessageFor_registerClient(NLNET::CMessage &__message, uint32 shardId, const std::vector < TLogDefinition > &logDef);
1076
1077                 // Message serializer. Return the message received in reference for easier integration
1078                 static const NLNET::CMessage &buildMessageFor_reportLog(NLNET::CMessage &__message, const std::vector < TLogInfo > &logInfos);
1079
1080
1081
1082
1083         };
1084
1085 }
1086
1087 #endif