Add some github workflow

Author: biaks

.github/workflows/cmake.yml

@@ -0,0 +1,30 @@
+name: CMake
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  build:
+    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
+    # You can convert this to a matrix build if you need cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -DIP_SOCKETS_CPP_LITE_BUILD_EXAMPLES=ON -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}

readme.md

@@ -1,8 +1,10 @@
 # ip-sockets-cpp-lite 🔌
 
+[![Build examples](https://github.com/biaks/ip-sockets-cpp-lite/actions/workflows/cmake.yml/badge.svg)](https://github.com/biaks/ip-sockets-cpp-lite/actions/workflows/cmake.yml)
+
 **Simplicity. Lightweight. Cross-platform.**
 
-ip-sockets-cpp-lite is a fast, header-only, dependency-free, cross-platform C++ library that makes programming UDP/TCP sockets and working with IPv4/IPv6 addresses as easy as possible.
+It's a fast, header-only, dependency-free, cross-platform C++ library that makes programming UDP/TCP sockets and working with IPv4/IPv6 addresses as easy as possible.
 Forget about endless `getaddrinfo` calls, confusion with `sockaddr_in`/`sockaddr_in6`, and platform-specific workarounds.
 
 ```cpp
@@ -22,6 +24,74 @@ sock.send("Hello!", 6);
 - **🔒 Predictable** - full control over everything
 - **📋 Human-readable errors** - clear error codes instead of cryptic errno values
 
+## Smart IP Address Handling 🌐
+
+Working with IP addresses has never been easier:
+
+### Create from anything
+```cpp
+// IPv4 addresses - all the common formats
+ip4_t ip0 = "192.168.1.1";       // from string
+ip4_t ip1 = 0xc0a80101;          // from uint32
+ip4_t ip2 = {192, 168, 1, 1};    // from bytes
+ip4_t ip3 = "0xc0a80101";        // from hex string
+ip4_t ip4 = "3232235777";        // from decimal string
+ip4_t ip5 = "127.1";             // 127.0.0.1 (missing bytes are zero)
+// IPv6 addresses - all the common formats
+ip6_t ip6 = "fe80::";            // link-local address
+ip6_t ip7 = "::1";               // loopback
+ip6_t ip8 = "64:ff9b::10.0.0.7"; // IPv4-translated (NAT64)
+ip6_t ip9 = "11.0.0.1";          // auto IPv4-mapped to ::ffff:11.0.0.1
+// Parsing of all variants of input strings always occurs in one pass
+```
+
+### Zero-copy overlay on existing memory
+```cpp
+uint8_t packet[14] = {0x45, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x01, 0xa8, ...};
+// Treat memory region as ip4_t without copying!
+ip4_t& src_ip = *reinterpret_cast<ip4_t*>(&packet[3]);
+std::cout << src_ip;                    // prints "127.0.0.1"
+```
+
+### Network operations made simple
+```cpp
+ip4_t ip = "192.168.1.100";
+ip4_t mask(24);                         // 255.255.255.0 from prefix
+ip4_t network = ip & mask;              // 192.168.1.0
+
+ip6_t ipv6 = "2001:db8::1";
+ip6_t ipv6_from_v4 = ip4_t("10.0.0.1"); // ::ffff:10.0.0.1 (IPv4-mapped)
+```
+
+### Address + port as one type
+```cpp
+addr4_t server  = "192.168.1.100:8080";  // IP and port together
+addr6_t server6 = "[2001:db8::1]:8080";
+std::cout << server;                     // prints "192.168.1.100:8080"
+```
+
+### Two Ways to Use IP and Address Types 🔧
+```cpp
+// Direct types (when IP version is known)
+ip4_t ip4     = "192.168.1.1";      // IPv4
+ip6_t ip6     = "2001:db8::1";      // IPv6
+addr4_t addr4 = "192.168.1.1:8080"; // IPv4 + port
+addr6_t addr6 = "[::1]:8080";       // IPv6 + port
+
+// Generic types (template-friendly)
+ip_t<v4> ip4     = "192.168.1.1";      // same as ip4_t
+ip_t<v6> ip6     = "2001:db8::1";      // same as ip6_t
+addr_t<v4> addr4 = "192.168.1.1:8080"; // same as addr4_t
+addr_t<v6> addr6 = "[::1]:8080";       // same as addr6_t
+
+// Perfect for templates!
+template <ip_type_e Type>
+void print_endpoint(const addr_t<Type>& endpoint) {
+    std::cout << "Connecting to: " << endpoint << '\n';
+}
+```
+**Choose what fits your code:** use concrete types for simplicity, or generic types for maximum flexibility in templates!
+
 ## Quick Start 🏁
 
 ### 1. Installation
@@ -31,7 +101,7 @@ Simply copy three files into your project:
 - `udp_socket.h` — UDP sockets
 - `tcp_socket.h` — TCP sockets
 
-Then include one of what you need:
+Then include what you need:
 ```cpp
 #include "ip_address.h"  // work only with ipv4/ipv6 addresses
 #include "udp_socket.h"  // work with UDP ipv4/ipv6 client/server sockets
@@ -78,7 +148,7 @@ int main() {
     // Create a UDP server on port 8080
     udp_socket_t<v4, socket_type_e::server> server;
 
-    if (server.open("0.0.0.0:8080") != no_error) {
+    if (server.open("0.0.0.0:8080") == no_error) {
 
         std::cout << "Server listening on port 8080\n";
 
@@ -110,7 +180,7 @@ int main() {
     // Create a TCP server
     tcp_socket_t<v4, socket_type_e::server> server;
 
-    if (server.open("0.0.0.0:8080") != no_error) {
+    if (server.open("0.0.0.0:8080") == no_error) {
 
         std::cout << "TCP server listening on port 8080\n";
 
@@ -138,7 +208,7 @@ int main() {
 
 ## Why is this convenient? 🤔
 
-### Instead of this (raw sockets):
+Instead of this (system sockets):
 ```cpp
 struct sockaddr_in addr;
 addr.sin_family = AF_INET;
@@ -147,12 +217,58 @@ inet_pton(AF_INET, "192.168.1.100", &addr.sin_addr);
 // ... and 20 more lines to send a single packet
 ```
 
-### Write this:
+Just write this:
 ```cpp
 sock.open("192.168.1.100:8080");  // done!
 sock.send("Hello", 5);
 ```
 
+## Synchronous with Timeouts — Why? ⏱️
+
+You might wonder: "Why this library provide synchronous sockets with timeouts instead of async I/O?"
+
+Great question! Here's why this design choice makes sense:
+
+### ✅ Cross-platform simplicity
+Async I/O APIs differ dramatically between platforms (epoll on Linux, kqueue on BSD, IOCP on Windows).
+By choosing synchronous operations with timeouts, this library get a **single codebase** that works everywhere without #ifdef hell.
+
+### ✅ Easy to understand and use
+No callbacks, no event loops, no complex state machines. Your code reads linearly:
+```cpp
+sock.open(server);
+sock.send(request);
+sock.recv(response);  // blocks until data arrives or timeout
+```
+Every developer understands this flow instantly.
+
+### ✅ Threads are cheap, complexity is expensive
+Spawning a thread to wait for socket I/O is perfectly fine:
+```cpp
+std::thread([&]() {
+    while (true) {
+        int bytes = server.recvfrom(buffer, sizeof(buffer), client);
+        if (bytes > 0) handle_client(client, buffer, bytes);
+    }
+}).detach();  // One thread per socket — no problem!
+```
+Modern systems handle thousands of threads easily. **Don't optimize prematurely** — clean code is better than complex async machinery.
+
+### ✅ Perfect for 95% of use cases
+- REST API clients
+- IoT devices
+- Game servers
+- Protocol implementations
+- Embedded systems
+
+For the 5% that truly need massive concurrency (10k+ connections), you can still use this library in thread pools or combine it with higher-level async frameworks.
+
+---
+
+**Bottom line:** This library gives you predictable, blocking I/O with configurable timeouts — the simplest model that works for most real-world applications. Keep it simple, keep it portable! 🎯
+
+---
+
 ## Features 🔧
 
 ### IP Address Handling (`ip_address.h`)
@@ -161,6 +277,9 @@ sock.send("Hello", 5);
 - Network prefixes and masks
 - IPv4-over-IPv6 mapping
 - Address + port as a single unit
+- Zero-copy overlay on existing memory buffers
+- Rich constructors from strings, numbers, bytes
+- Flexible parsing of various formats (hex, decimal, dotted)
 
 ### UDP Sockets (`udp_socket.h`)
 - Client and server modes