generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-10-23 00:07:59 +02:00
Code Issues Projects Releases Wiki Activity

GH #127: Eliminate -Wshadow warnings

Browse Source 
- fixed GH #127: Eliminate -Wshadow warnings
- SocketAddress small object optimization
This commit is contained in:
aleks-f
2013-03-17 01:28:01 -05:00
parent 42ff341cb9
commit 2392f34974
27 changed files with 538 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Net/src/IPAddress.cpp
View File

@@ -221,7 +221,7 @@ IPAddress::IPAddress(const struct sockaddr& sockaddr)
IPAddress::~IPAddress()
{
pImpl()->~IPAddressImpl();
destruct();
}
@@ -229,6 +229,7 @@ IPAddress& IPAddress::operator = (const IPAddress& addr)
{
if (&addr != this)
{
destruct();
if (addr.family() == IPAddress::IPv4)
new (_memory) IPv4AddressImpl(addr.addr());
else

240
Net/src/SocketAddress.cpp
View File

@@ -50,6 +50,9 @@ using Poco::NumberParser;
using Poco::NumberFormatter;
using Poco::UInt16;
using Poco::InvalidArgumentException;
using Poco::Net::Impl::SocketAddressImpl;
using Poco::Net::Impl::IPv4SocketAddressImpl;
using Poco::Net::Impl::IPv6SocketAddressImpl;
namespace Poco {
@@ -65,151 +68,6 @@ struct AFLT
};
//
// SocketAddressImpl
//
class SocketAddressImpl: public RefCountedObject
{
public:
virtual IPAddress host() const = 0;
virtual UInt16 port() const = 0;
virtual poco_socklen_t length() const = 0;
virtual const struct sockaddr* addr() const = 0;
virtual int af() const = 0;
protected:
SocketAddressImpl()
{
}
virtual ~SocketAddressImpl()
{
}
private:
SocketAddressImpl(const SocketAddressImpl&);
SocketAddressImpl& operator = (const SocketAddressImpl&);
};
class IPv4SocketAddressImpl: public SocketAddressImpl
{
public:
IPv4SocketAddressImpl()
{
std::memset(&_addr, 0, sizeof(_addr));
_addr.sin_family = AF_INET;
poco_set_sin_len(&_addr);
}
IPv4SocketAddressImpl(const struct sockaddr_in* addr)
{
std::memcpy(&_addr, addr, sizeof(_addr));
}
IPv4SocketAddressImpl(const void* addr, UInt16 port)
{
std::memset(&_addr, 0, sizeof(_addr));
_addr.sin_family = AF_INET;
std::memcpy(&_addr.sin_addr, addr, sizeof(_addr.sin_addr));
_addr.sin_port = port;
}
IPAddress host() const
{
return IPAddress(&_addr.sin_addr, sizeof(_addr.sin_addr));
}
UInt16 port() const
{
return _addr.sin_port;
}
poco_socklen_t length() const
{
return sizeof(_addr);
}
const struct sockaddr* addr() const
{
return reinterpret_cast<const struct sockaddr*>(&_addr);
}
int af() const
{
return _addr.sin_family;
}
private:
struct sockaddr_in _addr;
};
#if defined(POCO_HAVE_IPv6)
class IPv6SocketAddressImpl: public SocketAddressImpl
{
public:
IPv6SocketAddressImpl(const struct sockaddr_in6* addr)
{
std::memcpy(&_addr, addr, sizeof(_addr));
}
IPv6SocketAddressImpl(const void* addr, UInt16 port)
{
std::memset(&_addr, 0, sizeof(_addr));
_addr.sin6_family = AF_INET6;
poco_set_sin6_len(&_addr);
std::memcpy(&_addr.sin6_addr, addr, sizeof(_addr.sin6_addr));
_addr.sin6_port = port;
}
IPv6SocketAddressImpl(const void* addr, UInt16 port, UInt32 scope)
{
std::memset(&_addr, 0, sizeof(_addr));
_addr.sin6_family = AF_INET6;
poco_set_sin6_len(&_addr);
std::memcpy(&_addr.sin6_addr, addr, sizeof(_addr.sin6_addr));
_addr.sin6_port = port;
_addr.sin6_scope_id = scope;
}
IPAddress host() const
{
return IPAddress(&_addr.sin6_addr, sizeof(_addr.sin6_addr), _addr.sin6_scope_id);
}
UInt16 port() const
{
return _addr.sin6_port;
}
poco_socklen_t length() const
{
return sizeof(_addr);
}
const struct sockaddr* addr() const
{
return reinterpret_cast<const struct sockaddr*>(&_addr);
}
int af() const
{
return _addr.sin6_family;
}
private:
struct sockaddr_in6 _addr;
};
#endif // POCO_HAVE_IPv6
//
// SocketAddress
//
@@ -217,31 +75,31 @@ private:
SocketAddress::SocketAddress()
{
_pImpl = new IPv4SocketAddressImpl;
new (_memory) IPv4SocketAddressImpl;
}
SocketAddress::SocketAddress(const IPAddress& addr, Poco::UInt16 port)
SocketAddress::SocketAddress(const IPAddress& hostAddress, Poco::UInt16 portNumber)
{
init(addr, port);
init(hostAddress, portNumber);
}
SocketAddress::SocketAddress(Poco::UInt16 port)
SocketAddress::SocketAddress(Poco::UInt16 portNumber)
{
init(IPAddress(), port);
init(IPAddress(), portNumber);
}
SocketAddress::SocketAddress(const std::string& addr, Poco::UInt16 port)
SocketAddress::SocketAddress(const std::string& hostAddress, Poco::UInt16 portNumber)
{
init(addr, port);
init(hostAddress, portNumber);
}
SocketAddress::SocketAddress(const std::string& addr, const std::string& port)
SocketAddress::SocketAddress(const std::string& hostAddress, const std::string& portNumber)
{
init(addr, resolveService(port));
init(hostAddress, resolveService(portNumber));
}
@@ -274,20 +132,22 @@ SocketAddress::SocketAddress(const std::string& hostAndPort)
}
SocketAddress::SocketAddress(const SocketAddress& addr)
SocketAddress::SocketAddress(const SocketAddress& socketAddress)
{
_pImpl = addr._pImpl;
_pImpl->duplicate();
if (socketAddress.family() == IPAddress::IPv4)
new (_memory) IPv4SocketAddressImpl(reinterpret_cast<const sockaddr_in*>(socketAddress.addr()));
else
new (_memory) IPv6SocketAddressImpl(reinterpret_cast<const sockaddr_in6*>(socketAddress.addr()));
}
SocketAddress::SocketAddress(const struct sockaddr* addr, poco_socklen_t length)
SocketAddress::SocketAddress(const struct sockaddr* sockAddr, poco_socklen_t length)
{
if (length == sizeof(struct sockaddr_in))
_pImpl = new IPv4SocketAddressImpl(reinterpret_cast<const struct sockaddr_in*>(addr));
new (_memory) IPv4SocketAddressImpl(reinterpret_cast<const struct sockaddr_in*>(sockAddr));
#if defined(POCO_HAVE_IPv6)
else if (length == sizeof(struct sockaddr_in6))
_pImpl = new IPv6SocketAddressImpl(reinterpret_cast<const struct sockaddr_in6*>(addr));
new (_memory) IPv6SocketAddressImpl(reinterpret_cast<const struct sockaddr_in6*>(sockAddr));
#endif
else throw Poco::InvalidArgumentException("Invalid address length passed to SocketAddress()");
}
@@ -295,63 +155,59 @@ SocketAddress::SocketAddress(const struct sockaddr* addr, poco_socklen_t length)
SocketAddress::~SocketAddress()
{
_pImpl->release();
destruct();
}
bool SocketAddress::operator < (const SocketAddress& addr) const
bool SocketAddress::operator < (const SocketAddress& socketAddress) const
{
if (family() < addr.family()) return true;
if (host() < addr.host()) return true;
return (port() < addr.port());
if (family() < socketAddress.family()) return true;
if (host() < socketAddress.host()) return true;
return (port() < socketAddress.port());
}
SocketAddress& SocketAddress::operator = (const SocketAddress& addr)
SocketAddress& SocketAddress::operator = (const SocketAddress& socketAddress)
{
if (&addr != this)
if (&socketAddress != this)
{
_pImpl->release();
_pImpl = addr._pImpl;
_pImpl->duplicate();
destruct();
if (socketAddress.family() == IPAddress::IPv4)
new (_memory) IPv4SocketAddressImpl(reinterpret_cast<const sockaddr_in*>(socketAddress.addr()));
else
new (_memory) IPv6SocketAddressImpl(reinterpret_cast<const sockaddr_in6*>(socketAddress.addr()));
}
return *this;
}
void SocketAddress::swap(SocketAddress& addr)
{
std::swap(_pImpl, addr._pImpl);
}
IPAddress SocketAddress::host() const
{
return _pImpl->host();
return pImpl()->host();
}
Poco::UInt16 SocketAddress::port() const
{
return ntohs(_pImpl->port());
return ntohs(pImpl()->port());
}
poco_socklen_t SocketAddress::length() const
{
return _pImpl->length();
return pImpl()->length();
}
const struct sockaddr* SocketAddress::addr() const
{
return _pImpl->addr();
return pImpl()->addr();
}
int SocketAddress::af() const
{
return _pImpl->af();
return pImpl()->af();
}
@@ -371,28 +227,28 @@ std::string SocketAddress::toString() const
}
void SocketAddress::init(const IPAddress& host, Poco::UInt16 port)
void SocketAddress::init(const IPAddress& hostAddress, Poco::UInt16 portNumber)
{
if (host.family() == IPAddress::IPv4)
_pImpl = new IPv4SocketAddressImpl(host.addr(), htons(port));
if (hostAddress.family() == IPAddress::IPv4)
new (_memory) IPv4SocketAddressImpl(hostAddress.addr(), htons(portNumber));
#if defined(POCO_HAVE_IPv6)
else if (host.family() == IPAddress::IPv6)
_pImpl = new IPv6SocketAddressImpl(host.addr(), htons(port), host.scope());
else if (hostAddress.family() == IPAddress::IPv6)
new (_memory) IPv6SocketAddressImpl(hostAddress.addr(), htons(portNumber), hostAddress.scope());
#endif
else throw Poco::NotImplementedException("unsupported IP address family");
}
void SocketAddress::init(const std::string& host, Poco::UInt16 port)
void SocketAddress::init(const std::string& hostAddress, Poco::UInt16 portNumber)
{
IPAddress ip;
if (IPAddress::tryParse(host, ip))
if (IPAddress::tryParse(hostAddress, ip))
{
init(ip, port);
init(ip, portNumber);
}
else
{
HostEntry he = DNS::hostByName(host);
HostEntry he = DNS::hostByName(hostAddress);
HostEntry::AddressList addresses = he.addresses();
if (addresses.size() > 0)
{
@@ -400,9 +256,9 @@ void SocketAddress::init(const std::string& host, Poco::UInt16 port)
// if we get both IPv4 and IPv6 addresses, prefer IPv4
std::sort(addresses.begin(), addresses.end(), AFLT());
#endif
init(addresses[0], port);
init(addresses[0], portNumber);
}
else throw HostNotFoundException("No address found for host", host);
else throw HostNotFoundException("No address found for host", hostAddress);
}
}

142
Net/src/SocketAddressImpl.cpp Normal file
View File

@@ -0,0 +1,142 @@
//
// SocketAddressImpl.cpp
//
// $Id: //poco/1.4/Net/src/SocketAddressImpl.cpp#5 $
//
// Library: Net
// Package: NetCore
// Module: SocketAddressImpl
//
// Copyright (c) 2005-2011, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// Permission is hereby granted, free of charge, to any person or organization
// obtaining a copy of the software and accompanying documentation covered by
// this license (the "Software") to use, reproduce, display, distribute,
// execute, and transmit the Software, and to prepare derivative works of the
// Software, and to permit third-parties to whom the Software is furnished to
// do so, all subject to the following:
//
// The copyright notices in the Software and this entire statement, including
// the above license grant, this restriction and the following disclaimer,
// must be included in all copies of the Software, in whole or in part, and
// all derivative works of the Software, unless such copies or derivative
// works are solely in the form of machine-executable object code generated by
// a source language processor.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
#include "Poco/Net/SocketAddressImpl.h"
#include "Poco/Net/SocketDefs.h"
/*
#include "Poco/Net/IPAddress.h"
#include "Poco/Net/NetException.h"
#include "Poco/Net/DNS.h"
#include "Poco/RefCountedObject.h"
#include "Poco/NumberParser.h"
#include "Poco/NumberFormatter.h"
#include <algorithm>
#include <cstring>
using Poco::RefCountedObject;
using Poco::NumberParser;
using Poco::NumberFormatter;
using Poco::UInt16;
using Poco::InvalidArgumentException;
*/
namespace Poco {
namespace Net {
namespace Impl {
//
// SocketAddressImpl
//
SocketAddressImpl::SocketAddressImpl()
{
}
SocketAddressImpl::~SocketAddressImpl()
{
}
//
// IPv4SocketAddressImpl
//
IPv4SocketAddressImpl::IPv4SocketAddressImpl()
{
std::memset(&_addr, 0, sizeof(_addr));
_addr.sin_family = AF_INET;
poco_set_sin_len(&_addr);
}
IPv4SocketAddressImpl::IPv4SocketAddressImpl(const struct sockaddr_in* addr)
{
std::memcpy(&_addr, addr, sizeof(_addr));
}
IPv4SocketAddressImpl::IPv4SocketAddressImpl(const void* addr, UInt16 port)
{
std::memset(&_addr, 0, sizeof(_addr));
_addr.sin_family = AF_INET;
std::memcpy(&_addr.sin_addr, addr, sizeof(_addr.sin_addr));
_addr.sin_port = port;
}
#if defined(POCO_HAVE_IPv6)
//
// IPv6SocketAddressImpl
//
IPv6SocketAddressImpl::IPv6SocketAddressImpl(const struct sockaddr_in6* addr)
{
std::memcpy(&_addr, addr, sizeof(_addr));
}
IPv6SocketAddressImpl::IPv6SocketAddressImpl(const void* addr, UInt16 port)
{
std::memset(&_addr, 0, sizeof(_addr));
_addr.sin6_family = AF_INET6;
poco_set_sin6_len(&_addr);
std::memcpy(&_addr.sin6_addr, addr, sizeof(_addr.sin6_addr));
_addr.sin6_port = port;
}
IPv6SocketAddressImpl::IPv6SocketAddressImpl(const void* addr, UInt16 port, UInt32 scope)
{
std::memset(&_addr, 0, sizeof(_addr));
_addr.sin6_family = AF_INET6;
poco_set_sin6_len(&_addr);
std::memcpy(&_addr.sin6_addr, addr, sizeof(_addr.sin6_addr));
_addr.sin6_port = port;
_addr.sin6_scope_id = scope;
}
#endif // POCO_HAVE_IPv6
} } } // namespace Poco::Net::Impl