Fix Windows Release build; improve README

Author: kzhdev

CMakeLists.txt

@@ -89,8 +89,9 @@ if(CMAKE_BUILD_TYPE STREQUAL "Release")
   if (WIN32)
     add_custom_target(dist_slick_socket ALL
       COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_BINARY_DIR}/dist/include
-      COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE}/slick_socket.lib ${CMAKE_BINARY_DIR}/dist/lib/slick_socket.lib
-      COMMENT "Copying slick_socket headers to dist/include"
+      COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/dist/lib
+      COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/Release/slick_socket.lib ${CMAKE_BINARY_DIR}/dist/lib/
+      COMMENT "Copying slick_socket headers and lib to dist"
       VERBATIM
     )
   else()

README.md

@@ -17,47 +17,142 @@ A header-only C++20 networking library providing cross-platform TCP and UDP mult
 - **UDP Multicast**: One-to-many communication support
 - **Logging**: Template-based logger interface with console output
 
-## Quick Start
+## Installation
 
-### Prerequisites
+### Using FetchContent (Recommended)
 
-- C++20 compatible compiler
-- CMake 3.20 or higher
+The easiest way to use slick_socket is to fetch it directly in your CMakeLists.txt:
 
-### Building
+```cmake
+include(FetchContent)
 
-```bash
-# Configure build
-cmake -S . -B build
+FetchContent_Declare(
+    slick_socket
+    GIT_REPOSITORY https://github.com/SlickQuant/slick_socket.git
+    GIT_TAG v1.0.0.1  # Use the desired version
+)
 
-# Build project
-cmake --build build --config Debug
+FetchContent_MakeAvailable(slick_socket)
 
-# Run tests
-cd build && ctest --output-on-failure -C Debug
+# Link against slick_socket
+target_link_libraries(your_target PRIVATE slick_socket)
+```
+
+On Windows, you also need to link against `ws2_32`:
+```cmake
+target_link_libraries(your_target PRIVATE slick_socket ws2_32)
 ```
 
-### Windows (Visual Studio)
+### From Source
 
-```bash
-# Configure with Visual Studio generator
-cmake -S . -B build -G "Visual Studio 17 2022"
+#### Prerequisites
 
-# Build
-cmake --build build --config Debug
-```
+- C++20 compatible compiler (GCC 11+, Clang 12+, MSVC 2022+)
+- CMake 3.25 or higher
+
+#### Unix/Linux/macOS
+
+1. **Configure the build**:
+   ```bash
+   cmake -S . -B build
+   ```
+
+2. **Build the library**:
+   ```bash
+   cmake --build build --config Release
+   ```
+
+3. **Copy to your project**:
+   ```bash
+   cp -r build/dist/include/slick /path/to/your/project/include/
+   ```
+
+   The library is header-only on Unix/Linux/macOS platforms, so only headers are needed.
+
+#### Windows (Visual Studio)
+
+1. **Configure the build**:
+   ```bash
+   cmake -S . -B build -G "Visual Studio 17 2022"
+   ```
+
+2. **Build the library**:
+   ```bash
+   cmake --build build --config Release
+   ```
+
+3. **Copy headers and library**:
+   ```bash
+   xcopy build\dist\include\slick <your-project>\include\slick /E
+   xcopy build\dist\lib\slick_socket.lib <your-project>\lib\
+   ```
+
+4. **Link in your CMakeLists.txt**:
+   ```cmake
+   # Add the slick_socket include and lib directories
+   target_include_directories(your_target PRIVATE path/to/slick/include)
+   target_link_directories(your_target PRIVATE path/to/slick/lib)
+
+   # Link the libraries
+   target_link_libraries(your_target PRIVATE slick_socket ws2_32)
+   ```
+
+   **Or manually** in Visual Studio:
+   - Add include path: `path/to/slick/include`
+   - Add library path: `path/to/slick/lib`
+   - Link with: `slick_socket.lib` and `ws2_32.lib`
 
 ## Usage
 
-Since this is a header-only library, simply include the headers you need:
+### Basic Example
+
+Include the headers you need in your project:
 
 ```cpp
-#include "tcp_server.h"
-#include "tcp_client.h" 
-#include "multicast_sender.h"
-#include "multicast_receiver.h"
+#include <slick/socket/tcp_server.h>
+#include <slick/socket/tcp_client.h>
+#include <slick/socket/multicast_sender.h>
+#include <slick/socket/multicast_receiver.h>
 ```
 
+### Creating a TCP Server
+
+```cpp
+#include <slick/socket/tcp_server.h>
+
+class MyServer : public slick::socket::TCPServerBase<MyServer>
+{
+public:
+    MyServer() : TCPServerBase("MyServer", {/*.port = 5000*/}) {}
+
+    void onClientConnected(int client_id, const std::string& address)
+    {
+        std::cout << "Client " << client_id << " connected from " << address << std::endl;
+    }
+
+    void onClientData(int client_id, const uint8_t* data, size_t size)
+    {
+        // Echo back to client
+        send_data(client_id, std::vector<uint8_t>(data, data + size));
+    }
+
+    void onClientDisconnected(int client_id)
+    {
+        std::cout << "Client " << client_id << " disconnected" << std::endl;
+    }
+};
+
+int main()
+{
+    MyServer server;
+    server.start();
+    // ... server runs in background thread
+    return 0;
+}
+```
+
+For more examples, see the [examples/](examples/) directory.
+
 ## Testing
 
 Run the complete test suite:
@@ -78,23 +173,42 @@ Enable verbose test output:
 cd build && ctest -V -C Debug
 ```
 
-## Build Options
+## Development
 
-### AddressSanitizer
+### Build Options
 
-Enable AddressSanitizer for debugging:
+#### AddressSanitizer
+
+Enable AddressSanitizer for debugging memory issues:
 
 ```bash
 cmake -S . -B build -DENABLE_ASAN=ON
 cmake --build build --config Debug
 ```
 
-### Release Build
+#### Release Build with Optimization
 
 ```bash
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
 cmake --build build --config Release
 ```
 
+### Project Structure
+
+```
+slick_socket/
+├── include/slick/socket/     # Public headers
+│   ├── tcp_server.h          # TCP server base class
+│   ├── tcp_client.h          # TCP client base class
+│   ├── multicast_sender.h    # UDP multicast sender
+│   ├── multicast_receiver.h  # UDP multicast receiver
+│   └── logger.h              # Logger interface
+├── src/                       # Implementation files (Windows-specific)
+├── examples/                  # Usage examples
+├── tests/                     # Unit and integration tests
+└── CMakeLists.txt
+```
+
 ## Architecture
 
 The library uses a three-file pattern for cross-platform support: