Development Best Practices

git checkout feature-branch
git rebase main

git push --force

git config --global pull.rebase true

git pull --rebase origin main

git rebase -i HEAD~n  # Replace 'n' with the number of commits to squash

git checkout main
git rebase feature-branch

git merge --ff-only feature-branch

git config --global merge.ff only

git commit --amend

/// \brief Brief description of the function
/// \details More detailed explanation if necessary.
/// \param x Description of parameter x
/// \return Description of return value
int my_function(int x);

#include <cmath>
#include <stdexcept>

/**
 * @brief Computes the area of a triangle using Heron's formula.
 *
 * This function calculates the area of a triangle given the lengths of its three sides.
 * It uses Heron's formula, which states that for a triangle with sides a, b, and c:
 *
 * \f[
 * A = \sqrt{s \cdot (s - a) \cdot (s - b) \cdot (s - c)}
 * \f]
 *
 * where \f$s\f$ is the semi-perimeter:
 *
 * \f[
 * s = \frac{a + b + c}{2}
 * \f]
 *
 * @param a The length of the first side (must be positive).
 * @param b The length of the second side (must be positive).
 * @param c The length of the third side (must be positive).
 * @return The computed area of the triangle.
 * @throws std::invalid_argument if the sides do not form a valid triangle.
 * @throws std::domain_error if the computed area is invalid due to floating-point errors.
 */
double computeTriangleArea(double a, double b, double c) {
    if (a <= 0 || b <= 0 || c <= 0) {
        throw std::invalid_argument("All side lengths must be positive.");
    }

    // Check for the triangle inequality
    if (a + b <= c || a + c <= b || b + c <= a) {
        throw std::invalid_argument("The given sides do not form a valid triangle.");
    }

    // Calculate semi-perimeter
    double s = (a + b + c) / 2.0;

    // Compute area using Heron's formula
    double area = std::sqrt(s * (s - a) * (s - b) * (s - c));

    if (std::isnan(area) || area <= 0) {
        throw std::domain_error("Computed area is invalid due to floating-point errors.");
    }

    return area;
}

/**
 * @brief Resizes the container to contain @p __sz elements.
 *
 * If @p __sz is smaller than the current size, the container is reduced to its first @p __sz elements.
 * If @p __sz is greater than the current size, additional default-constructed elements are appended.
 *
 * @param __sz The new size of the container.
 *
 * If an expansion is needed and sufficient capacity exists, no reallocation occurs.
 * Otherwise, new storage is allocated and existing elements are moved.
 *
 * @exception If an exception is thrown during element construction or move, the container remains unchanged.
 *
 * Complexity: Linear in the difference between old and new size.
 */
template <class _Tp, class _Allocator>
void vector<_Tp, _Allocator>::resize(size_type __sz) {
    if (__sz < size()) {

        // Shrink: Destroy extra elements
        erase(begin() + __sz, end());
    } else if (__sz > size()) {

        // Grow: Append default-constructed elements
        insert(end(), __sz - size(), _Tp());
    }
}

/// \pre `ptr` must not be null.
/// \post Returns a valid shared_ptr managing `ptr`.
/// \throws std::bad_alloc if allocation fails.
std::shared_ptr<T> safe_wrap(T* ptr);

/*!
@file
Defines `boost::hana::transform`.
*/

namespace boost { namespace hana {

    //! Transform each element of a sequence with a given function.
    //! @ingroup group-Sequence
    //!
    //! Example:
    //! @code
    //! auto doubled = hana::transform(hana::make_tuple(1, 2, 3), [](auto x) { return x * 2; });
    //! @endcode
    //! doubled == hana::make_tuple(2, 4, 6)
    //!
    template <typename Xs, typename F>
    constexpr auto transform(Xs&& xs, F&& f) {

        // See below for the commented version of this function.
    }
}}

    constexpr auto transform(Xs&& xs, F&& f) {
        return hana::adjust_if(

            static_cast<Xs&&>(xs), // Forward the sequence `xs`

            [](auto const&) { return true; }, // Always apply the transformation

            static_cast<F&&>(f) // Forward the transformation function
        );
    }

void start_read() {

    // Prepare a buffer to store incoming data.
    socket_.async_read_some(boost::asio::buffer(data_, max_length),
        [this](boost::system::error_code ec, std::size_t length) {
            if (!ec) {

                // Successfully read some data, process it.
                handle_data(data_, length);

                // Initiate another asynchronous read to continue receiving data.
                start_read();
            } else {

                // An error occurred, log and handle it.
                handle_error(ec);
            }
        });
}

#include <boost/asio.hpp>
#include <iostream>
#include <memory>
#include <utility>

using boost::asio::ip::tcp;

class Session : public std::enable_shared_from_this<Session> {
public:
    explicit Session(tcp::socket socket)

        : socket_(std::move(socket)) {}  // Move socket into this session

    void start() {

        read();  // Begin reading data from the client
    }

private:
    void read() {

        auto self = shared_from_this();  // Ensure session remains alive during async operation

        // Asynchronous read operation
        socket_.async_read_some(boost::asio::buffer(data_, max_length),
            [self](boost::system::error_code ec, std::size_t length) {
                if (!ec) {

                    // Successfully received data, now send a response
                    self->write(length);
                } else {

                    // Handle connection errors (e.g., client disconnected)
                    std::cerr << "Read error: " << ec.message() << std::endl;
                }
            });
    }

    void write(std::size_t length) {

        auto self = shared_from_this();  // Keep session alive for async write

        // Asynchronous write operation
        boost::asio::async_write(socket_, boost::asio::buffer(data_, length),
            [self](boost::system::error_code ec, std::size_t /*bytes_transferred*/) {
                if (!ec) {

                    // Successfully wrote data, continue reading for more client input
                    self->read();
                } else {

                    // Handle write error (e.g., broken pipe)
                    std::cerr << "Write error: " << ec.message() << std::endl;
                }
            });
    }

    tcp::socket socket_;
    enum { max_length = 1024 };

    char data_[max_length];  // Buffer to store incoming data
};

// Server class that listens for incoming connections
class Server {
public:
    Server(boost::asio::io_context& io_context, short port)
        : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)) {

        accept();  // Start listening for connections
    }

private:
    void accept() {
        acceptor_.async_accept(
            [this](boost::system::error_code ec, tcp::socket socket) {
                if (!ec) {

                    // Successfully accepted a connection, create a session
                    std::make_shared<Session>(std::move(socket))->start();
                } else {

                    // Log accept error
                    std::cerr << "Accept error: " << ec.message() << std::endl;
                }

                // Continue accepting new connections
                accept();
            });
    }

    tcp::acceptor acceptor_;
};

// Main function to run the server
int main() {
    try {
        boost::asio::io_context io_context;

        Server server(io_context, 12345);  // Start server on port 12345

        io_context.run();  // Run the IO context to handle async operations
    } catch (std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }
}