smartptr.hpp

Go to the documentation of this file.

#pragma once
 
#ifndef SMARTPTR_H
#define SMARTPTR_H
 
#include <memory>
#include <mutex>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <string>
 
#ifdef _WIN32
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #pragma comment(lib, "ws2_32.lib")
#else
    #include <netdb.h>
    #include <arpa/inet.h>
    #include <unistd.h>
#endif

#define RETAIN_SHARED_PTR(ptr) smartptr::retain(ptr)

#define RELEASE_SHARED_PTR(ptr) smartptr::release(ptr)
 
namespace smartptr {

inline void default_deleter(void* ptr) {
    std::free(ptr);
}

struct NetworkInfo {
    char ip[INET_ADDRSTRLEN]; 
    int family;               
};

inline NetworkInfo get_local_network_info() {
    NetworkInfo net_info{};
 
#ifdef _WIN32
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);
#endif
 
    char hostname[256];
    if (gethostname(hostname, sizeof(hostname)) != 0) {
        perror("gethostname failed");
        std::exit(EXIT_FAILURE);
    }
 
    struct addrinfo hints{}, *res;
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE;
 
    if (getaddrinfo(hostname, nullptr, &hints, &res) != 0) {
        perror("getaddrinfo failed");
        std::exit(EXIT_FAILURE);
    }
 
    auto* ipv4 = (struct sockaddr_in*)res->ai_addr;
    inet_ntop(AF_INET, &(ipv4->sin_addr), net_info.ip, INET_ADDRSTRLEN);
    net_info.family = res->ai_family;
 
    freeaddrinfo(res);
 
#ifdef _WIN32
    WSACleanup();
#endif
 
    return net_info;
}

struct SharedPtr {
    void* ptr = nullptr;                  
    int* ref_count = nullptr;              
    std::mutex* mutex = nullptr;           
    void (*deleter)(void*) = default_deleter; 
};

inline SharedPtr create(size_t size, void (*deleter)(void*) = default_deleter) {
    SharedPtr sp;
    sp.ptr = std::malloc(size);
    sp.ref_count = (int*)std::malloc(sizeof(int));
    *sp.ref_count = 1;
    sp.mutex = new std::mutex();
    sp.deleter = deleter;
    return sp;
}

inline void retain(SharedPtr* sp) {
    sp->mutex->lock();
    ++(*sp->ref_count);
    sp->mutex->unlock();
}

inline void release(SharedPtr* sp) {
    sp->mutex->lock();
    if (--(*sp->ref_count) == 0) {
        sp->deleter(sp->ptr);
        std::free(sp->ref_count);
        sp->mutex->unlock();
        delete sp->mutex;
        sp->ptr = nullptr;
        sp->ref_count = nullptr;
        sp->mutex = nullptr;
    } else {
        sp->mutex->unlock();
    }
}

struct UniquePtr {
    void* ptr = nullptr;                  
    void (*deleter)(void*) = default_deleter; 
};

inline UniquePtr make_unique(size_t size, void (*deleter)(void*) = default_deleter) {
    UniquePtr up;
    up.ptr = std::malloc(size);
    up.deleter = deleter;
    return up;
}

inline void destroy(UniquePtr* up) {
    if (up->ptr) {
        up->deleter(up->ptr);
        up->ptr = nullptr;
    }
}

inline UniquePtr transfer(UniquePtr* up) {
    UniquePtr new_up = *up;
    up->ptr = nullptr;
    return new_up;
}
 
} // namespace smartptr
 
#endif // SMARTPTR_H // end of SmartPointer