00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "log.h"
00021
00022 #ifdef NS3_LOG_ENABLE
00023
00024 #include <list>
00025 #include <utility>
00026 #include <iostream>
00027 #include "assert.h"
00028 #include "ns3/core-config.h"
00029 #include "fatal-error.h"
00030
00031 #ifdef HAVE_STDLIB_H
00032 #include <stdlib.h>
00033 #endif
00034
00035 namespace ns3 {
00036
00037 LogTimePrinter g_logTimePrinter = 0;
00038
00039 typedef std::list<std::pair <std::string, LogComponent *> > ComponentList;
00040 typedef std::list<std::pair <std::string, LogComponent *> >::iterator ComponentListI;
00041
00042 static class PrintList
00043 {
00044 public:
00045 PrintList ();
00046 } g_printList;
00047
00048 static
00049 ComponentList *GetComponentList (void)
00050 {
00051 static ComponentList components;
00052 return &components;
00053 }
00054
00055
00056
00057 PrintList::PrintList ()
00058 {
00059 #ifdef HAVE_GETENV
00060 char *envVar = getenv("NS_LOG");
00061 if (envVar == 0)
00062 {
00063 return;
00064 }
00065 std::string env = envVar;
00066 std::string::size_type cur = 0;
00067 std::string::size_type next = 0;
00068 while (next != std::string::npos)
00069 {
00070 next = env.find_first_of (":", cur);
00071 std::string tmp = std::string (env, cur, next-cur);
00072 if (tmp == "print-list")
00073 {
00074 LogComponentPrintList ();
00075 exit (0);
00076 break;
00077 }
00078 cur = next + 1;
00079 }
00080 #endif
00081 }
00082
00083
00084 LogComponent::LogComponent (char const * name)
00085 : m_levels (0), m_name (name)
00086 {
00087 EnvVarCheck (name);
00088
00089 ComponentList *components = GetComponentList ();
00090 for (ComponentListI i = components->begin ();
00091 i != components->end ();
00092 i++)
00093 {
00094 if (i->first == name)
00095 {
00096 NS_FATAL_ERROR ("Log component \""<<name<<"\" has already been registered once.");
00097 }
00098 }
00099 components->push_back (std::make_pair (name, this));
00100 }
00101
00102 void
00103 LogComponent::EnvVarCheck (char const * name)
00104 {
00105 #ifdef HAVE_GETENV
00106 char *envVar = getenv("NS_LOG");
00107 if (envVar == 0)
00108 {
00109 return;
00110 }
00111 std::string env = envVar;
00112 std::string myName = name;
00113
00114 std::string::size_type cur = 0;
00115 std::string::size_type next = 0;
00116 while (next != std::string::npos)
00117 {
00118 next = env.find_first_of (":", cur);
00119 std::string tmp = std::string (env, cur, next-cur);
00120 std::string::size_type equal = tmp.find ("=");
00121 std::string component;
00122 if (equal == std::string::npos)
00123 {
00124 component = tmp;
00125 if (component == myName || component == "*")
00126 {
00127 int level = LOG_ALL | LOG_PREFIX_TIME | LOG_PREFIX_FUNC;
00128 Enable ((enum LogLevel)level);
00129 return;
00130 }
00131 }
00132 else
00133 {
00134 component = tmp.substr (0, equal);
00135 if (component == myName || component == "*")
00136 {
00137 int level = 0;
00138 std::string::size_type cur_lev;
00139 std::string::size_type next_lev = equal;
00140 do
00141 {
00142 cur_lev = next_lev + 1;
00143 next_lev = tmp.find ("|", cur_lev);
00144 std::string lev = tmp.substr (cur_lev, next_lev - cur_lev);
00145 if (lev == "error")
00146 {
00147 level |= LOG_ERROR;
00148 }
00149 else if (lev == "warn")
00150 {
00151 level |= LOG_WARN;
00152 }
00153 else if (lev == "debug")
00154 {
00155 level |= LOG_DEBUG;
00156 }
00157 else if (lev == "info")
00158 {
00159 level |= LOG_INFO;
00160 }
00161 else if (lev == "function")
00162 {
00163 level |= LOG_FUNCTION;
00164 }
00165 else if (lev == "logic")
00166 {
00167 level |= LOG_LOGIC;
00168 }
00169 else if (lev == "all")
00170 {
00171 level |= LOG_ALL;
00172 }
00173 else if (lev == "prefix_func")
00174 {
00175 level |= LOG_PREFIX_FUNC;
00176 }
00177 else if (lev == "prefix_time")
00178 {
00179 level |= LOG_PREFIX_TIME;
00180 }
00181 else if (lev == "level_error")
00182 {
00183 level |= LOG_LEVEL_ERROR;
00184 }
00185 else if (lev == "level_warn")
00186 {
00187 level |= LOG_LEVEL_WARN;
00188 }
00189 else if (lev == "level_debug")
00190 {
00191 level |= LOG_LEVEL_DEBUG;
00192 }
00193 else if (lev == "level_info")
00194 {
00195 level |= LOG_LEVEL_INFO;
00196 }
00197 else if (lev == "level_function")
00198 {
00199 level |= LOG_LEVEL_FUNCTION;
00200 }
00201 else if (lev == "level_logic")
00202 {
00203 level |= LOG_LEVEL_LOGIC;
00204 }
00205 else if (lev == "level_all")
00206 {
00207 level |= LOG_LEVEL_ALL;
00208 }
00209 } while (next_lev != std::string::npos);
00210
00211 Enable ((enum LogLevel)level);
00212 }
00213 }
00214 cur = next + 1;
00215 }
00216 #endif
00217 }
00218
00219
00220 bool
00221 LogComponent::IsEnabled (enum LogLevel level) const
00222 {
00223
00224 return (level & m_levels) ? 1 : 0;
00225 }
00226
00227 bool
00228 LogComponent::IsNoneEnabled (void) const
00229 {
00230 return m_levels == 0;
00231 }
00232
00233 void
00234 LogComponent::Enable (enum LogLevel level)
00235 {
00236 m_levels |= level;
00237 }
00238
00239 void
00240 LogComponent::Disable (enum LogLevel level)
00241 {
00242 m_levels &= ~level;
00243 }
00244
00245 char const *
00246 LogComponent::Name (void) const
00247 {
00248 return m_name;
00249 }
00250
00251
00252 void
00253 LogComponentEnable (char const *name, enum LogLevel level)
00254 {
00255 ComponentList *components = GetComponentList ();
00256 for (ComponentListI i = components->begin ();
00257 i != components->end ();
00258 i++)
00259 {
00260 if (i->first.compare (name) == 0)
00261 {
00262 i->second->Enable (level);
00263 break;
00264 }
00265 }
00266 }
00267
00268 void
00269 LogComponentEnableAll (enum LogLevel level)
00270 {
00271 ComponentList *components = GetComponentList ();
00272 for (ComponentListI i = components->begin ();
00273 i != components->end ();
00274 i++)
00275 {
00276 i->second->Enable (level);
00277 }
00278 }
00279
00280 void
00281 LogComponentDisable (char const *name, enum LogLevel level)
00282 {
00283 ComponentList *components = GetComponentList ();
00284 for (ComponentListI i = components->begin ();
00285 i != components->end ();
00286 i++)
00287 {
00288 if (i->first.compare (name) == 0)
00289 {
00290 i->second->Disable (level);
00291 break;
00292 }
00293 }
00294 }
00295
00296 void
00297 LogComponentDisableAll (enum LogLevel level)
00298 {
00299 ComponentList *components = GetComponentList ();
00300 for (ComponentListI i = components->begin ();
00301 i != components->end ();
00302 i++)
00303 {
00304 i->second->Disable (level);
00305 }
00306 }
00307
00308 void
00309 LogComponentPrintList (void)
00310 {
00311 ComponentList *components = GetComponentList ();
00312 for (ComponentListI i = components->begin ();
00313 i != components->end ();
00314 i++)
00315 {
00316 std::cout << i->first << "=";
00317 if (i->second->IsNoneEnabled ())
00318 {
00319 std::cout << "0" << std::endl;
00320 continue;
00321 }
00322 if (i->second->IsEnabled (LOG_ERROR))
00323 {
00324 std::cout << "error";
00325 }
00326 if (i->second->IsEnabled (LOG_WARN))
00327 {
00328 std::cout << "|warn";
00329 }
00330 if (i->second->IsEnabled (LOG_DEBUG))
00331 {
00332 std::cout << "|debug";
00333 }
00334 if (i->second->IsEnabled (LOG_INFO))
00335 {
00336 std::cout << "|info";
00337 }
00338 if (i->second->IsEnabled (LOG_FUNCTION))
00339 {
00340 std::cout << "|function";
00341 }
00342 if (i->second->IsEnabled (LOG_LOGIC))
00343 {
00344 std::cout << "|logic";
00345 }
00346 if (i->second->IsEnabled (LOG_ALL))
00347 {
00348 std::cout << "|all";
00349 }
00350 std::cout << std::endl;
00351 }
00352 }
00353
00354 void LogSetTimePrinter (LogTimePrinter printer)
00355 {
00356 g_logTimePrinter = printer;
00357 }
00358 LogTimePrinter LogGetTimePrinter(void)
00359 {
00360 return g_logTimePrinter;
00361 }
00362
00363
00364 ParameterLogger::ParameterLogger (std::ostream &os)
00365 : m_itemNumber (0),
00366 m_os (os)
00367 {}
00368
00369 }
00370
00371 #else // NS3_LOG_ENABLE
00372
00373 namespace ns3 {
00374
00375 void
00376 LogComponentEnable (char const *name, enum LogLevel level)
00377 {
00378
00379 }
00380
00381 void
00382 LogComponentEnableAll (enum LogLevel level)
00383 {
00384
00385 }
00386
00387 void
00388 LogComponentDisable (char const *name, enum LogLevel level)
00389 {
00390
00391 }
00392
00393 void
00394 LogComponentDisableAll (enum LogLevel level)
00395 {
00396
00397 }
00398
00399 }
00400
00401 #endif