X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Socket%2FProtocols%2FINet%2FINet4Address.hh;h=a77903d96142e7139dde3062d073b47b0850ec2b;hb=6f50bf49e282c0528f51faa0a245bbfa2b867399;hp=b638448a6e87228debfc28dc20c413066d873dfc;hpb=f47178d89402cc90b67143ceb6c0fd5b3fa2a976;p=senf.git

diff --git a/Socket/Protocols/INet/INet4Address.hh b/Socket/Protocols/INet/INet4Address.hh
index b638448..a77903d 100644
--- a/Socket/Protocols/INet/INet4Address.hh
+++ b/Socket/Protocols/INet/INet4Address.hh
@@ -1,8 +1,8 @@
 // $Id$
 //
 // Copyright (C) 2007 
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
+// 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
@@ -30,17 +30,17 @@
 #include <iostream>
 #include <string>
 #include <boost/cstdint.hpp>
-#include <boost/function.hpp>
 #include <boost/array.hpp>
 #include <boost/operators.hpp>
-#include "Utils/SafeBool.hh"
+#include "../../../Utils/safe_bool.hh"
+#include "../../../Utils/Tags.hh"
 
 //#include "INet4Address.mpp"
 ///////////////////////////////hh.p////////////////////////////////////////
 
 namespace senf {
     
-    /** \brief IpV4 Internet address
+    /** \brief IPv4 Internet address
         
         INet4Address represents a simple IP address. It is modelled as a fixed-size
         container/sequence of 4 bytes.
@@ -53,12 +53,11 @@ namespace senf {
             therefore not be distinguished from initialization with a string literal. Therefore we
             need to disambiguate using the named constructors.
 
-        \todo Add additional classes for CIDR addresses and networks and network math.
         \ingroup addr_group
       */
     class INet4Address
         : public boost::array<boost::uint8_t,4>, 
-          public ComparableSafeBool<INet4Address>
+          public comparable_safe_bool<INet4Address>
     {
     public:
         ///////////////////////////////////////////////////////////////////////////
@@ -66,21 +65,17 @@ namespace senf {
         
         typedef uint32_t address_type;  ///< Address representation as number in host byte order
         typedef uint32_t inaddr_type;   ///< Legacy address representation in network byte order
-        typedef boost::function<void (INet4Address const &)> Callback;
-                                        ///< Callback for asynchronous from_string call
 
         static INet4Address const None; ///< The empty (0) address
         static INet4Address const Loopback; ///< The loopback (127.0.0.1) address
         static INet4Address const Broadcast; ////< The global broadcast (255.255.255.255) address
 
-        enum NoInit_t { noinit };
-
         ///////////////////////////////////////////////////////////////////////////
         ///\name Structors and default members
         ///@{
 
         INet4Address();                 ///< Construct an empty address
-        explicit INet4Address(NoInit_t); ///< Construct uninitialized (!) address
+        explicit INet4Address(senf::NoInit_t); ///< Construct uninitialized (!) address
         explicit INet4Address(address_type value);
                                         ///< Construct an address constant
 
@@ -96,20 +91,6 @@ namespace senf {
                                                  converted for some reason
                                              \param[in] s Address literal or hostname */
         
-        static void from_string(std::string const & s, Callback const & cb);
-                                        ///< Convert string to address (async/non-blocking)
-                                        /**< This member works like
-                                             from_string(std::string const &). However unlike
-                                             from_string(std::string const &), this call will not
-                                             block. Instead it will call \a cb passing the
-                                             INet4Address instance as soon as the address has been
-                                             resolved (which may be immediate if the address
-                                             represents an IP literal). \par
-                                             On error, the address passed to \a cb will be empty.
-                                             \param[in] s Address literal or hostname
-                                             \param[in] cb Callback to pass the address to 
-                                             \fixme Implement */
-
         template <class InputIterator> 
         static INet4Address from_data(InputIterator i);
                                         ///< Construct address from 4 bytes of raw data
@@ -150,9 +131,19 @@ namespace senf {
 
         ////@}
 
-        struct SyntaxException : public std::exception
-        { virtual char const * what() const throw() { return "invalid INet4 address syntax"; } };
+        /** \brief Base-class for INet4Address exceptions */
+        struct AddressException : public std::exception {};
 
+        /** \brief Invalid INet4 address syntax */
+        struct SyntaxException : public AddressException
+        { virtual char const * what() const throw() 
+                { return "invalid INet4 address syntax"; } };
+
+        /** \brief Resolver failure */
+        struct UnknownHostnameException : public AddressException
+        { virtual char const * what() const throw() 
+                { return "failed to resolve INet4 hostname"; } };
+        
     private:
         enum InAddr_t { IsInAddr };
         INet4Address(inaddr_type addr, InAddr_t);
@@ -195,13 +186,13 @@ namespace senf {
         static bool match(INet4Address const & addr);
     };
 
-    /** \brief IpV4 network prefix
+    /** \brief IPv4 network prefix
 
-        This class represents an IpV4 network prefix in CIDR notation. 
+        This class represents an IPv4 network prefix in CIDR notation. 
       */
     class INet4Network
         : public boost::equality_comparable<INet4Network>, 
-          public ComparableSafeBool<INet4Network>
+          public comparable_safe_bool<INet4Network>
     {
     public:
         ///////////////////////////////////////////////////////////////////////////