includes/DLTWrapper.h

   1 /**
   2  * Copyright (C) 2011, BMW AG
   3  *
   4  * GeniviAudioMananger AudioManagerDaemon
   5  *
   6  * \file DLTWrapper.h
   7  *
   8  * \date 20-Oct-2011 3:42:04 PM
   9  * \author Christian Mueller (christian.ei.mueller@bmw.de)
  10  *
  11  * \section License
  12  * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
  13  * Copyright (C) 2011, BMW AG Christian Mueller  Christian.ei.mueller@bmw.de
  14  *
  15  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
  16  * This program 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 Lesser General Public License, version 2.1, for more details.
  17  * You should have received a copy of the GNU Lesser General Public License, version 2.1, along with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
  18  * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may also be applicable to programs even in cases in which the program is not a library in the technical sense.
  19  * Linking AudioManager statically or dynamically with other modules is making a combined work based on AudioManager. You may license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to license your linked modules under the GNU Lesser General Public License, version 2.1, you may use the program under the following exception.
  20  * As a special exception, the copyright holders of AudioManager give you permission to combine AudioManager with software programs or libraries that are released under any license unless such a combination is not permitted by the license of such a software program or library. You may copy and distribute such a system following the terms of the GNU Lesser General Public License, version 2.1, including this special exception, for AudioManager and the licenses of the other code concerned.
  21  * Note that people who make modified versions of AudioManager are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, version 2.1, gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.
  22  *
  23  */
  24
  25 #ifndef DLTWRAPPER_H_
  26 #define DLTWRAPPER_H_
  27
  28 #include <dlt/dlt.h>
  29 #include <string>
  30
  31 class DLTWrapper
  32 {
  33 public:
  34     static DLTWrapper* instance();
  35     void registerApp(const char *appid, const char * description);
  36     void registerContext(DltContext& handle, const char *contextid, const char * description);
  37     void unregisterContext(DltContext& handle);
  38     void init(DltLogLevelType loglevel, DltContext* context = NULL);
  39     void send();
  40     void append(const int8_t value);
  41     void append(const uint8_t value);
  42     void append(const int16_t value);
  43     void append(const uint16_t value);
  44     void append(const int32_t value);
  45     void append(const uint32_t value);
  46     void append(const char*& value);
  47     void append(const std::string& value);
  48     void append(const bool value);
  49     ~DLTWrapper();
  50 private:
  51     DLTWrapper(); //is private because of singleton pattern
  52     DltContext mDltContext;
  53     DltContextData mDltContextData;
  54     static DLTWrapper* mDLTWrapper;
  55
  56 };
  57
  58 inline DLTWrapper* getWrapper()
  59 {
  60     return DLTWrapper::instance();
  61 }
  62
  63 template<typename T> void logInfo(T value)
  64 {
  65     DLTWrapper* inst(getWrapper());
  66     inst->init(DLT_LOG_INFO);
  67     inst->append(value);
  68     inst->send();
  69 }
  70
  71 template<typename T, typename T1> void logInfo(T value, T1 value1)
  72 {
  73     DLTWrapper* inst(getWrapper());
  74     inst->init(DLT_LOG_INFO);
  75     inst->append(value);
  76     inst->append(value1);
  77     inst->send();
  78 }
  79
  80 template<typename T, typename T1, typename T2> void logInfo(T value, T1 value1, T2 value2)
  81 {
  82     DLTWrapper* inst(getWrapper());
  83     inst->init(DLT_LOG_INFO);
  84     inst->append(value);
  85     inst->append(value1);
  86     inst->append(value2);
  87     inst->send();
  88 }
  89
  90 template<typename T, typename T1, typename T2, typename T3> void logInfo(T value, T1 value1, T2 value2, T3 value3)
  91 {
  92     DLTWrapper* inst(getWrapper());
  93     inst->init(DLT_LOG_INFO);
  94     inst->append(value);
  95     inst->append(value1);
  96     inst->append(value2);
  97     inst->append(value3);
  98     inst->send();
  99 }
 100
 101 template<typename T, typename T1, typename T2, typename T3, typename T4> void logInfo(T value, T1 value1, T2 value2, T3 value3, T4 value4)
 102 {
 103     DLTWrapper* inst(getWrapper());
 104     inst->init(DLT_LOG_INFO);
 105     inst->append(value);
 106     inst->append(value1);
 107     inst->append(value2);
 108     inst->append(value3);
 109     inst->append(value4);
 110     inst->send();
 111 }
 112
 113 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5> void logInfo(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5)
 114 {
 115     DLTWrapper* inst(getWrapper());
 116     inst->init(DLT_LOG_INFO);
 117     inst->append(value);
 118     inst->append(value1);
 119     inst->append(value2);
 120     inst->append(value3);
 121     inst->append(value4);
 122     inst->append(value5);
 123     inst->send();
 124 }
 125
 126 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> void logInfo(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6)
 127 {
 128     DLTWrapper* inst(getWrapper());
 129     inst->init(DLT_LOG_INFO);
 130     inst->append(value);
 131     inst->append(value1);
 132     inst->append(value2);
 133     inst->append(value3);
 134     inst->append(value4);
 135     inst->append(value5);
 136     inst->append(value6);
 137     inst->send();
 138 }
 139
 140 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> void logInfo(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7)
 141 {
 142     DLTWrapper* inst(getWrapper());
 143     inst->init(DLT_LOG_INFO);
 144     inst->append(value);
 145     inst->append(value1);
 146     inst->append(value2);
 147     inst->append(value3);
 148     inst->append(value4);
 149     inst->append(value5);
 150     inst->append(value6);
 151     inst->append(value7);
 152     inst->send();
 153 }
 154
 155 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> void logInfo(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8)
 156 {
 157     DLTWrapper* inst(getWrapper());
 158     inst->init(DLT_LOG_INFO);
 159     inst->append(value);
 160     inst->append(value1);
 161     inst->append(value2);
 162     inst->append(value3);
 163     inst->append(value4);
 164     inst->append(value5);
 165     inst->append(value6);
 166     inst->append(value7);
 167     inst->append(value8);
 168     inst->send();
 169 }
 170
 171 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> void logInfo(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9)
 172 {
 173     DLTWrapper* inst(getWrapper());
 174     inst->init(DLT_LOG_ERROR);
 175     inst->append(value);
 176     inst->append(value1);
 177     inst->append(value2);
 178     inst->append(value3);
 179     inst->append(value4);
 180     inst->append(value5);
 181     inst->append(value6);
 182     inst->append(value7);
 183     inst->append(value8);
 184     inst->append(value9);
 185     inst->send();
 186 }
 187
 188 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> void logInfo(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10)
 189 {
 190     DLTWrapper* inst(getWrapper());
 191     inst->init(DLT_LOG_ERROR);
 192     inst->append(value);
 193     inst->append(value1);
 194     inst->append(value2);
 195     inst->append(value3);
 196     inst->append(value4);
 197     inst->append(value5);
 198     inst->append(value6);
 199     inst->append(value7);
 200     inst->append(value8);
 201     inst->append(value9);
 202     inst->append(value10);
 203     inst->send();
 204 }
 205
 206 template<typename T> void logError(T value)
 207 {
 208     DLTWrapper* inst(getWrapper());
 209     inst->init(DLT_LOG_ERROR);
 210     inst->append(value);
 211     inst->send();
 212 }
 213
 214 template<typename T, typename T1> void logError(T value, T1 value1)
 215 {
 216     DLTWrapper* inst(getWrapper());
 217     inst->init(DLT_LOG_ERROR);
 218     inst->append(value);
 219     inst->append(value1);
 220     inst->send();
 221 }
 222
 223 template<typename T, typename T1, typename T2> void logError(T value, T1 value1, T2 value2)
 224 {
 225     DLTWrapper* inst(getWrapper());
 226     inst->init(DLT_LOG_ERROR);
 227     inst->append(value);
 228     inst->append(value1);
 229     inst->append(value2);
 230     inst->send();
 231 }
 232
 233 template<typename T, typename T1, typename T2, typename T3> void logError(T value, T1 value1, T2 value2, T3 value3)
 234 {
 235     DLTWrapper* inst(getWrapper());
 236     inst->init(DLT_LOG_ERROR);
 237     inst->append(value);
 238     inst->append(value1);
 239     inst->append(value2);
 240     inst->append(value3);
 241     inst->send();
 242 }
 243
 244 template<typename T, typename T1, typename T2, typename T3, typename T4> void logError(T value, T1 value1, T2 value2, T3 value3, T4 value4)
 245 {
 246     DLTWrapper* inst(getWrapper());
 247     inst->init(DLT_LOG_ERROR);
 248     inst->append(value);
 249     inst->append(value1);
 250     inst->append(value2);
 251     inst->append(value3);
 252     inst->append(value4);
 253     inst->send();
 254 }
 255
 256 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5> void logError(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5)
 257 {
 258     DLTWrapper* inst(getWrapper());
 259     inst->init(DLT_LOG_ERROR);
 260     inst->append(value);
 261     inst->append(value1);
 262     inst->append(value2);
 263     inst->append(value3);
 264     inst->append(value4);
 265     inst->append(value5);
 266     inst->send();
 267 }
 268
 269 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> void logError(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6)
 270 {
 271     DLTWrapper* inst(getWrapper());
 272     inst->init(DLT_LOG_ERROR);
 273     inst->append(value);
 274     inst->append(value1);
 275     inst->append(value2);
 276     inst->append(value3);
 277     inst->append(value4);
 278     inst->append(value5);
 279     inst->append(value6);
 280     inst->send();
 281 }
 282
 283 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> void logError(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7)
 284 {
 285     DLTWrapper* inst(getWrapper());
 286     inst->init(DLT_LOG_ERROR);
 287     inst->append(value);
 288     inst->append(value1);
 289     inst->append(value2);
 290     inst->append(value3);
 291     inst->append(value4);
 292     inst->append(value5);
 293     inst->append(value6);
 294     inst->append(value7);
 295     inst->send();
 296 }
 297
 298 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> void logError(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8)
 299 {
 300     DLTWrapper* inst(getWrapper());
 301     inst->init(DLT_LOG_ERROR);
 302     inst->append(value);
 303     inst->append(value1);
 304     inst->append(value2);
 305     inst->append(value3);
 306     inst->append(value4);
 307     inst->append(value5);
 308     inst->append(value6);
 309     inst->append(value7);
 310     inst->append(value8);
 311     inst->send();
 312 }
 313
 314 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> void logError(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9)
 315 {
 316     DLTWrapper* inst(getWrapper());
 317     inst->init(DLT_LOG_ERROR);
 318     inst->append(value);
 319     inst->append(value1);
 320     inst->append(value2);
 321     inst->append(value3);
 322     inst->append(value4);
 323     inst->append(value5);
 324     inst->append(value6);
 325     inst->append(value7);
 326     inst->append(value8);
 327     inst->append(value9);
 328     inst->send();
 329 }
 330
 331 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> void logError(T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10)
 332 {
 333     DLTWrapper* inst(getWrapper());
 334     inst->init(DLT_LOG_ERROR);
 335     inst->append(value);
 336     inst->append(value1);
 337     inst->append(value2);
 338     inst->append(value3);
 339     inst->append(value4);
 340     inst->append(value5);
 341     inst->append(value6);
 342     inst->append(value7);
 343     inst->append(value8);
 344     inst->append(value9);
 345     inst->append(value10);
 346     inst->send();
 347 }
 348
 349 template<typename T> void log(DltContext* const context, DltLogLevelType loglevel, T value)
 350 {
 351     DLTWrapper* inst(getWrapper());
 352     inst->init(loglevel, context);
 353     inst->append(value);
 354     inst->send();
 355 }
 356
 357 template<typename T, typename T1> void log(DltContext* const context, DltLogLevelType loglevel, T value, T1 value1)
 358 {
 359     DLTWrapper* inst(getWrapper());
 360     inst->init(loglevel, context);
 361     inst->append(value);
 362     inst->append(value1);
 363     inst->send();
 364 }
 365
 366 template<typename T, typename T1, typename T2> void log(DltContext* const context, DltLogLevelType loglevel, T value, T1 value1, T2 value2)
 367 {
 368     DLTWrapper* inst(getWrapper());
 369     inst->init(loglevel, context);
 370     inst->append(value);
 371     inst->append(value1);
 372     inst->append(value2);
 373     inst->send();
 374 }
 375
 376 template<typename T, typename T1, typename T2, typename T3> void log(DltContext* const context, DltLogLevelType loglevel, T value, T1 value1, T2 value2, T3 value3)
 377 {
 378     DLTWrapper* inst(getWrapper());
 379     inst->init(loglevel, context);
 380     inst->append(value);
 381     inst->append(value1);
 382     inst->append(value2);
 383     inst->append(value3);
 384     inst->send();
 385 }
 386
 387 template<typename T, typename T1, typename T2, typename T3, typename T4> void log(DltContext* const context, DltLogLevelType loglevel, T value, T1 value1, T2 value2, T3 value3, T4 value4)
 388 {
 389     DLTWrapper* inst(getWrapper());
 390     inst->init(loglevel, context);
 391     inst->append(value);
 392     inst->append(value1);
 393     inst->append(value2);
 394     inst->append(value3);
 395     inst->append(value4);
 396     inst->send();
 397 }
 398
 399 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5> void log(DltContext* const context, DltLogLevelType loglevel, T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5)
 400 {
 401     DLTWrapper* inst(getWrapper());
 402     inst->init(loglevel, context);
 403     inst->append(value);
 404     inst->append(value1);
 405     inst->append(value2);
 406     inst->append(value3);
 407     inst->append(value4);
 408     inst->append(value5);
 409     inst->send();
 410 }
 411
 412 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> void log(DltContext* const context, DltLogLevelType loglevel, T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6)
 413 {
 414     DLTWrapper* inst(getWrapper());
 415     inst->init(loglevel, context);
 416     inst->append(value);
 417     inst->append(value1);
 418     inst->append(value2);
 419     inst->append(value3);
 420     inst->append(value4);
 421     inst->append(value5);
 422     inst->append(value6);
 423     inst->send();
 424 }
 425
 426 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> void log(DltContext* const context, DltLogLevelType loglevel, T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7)
 427 {
 428     DLTWrapper* inst(getWrapper());
 429     inst->init(loglevel, context);
 430     inst->append(value);
 431     inst->append(value1);
 432     inst->append(value2);
 433     inst->append(value3);
 434     inst->append(value4);
 435     inst->append(value5);
 436     inst->append(value6);
 437     inst->append(value7);
 438     inst->send();
 439 }
 440
 441 template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> void log(DltContext* const context, DltLogLevelType loglevel, T value, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8)
 442 {
 443     DLTWrapper* inst(getWrapper());
 444     inst->init(loglevel, context);
 445     inst->append(value);
 446     inst->append(value1);
 447     inst->append(value2);
 448     inst->append(value3);
 449     inst->append(value4);
 450     inst->append(value5);
 451     inst->append(value6);
 452     inst->append(value7);
 453     inst->append(value8);
 454     inst->send();
 455 }
 456
 457 #endif /* DLTWRAPPER_H_ */