# Sockeye

An easy-to-use, fast socket C++ library! Uses epoll on Linux, kqueue on BSD/macOS.

## API Reference

### sockeye::Socket

Main server class for handling TCP connections.

#### Constructor
```cpp
explicit Socket(uint16_t port = 8080)
```

#### Methods

**`bool start()`**
Initialize the server socket and event system. Returns `true` on success.

**`void run()`**
Start the event loop. Blocks until `stop()` is called.

**`void stop()`**
Stop the server and exit the event loop.

**`void on_connection(ConnectionHandler handler)`**
Set callback for new client connections.

**`void on_data(DataHandler handler)`**
Set callback for incoming data from clients.

**`void on_disconnect(DisconnectHandler handler)`**
Set callback for client disconnections.

#### Handler Types

```cpp
using ConnectionHandler = std::function<void(int client_fd)>;
using DataHandler = std::function<void(int client_fd, const char* data, size_t len)>;
using DisconnectHandler = std::function<void(int client_fd)>;
```

## Examples

### Basic Echo Server

```cpp
#include "sockeye.hpp"
#include <iostream>
#include <cstring>

int main() {
	sockeye::Socket server(8080);

	server.on_connection([](int client_fd) {
		std::cout << "Client connected: " << client_fd << std::endl;
	});

	server.on_data([](int client_fd, const char* data, size_t len) {
		// Echo data back to client
		send(client_fd, data, len, 0);
	});

	server.on_disconnect([](int client_fd) {
		std::cout << "Client disconnected: " << client_fd << std::endl;
	});

	if (!server.start()) {
		std::cerr << "Failed to start server" << std::endl;
		return 1;
	}

	server.run();
	return 0;
}
```

### HTTP-like Server

```cpp
#include "sockeye.hpp"
#include <iostream>
#include <string>

int main() {
	sockeye::Socket server(8080);

	server.on_data([](int client_fd, const char* data, size_t len) {
		std::string request(data, len);

		// Simple HTTP response
		std::string response =
			"HTTP/1.1 200 OK\r\n"
			"Content-Length: 13\r\n"
			"Connection: close\r\n\r\n"
			"Hello, World!";

		send(client_fd, response.c_str(), response.length(), 0);
		close(client_fd);
	});

	if (!server.start()) {
		std::cerr << "Failed to start server" << std::endl;
		return 1;
	}

	std::cout << "Server listening on port 8080" << std::endl;
	server.run();
	return 0;
}
```

### Graceful Shutdown

```cpp
#include "sockeye.hpp"
#include <signal.h>

sockeye::Socket* server_ptr = nullptr;

void signal_handler(int signal) {
	if (server_ptr) {
		server_ptr->stop();
	}
}

int main() {
	sockeye::Socket server(8080);
	server_ptr = &server;

	signal(SIGINT, signal_handler);
	signal(SIGTERM, signal_handler);

	// Set up handlers...

	if (!server.start()) {
		return 1;
	}

	server.run();
	return 0;
}
```