Implement src/dst address pinting in pcapslice. Remove deprecated throw.

Author: saleyn

.idea/emacs.xml

@@ -351,15 +351,15 @@ namespace config {
         const variant_tree_base& def(
              const tree_path& a_path,
              const tree_path& a_root_path  = tree_path()
-         ) const throw (variant_tree_error);
+         ) const;
 
         /// Get default value for a named option.
         /// @return default value for a given option's path.
         template <class T>
         T def_value(
             const tree_path& a_path,
             const tree_path& a_root_path  = tree_path()
-        ) const throw (variant_tree_error)
+        ) const
         {
             return def(a_path, a_root_path).data().get<T>();
         }
@@ -388,15 +388,14 @@ namespace config {
 
         void validate(variant_tree& a_config, bool a_fill_defaults,
             const custom_validator& a_custom_validator = NULL
-        ) const throw(variant_tree_error);
+        ) const;
 
         void validate(const variant_tree& a_config,
             const custom_validator& a_custom_validator = NULL
-        ) const throw(variant_tree_error);
+        ) const;
 
         // Validate configuration tree stored in config()
-        void validate(const custom_validator& a_custom_validator = NULL)
-            const throw(variant_tree_error);
+        void validate(const custom_validator& a_custom_validator = NULL) const;
 
     protected:
         mutable tree_path                m_root;   // Path from configuration root
@@ -412,7 +411,7 @@ namespace config {
         void validate(variant_tree& a_config,
             const option_map& a_opts, bool fill_defaults,
             const custom_validator& a_custom_validator
-        ) const throw(variant_tree_error);
+        ) const;
 
         static void add_option(option_map& a, const option& a_opt) {
             a.insert(std::make_pair(a_opt.name, a_opt));
@@ -459,20 +458,19 @@ namespace config {
             config_level_list&      a_stack,
             bool                    a_fill_defaults,
             const custom_validator& a_custom_validator
-        ) const throw(variant_tree_error);
+        ) const;
 
         void check_option(
             config_level_list&                      a_stack,
             typename variant_tree_base::value_type& a_vt,
             bool                                    a_fill_defaults,
             const custom_validator&                 a_custom_validator
-        ) const throw(std::invalid_argument, variant_tree_error);
+        ) const;
 
         void check_unique(const tree_path& a_root, const variant_tree_base& a_config,
-            const option_map& a_opts) const throw(variant_tree_error);
+            const option_map& a_opts) const;
 
-        void check_required(config_level_list& a_stack) const
-            throw (missing_required_option_error, variant_tree_error);
+        void check_required(config_level_list& a_stack) const;
 
         static option_type_t to_option_type(variant::value_type a_type);
 
@@ -495,8 +493,7 @@ namespace config {
         }
 
         tree_path strip_root(const tree_path& a_root_path,
-                             const tree_path& a_root = tree_path()) const
-            throw(variant_tree_error);
+                             const tree_path& a_root = tree_path()) const;
 
         static const option* find(tree_path& a_suffix, const option_map& a_options)
             throw ();

.idea/rebar.xml

@@ -446,8 +446,7 @@ struct logger : boost::noncopyable {
     };
 
     typedef delegate
-        <void (const msg& a_msg, const char* a_buf, size_t a_size)
-               throw(io_error)>
+        <void (const msg& a_msg, const char* a_buf, size_t a_size)>
         on_msg_delegate_t;
 
     // Maps macros to values that can be used in configuration
@@ -647,17 +646,17 @@ struct logger : boost::noncopyable {
     /// This method is used for configuration parsing.
     /// @param a_levels delimited log levels (e.g. "DEBUG | INFO | WARNING").
     [[deprecated]]
-    static int parse_log_levels(const std::string& levels) throw(std::runtime_error)
+    static int parse_log_levels(const std::string& levels)
         { return utxx::parse_log_levels(levels); }
 
     /// Converts a string (e.g. "INFO") to the corresponding log level.
     [[deprecated]]
-    static log_level parse_log_level(const std::string& a_level) throw(std::runtime_error)
+    static log_level parse_log_level(const std::string& a_level)
         { return utxx::parse_log_level(a_level); }
 
     /// Convert a string (e.g. "INFO") to the log levels greater or equal to it.
     [[deprecated]]
-    static int parse_min_log_level(const std::string& a_level) throw(std::runtime_error)
+    static int parse_min_log_level(const std::string& a_level)
         { return utxx::parse_min_log_level(a_level); }
 
     /// String representation of log levels enabled by default.  Used in config
@@ -829,8 +828,7 @@ struct logger_impl {
     /// Name of the logger
     virtual const std::string& name() const = 0;
 
-    virtual bool init(const variant_tree& a_config)
-        throw(badarg_error, io_error) = 0;
+    virtual bool init(const variant_tree& a_config) = 0;
 
     /// Dump all settings to stream
     virtual std::ostream& dump(std::ostream& out, const std::string& a_prefix) const = 0;

include/utxx/config_validator.hpp

@@ -72,11 +72,9 @@ class logger_impl_console: public logger_impl {
     /// Dump all settings to stream
     std::ostream& dump(std::ostream& out, const std::string& a_prefix) const;
 
-    bool init(const variant_tree& a_config)
-        throw(badarg_error, io_error);
+    bool init(const variant_tree& a_config);
 
-    void log_msg(const logger::msg& a_msg, const char* a_buf, size_t a_size)
-         throw  (io_error);
+    void log_msg(const logger::msg& a_msg, const char* a_buf, size_t a_size);
 };
 
 } // namespace utxx

include/utxx/logger/logger.hpp

@@ -97,11 +97,9 @@ class logger_impl_file: public logger_impl {
     /// Dump all settings to stream
     std::ostream& dump(std::ostream& out, const std::string& a_prefix) const;
 
-    bool init(const variant_tree& a_config)
-        throw(badarg_error, io_error);
+    bool init(const variant_tree& a_config);
 
-    void log_msg(const logger::msg& a_msg, const char* a_buf, size_t a_size)
-        throw(io_error);
+    void log_msg(const logger::msg& a_msg, const char* a_buf, size_t a_size);
 };
 
 } // namespace utxx

include/utxx/logger/logger_impl_console.hpp

@@ -88,11 +88,9 @@ class logger_impl_syslog: public logger_impl {
     /// Dump all settings to stream
     std::ostream& dump(std::ostream& out, const std::string& a_prefix) const;
 
-    bool init(const variant_tree& a_config)
-        throw(badarg_error, io_error);
+    bool init(const variant_tree& a_config);
 
-    void log_msg(const logger::msg& a_msg, const char* a_buf, size_t a_size)
-        throw(io_error);
+    void log_msg(const logger::msg& a_msg, const char* a_buf, size_t a_size);
 };
 
 } // namespace utxx

include/utxx/logger/logger_impl_file.hpp

@@ -64,12 +64,12 @@ namespace utxx {
     /// Converts a delimited string to a bitmask of corresponding levels.
     /// This method is used for configuration parsing.
     /// @param a_levels delimited log levels (e.g. "DEBUG | INFO | WARNING").
-    int parse_log_levels(const std::string& levels) throw(std::runtime_error);
+    int parse_log_levels(const std::string& levels);
 
     /// Converts a string (e.g. "INFO") to the corresponding log level.
-    log_level parse_log_level(const std::string& a_level) throw(std::runtime_error);
+    log_level parse_log_level(const std::string& a_level);
 
     /// Convert a string (e.g. "INFO") to the log levels greater or equal to it.
-    int parse_min_log_level(const std::string& a_level) throw(std::runtime_error);
+    int parse_min_log_level(const std::string& a_level);
 
 } // namespace utxx

include/utxx/logger/logger_impl_syslog.hpp

@@ -98,6 +98,19 @@ struct pcap {
             return std::string(buf);
         }
 
+        template <int N>
+        char* src(char (&buf)[N]) const {
+            char* p = fmt(buf, src_ip());
+            assert(p-buf <= N);
+            return p;
+        }
+        template <int N>
+        char* dst(char (&buf)[N]) const {
+            char* p = fmt(buf, dst_ip());
+            assert(p-buf <= N);
+            return p;
+        }
+
         template <int N>
         static char* fmt(char (&p)[N], uint32_t ip) {
             static_assert(N >= 16, "Buffer too small!");
@@ -115,14 +128,27 @@ struct pcap {
         uint16_t dst_port() const { return ntohs(udp.dest);   }
 
         std::string src() const {
-            char buf[32]; fmt(ip_frame::fmt(buf, src_ip()), src_port());
+            char buf[32]; src(buf);
             return std::string(buf);
         }
         std::string dst() const {
-            char buf[32]; fmt(ip_frame::fmt(buf, dst_ip()), dst_port());
+            char buf[32]; dst(buf);
             return std::string(buf);
         }
 
+        template <int N>
+        char* src(char (&buf)[N]) const {
+            char* p = fmt(ip_frame::fmt(buf, src_ip()), src_port());
+            assert(p-buf <= N);
+            return p;
+        }
+        template <int N>
+        char* dst(char (&buf)[N]) const {
+            char* p = fmt(ip_frame::fmt(buf, dst_ip()), dst_port());
+            assert(p-buf <= N);
+            return p;
+        }
+
     private:
         static char* fmt(char* buf, uint16_t port) {
             return buf + sprintf(buf, ":%d", port);
@@ -138,14 +164,27 @@ struct pcap {
         uint16_t dst_port() const { return ntohs(tcp.dest);   }
 
         std::string src() const {
-            char buf[32]; fmt(ip_frame::fmt(buf, src_ip()), src_port());
+            char buf[32]; src(buf);
             return std::string(buf);
         }
         std::string dst() const {
-            char buf[32]; fmt(ip_frame::fmt(buf, dst_ip()), dst_port());
+            char buf[32]; dst(buf);
             return std::string(buf);
         }
 
+        template <int N>
+        char* src(char (&buf)[N]) const {
+            char* p = fmt(ip_frame::fmt(buf, src_ip()), src_port());
+            assert(p-&buf[0] <= N);
+            return p;
+        }
+        template <int N>
+        char* dst(char (&buf)[N]) const {
+            char* p = fmt(ip_frame::fmt(buf, dst_ip()), dst_port());
+            assert(p-&buf[0] <= N);
+            return p;
+        }
+
     private:
         static char* fmt(char* buf, uint16_t port) {
             return buf + sprintf(buf, ":%d", port);

include/utxx/logger/logger_util.hpp

@@ -110,7 +110,7 @@ namespace utxx {
         T*      m_begin;
         T*      m_end;
 
-        void check_range(size_t a_id) const throw (badarg_error) {
+        void check_range(size_t a_id) const {
             size_t n = m_header->max_recs;
             if (likely(a_id < n))
                 return;
@@ -158,7 +158,7 @@ namespace utxx {
         /// @return true if the storage file didn't exist and was created
         bool init(const char* a_filename, size_t a_max_recs, bool a_read_only = false,
             int a_mode = default_file_mode(), void const* a_map_address = nullptr,
-            int a_map_options = 0) throw (io_error, utxx::runtime_error);
+            int a_map_options = 0);
 
         /// Initialize the storage in shared memory.
         /// @param a_segment  the shared memory segment
@@ -168,8 +168,7 @@ namespace utxx {
         /// @param a_max_recs max capacity of the storage in the number of records
         /// @return true if the shared memory object didn't exist and was created
         bool init(bip::fixed_managed_shared_memory& a_segment,
-                  const char* a_name, persist_attach_type a_flag, size_t a_max_recs)
-                  throw (utxx::runtime_error);
+                  const char* a_name, persist_attach_type a_flag, size_t a_max_recs);
 
         size_t count()    const { return m_header->rec_count.load(std::memory_order_relaxed); }
         size_t capacity() const { return m_header->max_recs; }
@@ -180,7 +179,7 @@ namespace utxx {
 
         /// Allocate next record and return its ID.
         /// @return
-        size_t allocate_rec() throw(utxx::runtime_error) {
+        size_t allocate_rec() {
             auto error = [this]() {
                 throw utxx::runtime_error
                     ("persist_array: Out of storage capacity (", this->m_storage_name, ")!");
@@ -235,10 +234,10 @@ namespace utxx {
         /// @return id of the given object in the storage
         size_t id_of(const T* a_rec) const { return a_rec - m_begin; }
 
-        const T& operator[] (size_t a_id) const throw(badarg_error) {
+        const T& operator[] (size_t a_id) const {
             check_range(a_id); return *get(a_id);
         }
-        T& operator[] (size_t a_id) throw(badarg_error) {
+        T& operator[] (size_t a_id) {
             check_range(a_id); return *get(a_id);
         }
 
@@ -314,8 +313,8 @@ namespace utxx {
 
     template <typename T, size_t NLocks, typename Lock, typename Ext>
     bool persist_array<T,NLocks,Lock,Ext>::
-    init(const char* a_filename, size_t a_max_recs, bool a_read_only, int a_mode, void const* a_map_address, int a_map_options)
-        throw (io_error, utxx::runtime_error)
+    init(const char* a_filename, size_t a_max_recs, bool a_read_only, int a_mode,
+         void const* a_map_address, int a_map_options)
     {
         auto sz = total_size(a_max_recs);
 
@@ -439,7 +438,6 @@ namespace utxx {
     bool persist_array<T,NLocks,Lock,Ext>::
     init(bip::fixed_managed_shared_memory& a_segment,
          const char* a_name, persist_attach_type a_flag, size_t a_max_recs)
-        throw(utxx::runtime_error)
     {
         std::pair<char*, size_t> fres = a_segment.find<char>(a_name);
 

include/utxx/pcap.hpp

@@ -269,7 +269,8 @@ class timestamp {
 //---------------------------------------------------------------------------
 /// Streaming support for time_val
 //---------------------------------------------------------------------------
-inline std::ostream& operator<< (std::ostream& out, time_val a) {
+template <typename Stream>
+inline Stream& operator<< (Stream& out, time_val a) {
     return out << timestamp::to_string(a, DATE_TIME_WITH_USEC, false);
 }