luo980/uvw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactoring

Browse Source
This commit is contained in:
Michele Caini 2016-07-22 09:35:50 +02:00
parent 7d486b3755
commit 10f0f1336b
6 changed files with 71 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
README.md
View File

@ -26,7 +26,7 @@ void listen(uvw::Loop &loop) {
client->read();
});
tcp->bind<uvw::Tcp::IPv4>("127.0.0.1", 4242);
tcp->bind("127.0.0.1", 4242);
tcp->listen();
}
@ -41,7 +41,7 @@ void conn(uvw::Loop &loop) {
tcp.close();
});
tcp->connect<uvw::Tcp::IPv4>(std::string{"127.0.0.1"}, 4242);
tcp->connect(std::string{"127.0.0.1"}, 4242);
}
int main() {
@ -147,7 +147,7 @@ To know what are the available resources' types, please refer the API reference.
##### The event-based approach
For `uvw` offers an event-based approach, resources are small event emitters to which listeners can be attached.
Attaching a listener to a resource is the reccomended way to be notified about changes.
Attaching a listener to a resource is the recommended way to be notified about changes.
Listeners must be callable objects of type `void(const EventType &, ResourceType &)`, where:
* `EventType` is the type of the event for which they have been designed
@ -180,11 +180,14 @@ tcp->on<uvw::ListenEvent>([](const uvw::ListenEvent &event, uvw::Tcp &srv) mutab
client->read();
});
tcp->bind<uvw::Tcp::IPv4>("127.0.0.1", 4242);
tcp->bind("127.0.0.1", 4242);
tcp->listen();
```
The API reference is the reccomended documentation for further details about resources and their methods.
Note that `uvw::Tcp` already supports _IPv6_ out-of-the-box. The statement above is equivalent to `tcp->bind<uvw::Tcp::IPv4>("127.0.0.1", 4242)`.
It's suffice to explicitly specify `uvw::Tcp::IPv6` as the underlying protocol to use it.
The API reference is the recommended documentation for further details about resources and their methods.
## Tests

5
src/uvw/stream.hpp
View File

@ -126,7 +126,10 @@ public:
listen(DEFAULT_BACKLOG);
}
virtual void accept(T &) = 0;
template<typename U>
void accept(U &ref) {
this->invoke(&uv_accept, this->template get<uv_stream_t>(), ref.template get<uv_stream_t>());
}
void read() {
this->invoke(&uv_read_start, this->template get<uv_stream_t>(), &this->allocCallback, &readCallback);

63
src/uvw/tcp.hpp
View File

@ -17,23 +17,8 @@ namespace uvw {
class Tcp final: public Stream<Tcp> {
using SockFunctionType = Addr(*)(const Tcp &);
using PeerFunctionType = SockFunctionType;
template<typename I>
static Addr tSock(const Tcp &tcp) noexcept {
return details::address<I>(uv_tcp_getsockname, tcp.get<uv_tcp_t>());
}
template<typename I>
static Addr tPeer(const Tcp &tcp) noexcept {
return details::address<I>(uv_tcp_getpeername, tcp.get<uv_tcp_t>());
}
explicit Tcp(std::shared_ptr<Loop> ref)
: Stream{HandleType<uv_tcp_t>{}, std::move(ref)},
sockF{&tSock<details::IPv4>},
peerF{&tPeer<details::IPv4>}
: Stream{HandleType<uv_tcp_t>{}, std::move(ref)}
{ }
public:
@ -61,33 +46,34 @@ public:
invoke(&uv_tcp_keepalive, get<uv_tcp_t>(), enable, time.count());
}
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
void bind(std::string ip, unsigned int port, Flags<Bind> flags = Flags<Bind>{}) {
typename Traits::Type addr;
Traits::AddrFunc(ip.data(), port, &addr);
if(0 == invoke(&uv_tcp_bind, get<uv_tcp_t>(), reinterpret_cast<const sockaddr *>(&addr), flags)) {
sockF = &tSock<I>;
peerF = &tPeer<I>;
}
typename details::IpTraits<I>::Type addr;
details::IpTraits<I>::AddrFunc(ip.data(), port, &addr);
invoke(&uv_tcp_bind, get<uv_tcp_t>(), reinterpret_cast<const sockaddr *>(&addr), flags);
}
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
void bind(Addr addr, Flags<Bind> flags = Flags<Bind>{}) {
bind<I>(addr.ip, addr.port, flags);
}
Addr sock() const noexcept { return sockF(*this); }
Addr peer() const noexcept { return peerF(*this); }
template<typename I = IPv4>
Addr sock() const noexcept {
return details::address<I>(&uv_tcp_getsockname, get<uv_tcp_t>());
}
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
Addr peer() const noexcept {
return details::address<I>(&uv_tcp_getpeername, get<uv_tcp_t>());
}
template<typename I = IPv4>
void connect(std::string ip, unsigned int port) {
typename Traits::Type addr;
Traits::AddrFunc(ip.data(), port, &addr);
typename details::IpTraits<I>::Type addr;
details::IpTraits<I>::AddrFunc(ip.data(), port, &addr);
auto listener = [ptr = this->shared_from_this()](const auto &event, details::Connect &) {
ptr->sockF = &tSock<I>;
ptr->peerF = &tPeer<I>;
ptr->publish(event);
};
@ -97,19 +83,8 @@ public:
connect->connect(&uv_tcp_connect, get<uv_tcp_t>(), reinterpret_cast<const sockaddr *>(&addr));
}
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
void connect(Addr addr) { connect<I>(addr.ip, addr.port); }
void accept(Tcp &tcp) override {
if(0 == invoke(&uv_accept, get<uv_stream_t>(), tcp.get<uv_stream_t>())) {
tcp.sockF = sockF;
tcp.peerF = peerF;
}
}
private:
SockFunctionType sockF;
PeerFunctionType peerF;
};

94
src/uvw/udp.hpp
View File

@ -39,40 +39,27 @@ public:
class Udp final: public Handle<Udp> {
using SockFunctionType = Addr(*)(const Udp &);
using PeerFunctionType = Addr(*)(const sockaddr *);
template<typename I>
static Addr tSock(const Udp &udp) noexcept {
return details::address<I>(uv_udp_getsockname, udp.get<uv_udp_t>());
}
template<typename I, typename..., typename Traits = details::IpTraits<I>>
static Addr tPeer(const sockaddr *addr) noexcept {
const typename Traits::Type *aptr = reinterpret_cast<const typename Traits::Type *>(addr);
int len = sizeof(*addr);
return details::address<I>(aptr, len);
}
explicit Udp(std::shared_ptr<Loop> ref)
: Handle{HandleType<uv_udp_t>{}, std::move(ref)},
sockF{&tSock<details::IPv4>},
peerF{&tPeer<details::IPv4>}
: Handle{HandleType<uv_udp_t>{}, std::move(ref)}
{ }
template<typename I>
static void recvCallback(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf, const sockaddr *addr, unsigned flags) {
typename details::IpTraits<I>::Type *aptr = reinterpret_cast<const typename details::IpTraits<I>::Type *>(addr);
int len = sizeof(*addr);
Udp &udp = *(static_cast<Udp*>(handle->data));
// data will be destroyed no matter of what the value of nread is
std::unique_ptr<const char[]> data{buf->base};
if(nread > 0) {
// data available (can be truncated)
udp.publish(UDPDataEvent{udp.peerF(addr), std::move(data), nread, flags & UV_UDP_PARTIAL});
udp.publish(UDPDataEvent{details::address<I>(aptr, len), std::move(data), nread, flags & UV_UDP_PARTIAL});
} else if(nread == 0 && addr == nullptr) {
// no more data to be read, doing nothing is fine
} else if(nread == 0 && addr != nullptr) {
// empty udp packet
udp.publish(UDPDataEvent{udp.peerF(addr), std::move(data), nread, false});
udp.publish(UDPDataEvent{details::address<I>(aptr, len), std::move(data), nread, false});
} else {
// transmission error
udp.publish(ErrorEvent(nread));
@ -100,30 +87,26 @@ public:
bool init() { return initialize<uv_udp_t>(&uv_udp_init); }
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
void bind(std::string ip, unsigned int port, Flags<Bind> flags = Flags<Bind>{}) {
typename Traits::Type addr;
Traits::AddrFunc(ip.data(), port, &addr);
if(0 == invoke(&uv_udp_bind, get<uv_udp_t>(), reinterpret_cast<const sockaddr *>(&addr), flags)) {
sockF = &tSock<I>;
peerF = &tPeer<I>;
}
typename details::IpTraits<I>::Type addr;
details::IpTraits<I>::AddrFunc(ip.data(), port, &addr);
invoke(&uv_udp_bind, get<uv_udp_t>(), reinterpret_cast<const sockaddr *>(&addr), flags);
}
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
void bind(Addr addr, Flags<Bind> flags = Flags<Bind>{}) {
bind<I>(addr.ip, addr.port, flags);
}
Addr sock() const noexcept { return sockF(*this); }
template<typename I = IPv4>
Addr sock() const noexcept {
return details::address<I>(&uv_udp_getsockname, get<uv_udp_t>());
}
template<typename I>
template<typename I = IPv4>
void multicastMembership(std::string multicast, std::string interface, Membership membership) {
if(0 == invoke(&uv_udp_set_membership, get<uv_udp_t>(), multicast.data(), interface.data(), static_cast<uv_membership>(membership))) {
sockF = &tSock<I>;
peerF = &tPeer<I>;
}
invoke(&uv_udp_set_membership, get<uv_udp_t>(), multicast.data(), interface.data(), static_cast<uv_membership>(membership));
}
void multicastLoop(bool enable = true) {
@ -134,27 +117,22 @@ public:
invoke(&uv_udp_set_multicast_ttl, get<uv_udp_t>(), val > 255 ? 255 : val);
}
template<typename I>
template<typename I = IPv4>
void multicastInterface(std::string interface) {
if(0 == invoke(&uv_udp_set_multicast_interface, get<uv_udp_t>(), interface.data())) {
sockF = &tSock<I>;
peerF = &tPeer<I>;
}
invoke(&uv_udp_set_multicast_interface, get<uv_udp_t>(), interface.data());
}
void broadcast(bool enable = false) { invoke(&uv_udp_set_broadcast, get<uv_udp_t>(), enable); }
void ttl(int val) { invoke(&uv_udp_set_ttl, get<uv_udp_t>(), val > 255 ? 255 : val); }
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
void send(std::string ip, unsigned int port, char *data, ssize_t len) {
typename Traits::Type addr;
Traits::AddrFunc(ip.data(), port, &addr);
typename details::IpTraits<I>::Type addr;
details::IpTraits<I>::AddrFunc(ip.data(), port, &addr);
uv_buf_t bufs[] = { uv_buf_init(data, len) };
auto listener = [ptr = this->shared_from_this()](const auto &event, details::Send &) {
ptr->sockF = &tSock<I>;
ptr->peerF = &tPeer<I>;
ptr->publish(event);
};
@ -162,20 +140,17 @@ public:
send->once<ErrorEvent>(listener);
send->once<SendEvent>(listener);
send->send(get<uv_udp_t>(), bufs, 1, reinterpret_cast<const sockaddr *>(&addr));
sockF = &tSock<I>;
peerF = &tPeer<I>;
}
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
void send(std::string ip, unsigned int port, std::unique_ptr<char[]> data, ssize_t len) {
send<I>(ip, port, data.get(), len);
}
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
int trySend(std::string ip, unsigned int port, char *data, ssize_t len) {
typename Traits::Type addr;
Traits::AddrFunc(ip.data(), port, &addr);
typename details::IpTraits<I>::Type addr;
details::IpTraits<I>::AddrFunc(ip.data(), port, &addr);
uv_buf_t bufs[] = { uv_buf_init(data, len) };
auto bw = uv_udp_try_send(get<uv_udp_t>(), bufs, 1, reinterpret_cast<const sockaddr *>(&addr));
@ -183,25 +158,22 @@ public:
if(bw < 0) {
this->publish(ErrorEvent{bw});
bw = 0;
} else {
sockF = &tSock<I>;
peerF = &tPeer<I>;
}
return bw;
}
template<typename I, typename..., typename Traits = details::IpTraits<I>>
template<typename I = IPv4>
int trySend(std::string ip, unsigned int port, std::unique_ptr<char[]> data, ssize_t len) {
return trySend<I>(ip, port, data.get(), len);
}
void recv() { invoke(&uv_udp_recv_start, get<uv_udp_t>(), &allocCallback, &recvCallback); }
void stop() { invoke(&uv_udp_recv_stop, get<uv_udp_t>()); }
template<typename I = IPv4>
void recv() {
invoke(&uv_udp_recv_start, get<uv_udp_t>(), &allocCallback, &recvCallback<I>);
}
private:
SockFunctionType sockF;
PeerFunctionType peerF;
void stop() { invoke(&uv_udp_recv_stop, get<uv_udp_t>()); }
};

10
src/uvw/util.hpp
View File

@ -107,12 +107,12 @@ const IpTraits<IPv4>::NameFuncType IpTraits<IPv4>::NameFunc = &uv_ip4_name;
const IpTraits<IPv6>::NameFuncType IpTraits<IPv6>::NameFunc = &uv_ip6_name;
template<typename I, typename..., typename Traits = details::IpTraits<I>>
Addr address(const typename Traits::Type *aptr, int len) noexcept {
template<typename I>
Addr address(const typename details::IpTraits<I>::Type *aptr, int len) noexcept {
std::pair<std::string, unsigned int> addr{};
char name[len];
int err = Traits::NameFunc(aptr, name, len);
int err = details::IpTraits<I>::NameFunc(aptr, name, len);
if(0 == err) {
addr = { std::string{name}, ntohs(aptr->sin_port) };
@ -126,7 +126,7 @@ Addr address(const typename Traits::Type *aptr, int len) noexcept {
}
template<typename I, typename F, typename H, typename..., typename Traits = details::IpTraits<I>>
template<typename I, typename F, typename H>
Addr address(F &&f, const H *handle) noexcept {
sockaddr_storage ssto;
int len = sizeof(ssto);
@ -135,7 +135,7 @@ Addr address(F &&f, const H *handle) noexcept {
int err = std::forward<F>(f)(handle, reinterpret_cast<sockaddr *>(&ssto), &len);
if(0 == err) {
typename Traits::Type *aptr = reinterpret_cast<typename Traits::Type *>(&ssto);
typename details::IpTraits<I>::Type *aptr = reinterpret_cast<typename details::IpTraits<I>::Type *>(&ssto);
addr = address<I>(aptr, len);
}

4
test/main.cpp
View File

@ -56,7 +56,7 @@ void listen(uvw::Loop &loop) {
std::cout << "close" << std::endl;
});
tcp->bind<uvw::Tcp::IPv4>("127.0.0.1", 4242);
tcp->bind("127.0.0.1", 4242);
tcp->listen();
}
@ -88,7 +88,7 @@ void conn(uvw::Loop &loop) {
std::cout << "close" << std::endl;
});
tcp->connect<uvw::Tcp::IPv4>(std::string{"127.0.0.1"}, 4242);
tcp->connect(std::string{"127.0.0.1"}, 4242);
}
void g() {