X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Utils%2FLogger%2FTarget.cc;h=d352836c30125fc23c6363b2ed6d0c7a90b972e3;hb=456ee576285b76aa46240f8001f426757810dcc1;hp=997696a3d9f247613b91e062b489266b7169f3fb;hpb=ae06fe86f16fdabb7ffb219d255444d2eb4f4f79;p=senf.git

diff --git a/Utils/Logger/Target.cc b/Utils/Logger/Target.cc
index 997696a..d352836 100644
--- a/Utils/Logger/Target.cc
+++ b/Utils/Logger/Target.cc
@@ -1,8 +1,8 @@
 // $Id$
 //
-// Copyright (C) 2007 
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
+// Copyright (C) 2007
+// Fraunhofer Institute for Open Communication Systems (FOKUS)
+// Competence Center NETwork research (NET), St. Augustin, GERMANY
 //     Stefan Bund <g0dil@berlios.de>
 //
 // This program is free software; you can redistribute it and/or modify
@@ -24,9 +24,11 @@
     \brief Target non-inline non-template implementation */
 
 #include "Target.hh"
-//#include "Target.ih"
+#include "Target.ih"
 
 // Custom includes
+#include <algorithm>
+#include "ConsoleTarget.hh"
 
 //#include "Target.mpp"
 #define prefix_
@@ -37,21 +39,152 @@
 
 prefix_ senf::log::Target::Target()
 {
-    TargetRegistry::instance().registerTarget(this);
+    detail::TargetRegistry::instance().registerTarget(this);
 }
 
 prefix_ senf::log::Target::~Target()
 {
     while( ! rib_.empty()) {
-        // This is slower but simplifies the area cache handling and removing a target
-        // should be quite seldom
+        // This is slow but simplifies the area cache handling and removing a target should be
+        // relatively seldom
         RIB::reverse_iterator i (rib_.rbegin());
-        unroute(i->stream, i->area, i->level);
+        unroute(i->stream_, i->area_, i->level_, i->action_);
     }
-    TargetRegistry::instance().unregisterTarget(this);
+    detail::TargetRegistry::instance().unregisterTarget(this);
 }
 
-prefix_ void senf::log::Target::write(boost::posix_time::ptime timestamp,
+prefix_ void senf::log::Target::route(std::string const & stream, std::string const & area,
+                                      unsigned level, action_t action, int index)
+{
+    detail::StreamBase const * s (StreamRegistry::instance().lookup(stream));
+    if (!s)
+        throw InvalidStreamException();
+    detail::AreaBase const * a (0);
+    if (! area.empty()) {
+        a = AreaRegistry::instance().lookup(area);
+        if (!a)
+            throw InvalidAreaException();
+    }
+    route(s, a, level, action, index);
+}
+
+prefix_ void senf::log::Target::unroute(std::string const & stream, std::string const & area,
+                                        unsigned level, action_t action)
+{
+    detail::StreamBase const * s (StreamRegistry::instance().lookup(stream));
+    if (!s)
+        throw InvalidStreamException();
+    detail::AreaBase const * a (0);
+    if (! area.empty()) {
+        a = AreaRegistry::instance().lookup(area);
+        if (!a)
+            throw InvalidAreaException();
+    }
+    unroute(s, a, level, action);
+}
+
+prefix_ void senf::log::Target::unroute(int index)
+{
+    RIB::iterator i;
+    if (index < 0) {
+        if (RIB::size_type(-index) >= rib_.size())
+            i = rib_.begin();
+        else {
+            i = rib_.end();
+            std::advance(i, index);
+        }
+    } else {
+        if (RIB::size_type(index+1) >= rib_.size()) {
+            i = rib_.end();
+            --i;
+        } else {
+            i = rib_.begin();
+            std::advance(i, index);
+        }
+    }
+    if (i == rib_.end())
+        return;
+    RoutingEntry entry (*i);
+    rib_.erase(i);
+    if (entry.action_ == ACCEPT)
+        updateRoutingCache(entry.stream_, entry.area_);
+}
+
+////////////////////////////////////////
+// private members
+
+prefix_ void senf::log::Target::route(detail::StreamBase const * stream,
+                                      detail::AreaBase const * area, unsigned level,
+                                      action_t action, int index)
+{
+    RIB::iterator i;
+    if (index < 0) {
+        if (RIB::size_type(-index-1) >= rib_.size())
+            i = rib_.begin();
+        else {
+            i = rib_.end();
+            std::advance(i, index + 1 );
+        }
+    } else {
+        if (RIB::size_type(index) >= rib_.size())
+            i = rib_.end();
+        else {
+            i = rib_.begin();
+            std::advance(i, index);
+        }
+    }
+    rib_.insert(i, RoutingEntry(stream, area, level, action));
+    if (action == ACCEPT)
+        updateRoutingCache(stream, area);
+    // This disables the initial fallback routing
+    detail::TargetRegistry::instance().routed();
+}
+
+prefix_ void senf::log::Target::unroute(detail::StreamBase const * stream,
+                                        detail::AreaBase const * area, unsigned level, 
+                                        action_t action)
+{
+    RIB::iterator i = std::find(rib_.begin(), rib_.end(), 
+                                RoutingEntry(stream, area, level, action));
+    if (i != rib_.end())
+        unroute(std::distance(rib_.begin(), i));
+}
+
+prefix_ void senf::log::Target::updateRoutingCache(detail::StreamBase const * stream,
+                                                   detail::AreaBase const * area)
+{
+    if (! stream) {
+        StreamRegistry::Registry::iterator i (StreamRegistry::instance().registry_.begin());
+        StreamRegistry::Registry::iterator const i_end (StreamRegistry::instance().registry_.end());
+        for (; i != i_end ; ++i)
+            updateRoutingCache(i->second, area);
+        return;
+    }
+    if (! area) {
+        AreaRegistry::Registry::iterator i (AreaRegistry::instance().registry_.begin());
+        AreaRegistry::Registry::iterator const i_end (AreaRegistry::instance().registry_.end());
+        for (; i != i_end ; ++i)
+            updateRoutingCache(stream, i->second);
+        return;
+    }
+    unsigned limit (DISABLED::value);
+    RIB::iterator i (rib_.begin());
+    RIB::iterator const i_end (rib_.end());
+    for(; i != i_end; ++i)
+        if ( (! i->stream_ || i->stream_ == stream) &&
+             (! i->area_ || i->area_ == area) &&
+             i->action_ == ACCEPT ) {
+            unsigned l (i->level_ == NONE::value ? i->stream_->defaultRuntimeLimit() : i->level_);
+            if (l < limit)
+                limit = l;
+        }
+    if (limit == DISABLED::value)
+        area->removeRoutingCache(*this, *stream);
+    else
+        area->updateRoutingCache(*this, *stream, limit);
+}
+
+prefix_ void senf::log::Target::write(time_type timestamp,
                                       detail::StreamBase const & stream,
                                       detail::AreaBase const & area, unsigned level,
                                       std::string const & message)
@@ -59,26 +192,29 @@ prefix_ void senf::log::Target::write(boost::posix_time::ptime timestamp,
     RIB::iterator i (rib_.begin());
     RIB::iterator const i_end (rib_.end());
     for (; i != i_end; ++i)
-        if ( ( ! i->stream || i->stream == &stream ) &&
-             ( ! i->area || i->area == &area ) &&
-             (i->level == NONE::value ? i->stream->defaultRuntimeLimit() : i->level) <= level ) {
-            v_write(timestamp, stream.v_name(), area.v_name(), level, message);
+        if ( (! i->stream_ || i->stream_ == &stream) &&
+             (! i->area_ || i->area_ == &area) &&
+             (i->level_ == NONE::value ? i->stream_->defaultRuntimeLimit() : i->level_) <= level ) {
+            if (i->action_ == ACCEPT)
+                v_write(timestamp, stream.v_name(), area.v_name(), level, message);
             return;
         }
 }
 
 ///////////////////////////////////////////////////////////////////////////
-// senf::log::TargetRegistry
+// senf::log::detail::TargetRegistry
 
-prefix_ void senf::log::TargetRegistry::write(detail::StreamBase const & stream,
-                                              detail::AreaBase const & area, unsigned level,
-                                              std::string msg)
+prefix_ void senf::log::detail::TargetRegistry::write(StreamBase const & stream,
+                                                      AreaBase const & area, unsigned level,
+                                                      std::string msg)
 {
-    boost::posix_time::ptime timestamp (boost::posix_time::microsec_clock::universal_time());
-    Targets::iterator i (targets_.begin());
-    Targets::iterator i_end (targets_.end());
-    for(; i != i_end; ++i)
-        (*i)->write(timestamp, stream, area, level, msg);
+    if (fallbackRouting_) {
+        if (level >= stream.defaultRuntimeLimit())
+            static_cast<Target &>(ConsoleTarget::instance()).v_write( 
+                TimeSource::now(), stream.v_name(), area.v_name(), level, msg );
+    }
+    else
+        area.write( TimeSource::now(), stream, level, msg );
 }
 
 ///////////////////////////////cc.e////////////////////////////////////////