An object oriented C++ wrapper for CURL (libcurl)

Overview

curlcpp

An object-oriented C++ wrapper for cURL tool

If you want to know a bit more about cURL and libcurl, you should go on the official website http://curl.haxx.se/

Donate

Help me to improve this project!

paypal

Compile and link

Standalone

cd build
cmake ..
make # -j2

Note: cURL >= 7.34 is required.

Then add <curlcpp root>/build/src/ to your library path and <curlcpp root>/include/ to your include path.

When linking, link against curlcpp (e.g.: g++ -std=c++11 example.cpp -o example -lcurlcpp -lcurl). Or if you want run from terminal,

g++ -std=c++11 example.cpp -L/home/username/path/to/build/src/ -I/home/username/path/to/include/ -lcurlcpp -lcurl

Submodule

When using a git submodule and CMake-buildsystem, add the following lines to your CMakeLists.txt:

ADD_SUBDIRECTORY(ext/curlcpp) # Change `ext/curlcpp` to a directory according to your setup
INCLUDE_DIRECTORIES(${CURLCPP_SOURCE_DIR}/include)

Simple usage example

Here are some usage examples. You will find more examples in the test folder!

Here's an example of a simple HTTP request to get google web page, using the curl_easy interface:

#include "curl_easy.h"

using curl::curl_easy;
using curl::curl_easy_exception;
using curl::curlcpp_traceback;

/**
 * This example shows how to make a simple request with curl.
 */
int main() {
    // Easy object to handle the connection.
    curl_easy easy;

    // Add some options.
    easy.add<CURLOPT_URL>("http://<your_url_here>");
    easy.add<CURLOPT_FOLLOWLOCATION>(1L);

    try {
        easy.perform();
    } catch (curl_easy_exception &error) {
    	// If you want to print the last error.
        std::cerr<<error.what()<<std::endl;
    }
    return 0;
}

If you want to get information about the current curl session, you could do:

#include "curl_easy.h"
#include "curl_ios.h"
#include "curl_exception.h"

using std::ostringstream;

using curl::curl_easy;
using curl::curl_easy_exception;
using curl::curlcpp_traceback;
using curl::curl_ios;

/**
 * This example shows how to use the easy interface and obtain
 * informations about the current session.
 */
int main(int argc, const char **argv) {
    // Let's declare a stream
    ostringstream stream;

    // We are going to put the request's output in the previously declared stream
    curl_ios<ostringstream> ios(stream);

    // Declaration of an easy object
    curl_easy easy(ios);

    // Add some option to the curl_easy object.
    easy.add<CURLOPT_URL>("http://<your_url_here>");
    easy.add<CURLOPT_FOLLOWLOCATION>(1L);

    try {
        easy.perform();

		// Retrieve information about curl current session.
		auto x = easy.get_info<CURLINFO_CONTENT_TYPE>();

		/**
		 * get_info returns a curl_easy_info object. With the get method we retrieve
		 * the std::pair object associated with it: the first item is the return code of the
		 * request. The second is the element requested by the specified libcurl macro.
		 */
		std::cout<<x.get()<<std::endl;

    } catch (curl_easy_exception &error) {
		// If you want to print the last error.
		std::cerr<<error.what()<<std::endl;

		// If you want to print the entire error stack you can do
		error.print_traceback();
    }
    return 0;
}

Here's instead, the creation of an HTTPS POST login form:

#include <string>

#include "curl_easy.h"
#include "curl_pair.h"
#include "curl_form.h"
#include "curl_exception.h"

using std::string;

using curl::curl_form;
using curl::curl_easy;
using curl::curl_pair;
using curl::curl_easy_exception;
using curl::curlcpp_traceback;

int main(int argc, const char * argv[]) {
    curl_form form;
    curl_easy easy;

    // Forms creation
    curl_pair<CURLformoption,string> name_form(CURLFORM_COPYNAME,"user");
    curl_pair<CURLformoption,string> name_cont(CURLFORM_COPYCONTENTS,"you username here");
    curl_pair<CURLformoption,string> pass_form(CURLFORM_COPYNAME,"passw");
    curl_pair<CURLformoption,string> pass_cont(CURLFORM_COPYCONTENTS,"your password here");
    
    try {
        // Form adding
        form.add(name_form,name_cont);
        form.add(pass_form,pass_cont);
        
        // Add some options to our request
        easy.add<CURLOPT_URL>("http://<your_url_here>");
        easy.add<CURLOPT_SSL_VERIFYPEER>(false);
        easy.add<CURLOPT_HTTPPOST>(form.get());
        // Execute the request.
        easy.perform();

    } catch (curl_easy_exception &error) {
        // If you want to get the entire error stack we can do:
        curlcpp_traceback errors = error.get_traceback();
        // Otherwise we could print the stack like this:
        error.print_traceback();
    }
    return 0;
}

And if we would like to put the returned content in a file? Nothing easier than:

#include <iostream>
#include <ostream>
#include <fstream>

#include "curl_easy.h"
#include "curl_ios.h"
#include "curl_exception.h"

using std::cout;
using std::endl;
using std::ostream;
using std::ofstream;

using curl::curl_easy;
using curl::curl_ios;
using curl::curl_easy_exception;
using curl::curlcpp_traceback;

int main(int argc, const char * argv[]) {
    // Create a file
    ofstream myfile;
    myfile.open ("/path/to/your/file");
    
    // Create a curl_ios object to handle the stream
    curl_ios<ostream> writer(myfile);
    // Pass it to the easy constructor and watch the content returned in that file!
    curl_easy easy(writer);
    
    // Add some option to the easy handle
    easy.add<CURLOPT_URL>("http://<your_url_here>");
    easy.add<CURLOPT_FOLLOWLOCATION>(1L);
    try {
        // Execute the request
        easy.perform();

    } catch (curl_easy_exception &error) {
		// If you want to print the last error.
		std::cerr<<error.what()<<std::endl;

		// If you want to print the entire error stack you can do
		error.print_traceback();
    }
    myfile.close();
    return 0;
}

Not interested in files? So let's put the request's output in a variable!

#include <iostream>
#include <ostream>

#include "curl_easy.h"
#include "curl_form.h"
#include "curl_ios.h"
#include "curl_exception.h"

using std::cout;
using std::endl;
using std::ostringstream;

using curl::curl_easy;
using curl::curl_ios;
using curl::curl_easy_exception;
using curl::curlcpp_traceback;

int main() {
    // Create a stringstream object
    ostringstream str;
    // Create a curl_ios object, passing the stream object.
    curl_ios<ostringstream> writer(str);
    
    // Pass the writer to the easy constructor and watch the content returned in that variable!
    curl_easy easy(writer);
    // Add some option to the easy handle
    easy.add<CURLOPT_URL>("http://<your_url_here>");
    easy.add<CURLOPT_FOLLOWLOCATION>(1L);

    try {
        easy.perform();

        // Let's print the stream content
        cout<<str.str()<<endl;

    } catch (curl_easy_exception &error) {
		// If you want to print the last error.
		std::cerr<<error.what()<<std::endl;

		// If you want to print the entire error stack you can do
		error.print_traceback();
    }
    return 0;
}

I have implemented a sender and a receiver to make it easy to use send/receive without handling buffers. For example, a very simple send/receiver would be:

#include <iostream>
#include <string>

#include "curl_easy.h"
#include "curl_form.h"
#include "curl_pair.h"
#include "curl_receiver.h"
#include "curl_exception.h"
#include "curl_sender.h"

using std::cout;
using std::endl;
using std::string;

using curl::curl_form;
using curl::curl_easy;
using curl::curl_sender;
using curl::curl_receiver;
using curl::curl_easy_exception;
using curl::curlcpp_traceback;

int main(int argc, const char * argv[]) {
    // Simple request
    string request = "GET / HTTP/1.0\r\nHost: example.com\r\n\r\n";
    // Creation of easy object.
    curl_easy easy;
    try {
        easy.add<CURLOPT_URL>("http://<your_url_here>");
        // Just connect
        easy.add<CURLOPT_CONNECT_ONLY>(true);
        // Execute the request.
        easy.perform();

    } catch (curl_easy_exception &error) {
        // If you want to get the entire error stack we can do:
        curlcpp_traceback errors = error.get_traceback();
        // Otherwise we could print the stack like this:
        error.print_traceback();
    }
    
    // Creation of a sender. You should wait here using select to check if socket is ready to send.
    curl_sender<string> sender(easy);
    sender.send(request);
    // Prints che sent bytes number.
    cout<<"Sent bytes: "<<sender.get_sent_bytes()<<endl;

    for(;;) {
        // You should wait here to check if socket is ready to receive
        try {
            // Create a receiver
            curl_receiver<char, 1024> receiver;
            // Receive the content on the easy handler
            receiver.receive(easy);
            // Prints the received bytes number.
            cout<<"Receiver bytes: "<<receiver.get_received_bytes()<<endl;

        } catch (curl_easy_exception &error) {
            // If any errors occurs, exit from the loop
            break;
        }
    }
    return 0;
}
Comments
  • Thread Safety : curl_exception's get_traceback's copy is not protected

    Thread Safety : curl_exception's get_traceback's copy is not protected

    Hi,

    There may be a small problem if curlcpp is used from several threads. Since the curl_exception's traceback is a static vector, you will have an issue if the get_traceback function's return value is being copied and an insert happens to the vector that results in the container being reallocated. This will result in a pretty nasty crash because the previous vector element memory is likely invalid now.

    For example, say there are 3 elements in traceback. 1 has been copied in get_traceback and then an insert happens from another thread which causes the vector to reallocate. In this case, the 1 element that was copied is going to be invalid memory.

    It would be better to provide a new function that takes a vector as an output parameter and use the tracebackLocker to lock the std::copy operation. You can then mark the current function as not thread-safe. Alternatively, can traceback be a non-static member?

    opened by vivshankar 16
  • Release:1.2 Cmake fails.

    Release:1.2 Cmake fails.

    Following instructions: made a "build" directory. Cd into it. cmake .., and get greeted by this:

    -- IPO / LTO supported, will enable for targets in release build type
    You have called ADD_LIBRARY for library curlcpp without any source files. This typically indicates a problem with your CMakeLists.txt file
    CMake Error: Could not open file for write in copy operation /curlcppConfig.cmake.tmp
    CMake Error: : System Error: Permission denied
    CMake Error at CMakeLists.txt:37 (configure_file):
      configure_file Problem configuring file
    
    
    -- Configuring incomplete, errors occurred!
    

    Running on Linux Mint 19 | Cmake: 3.10.2

    Testing release 1.1: and cmake runs fine.

    opened by LCWilliams 15
  • 'NOEXCEPT' does not name a type

    'NOEXCEPT' does not name a type

    When I compile curlcpp on Windows with MinGW I get the following error:

    $ make
    Scanning dependencies of target curlcpp
    [ 12%] Building CXX object src/CMakeFiles/curlcpp.dir/curl_easy.cpp.obj
    [ 25%] Building CXX object src/CMakeFiles/curlcpp.dir/curl_header.cpp.obj
    In file included from C:/curlcpp/src/curl_head
    er.cpp:6:0:
    C:/curlcpp/include/curl_header.h:66:22: error:
     expected ';' at end of member declaration
             ~curl_header() NOEXCEPT;
                          ^
    C:/curlcpp/include/curl_header.h:66:24: error:
     'NOEXCEPT' does not name a type
             ~curl_header() NOEXCEPT;
                            ^
    make[2]: *** [src/CMakeFiles/curlcpp.dir/curl_header.cpp.obj] Error 1
    make[1]: *** [src/CMakeFiles/curlcpp.dir/all] Error 2
    make: *** [all] Error 2
    

    How can I fix this?

    opened by antonlukyanov 14
  • Build of 1.4 fail with mingw32 in win10 and curl 7.74.0

    Build of 1.4 fail with mingw32 in win10 and curl 7.74.0

    Hello. I tried to compile the library (latest master branch and tag1.4) in Windows 10 with mingw32 and (latest) curl 7.74.0 (x32 and x64). The curl is downloaded from https://curl.se/windows/.

    The static library libcurlcpp.a is created with no problem.

    But when it tries to link with recv_header_example_exec.exe (or other programs) it get undefined reference errors. I've included the compile procedure's log below for commit-tag 1.4 with curl compilex32URFail.log

    When trying to link with curl 7.74.0 x64 I get similar issues. Same when linking with the libcurl.dll.a.

    If anyone could check it it would be nice. Thanks.

    opened by terablade2001 12
  • Problem linking curlcpp in Ubuntu 16.04

    Problem linking curlcpp in Ubuntu 16.04

    Good evening (again),

    I would be making this thread unless I had exhausted all my other options.

    I've been trying to compile my code in my new Ubuntu 16.04 server but I keep getting the same error every time:

    /usr/lib/ld: cannot find -lcurlcpp collect2: error: ld returned 1 exit status

    Is there any work around for this? (Unfortunately I don't have the option to upgrade my server). (I've run the installation that you provide without any error)

    Thanks in advance, Stavros

    opened by stav121 10
  • getinfo for curl_easy interface

    getinfo for curl_easy interface

    Perhaps I miss something while searching the source but is there a way to use getinfo (https://curl.haxx.se/libcurl/c/curl_easy_getinfo.html) from the curl easy interface? I am particularly trying to get the status code of a request after calling perform.

    opened by AlexGoico 10
  • Sending JSON data over POST

    Sending JSON data over POST

    Hi, i'm tring to send json data over POST:

    Here's my code

    curl_easy easy;
    curl_header header;
    header.add("Content-Type: application/json");
    easy.add(curl_pair<CURLoption,curl_header>(CURLOPT_HTTPHEADER, header));
    easy.add(curl_pair<CURLoption,string>(CURLOPT_URL, "http://localhost:3000/activePlayers"));
    easy.add(curl_pair<CURLoption,string>(CURLOPT_HTTPPOST,a));
    try {
        easy.perform();
    } catch (curl_easy_exception error) {
        // Print errors, if any
        error.print_traceback();
    }
    

    I get the following error:

    ERROR: Out of memory ::::: FUNCTION: perform

    Any idea how to set the application/json header and send JSON over POST ?

    opened by edi9999 10
  • missing: CURL_LIBRARY CURL_INCLUDE_DIR

    missing: CURL_LIBRARY CURL_INCLUDE_DIR

    I'm new to curl, I hope anyone could help to solve this I have installed curl from http://www.confusedbycode.com/curl/ when I'm trying cmake for visual studio v12 2013..I'm getting following error

    missing: CURL_LIBRARY CURL_INCLUDE_DIR

    This is the cmake log: The C compiler identification is MSVC 18.0.30723.0 The CXX compiler identification is MSVC 18.0.30723.0 Check for working C compiler using: Visual Studio 12 2013 Win64 Check for working C compiler using: Visual Studio 12 2013 Win64 -- works Detecting C compiler ABI info Detecting C compiler ABI info - done Check for working CXX compiler using: Visual Studio 12 2013 Win64 Check for working CXX compiler using: Visual Studio 12 2013 Win64 -- works Detecting CXX compiler ABI info Detecting CXX compiler ABI info - done CMake Error at C:/Program Files (x86)/CMake/share/cmake-3.0/Modules/FindPackageHandleStandardArgs.cmake:136 (message): Could NOT find CURL (missing: CURL_LIBRARY CURL_INCLUDE_DIR) Call Stack (most recent call first): C:/Program Files (x86)/CMake/share/cmake-3.0/Modules/FindPackageHandleStandardArgs.cmake:343 (_FPHSA_FAILURE_MESSAGE) C:/Program Files (x86)/CMake/share/cmake-3.0/Modules/FindCURL.cmake:61 (FIND_PACKAGE_HANDLE_STANDARD_ARGS) CMakeLists.txt:7 (FIND_PACKAGE)

    Configuring incomplete, errors occurred!

    opened by chrisnhans 10
  • problem with CURLOPT_POSTFIELDS not working

    problem with CURLOPT_POSTFIELDS not working

    This fails: easy.add(curl_pair<CURLoption, string>(CURLOPT_POSTFIELDS, "This will fail")); easy.perform();

    I think this is because the scope of the string only lasts as long as the call, but internally a pointer is kept to the raw string data. You probably should take an internal copy of the string somewhere before converting it to a C char buffer.

    I'm not sure if this applies to other calls too....

    To get this to work correctly I had to do this: const std::string data("This will work"); easy.add(curl_pair<CURLoption, string>(CURLOPT_POSTFIELDS, data)); easy.perform():

    opened by pixiepoop 9
  • [RFC] are the `curl_multi::get_info` and `curl_multi::is_finished` methods broken?

    [RFC] are the `curl_multi::get_info` and `curl_multi::is_finished` methods broken?

    IIUC the documentation every messages are returned only once and then removed from the internal handle.

    But curl_multi::is_finished consumes all the queue searching for a specific easy handle, discarding the messages it is not interested in.

    auto m = curl::curl_multi{};
    
    m.add(easy1);
    m.add(easy2);
    
    // do something
    
    std::cout << m.is_finished(easy1) << std::endl;
    std::cout << m.is_finished(easy2) << std::endl;
    

    The first call to curl_multi::is_finished could discard a message for easy2.

    What if we add an unordered_map[easy_handle->message] in the curl_multi class in order to store the messages returned by curl_multi_info_read (overwrite the old ones should be ok)?

    According to this answer on stackoverflow in order to reuse an easy handle you have to remove it, change and then re-add to the multi instance; if so we can cleanup the messages map during the remove phase.

    opened by dvd0101 8
  • Modern CMake support

    Modern CMake support

    Hello, I'm interested in using the library however I want to have 2 things: modern C++ and modern CMake. The first one is rather trivial to find info about but the second is (still) rather hard to encounter.

    So what I mean by modern CMake is:

    • Any project that needs library foobar should be enough to just write target_link_libraries(project_name PRIVATE foobar). If there are any compiler/linker flags missing that's the library's fault.
    • foobar should never touch any global CMake variables (CMAKE_*) as changing any can corrupt the build of the whole dependency tree. It should instead declare everything through target_* CMake functions as either PUBLIC or PRIVATE requirement.

    This repository contains rather old CMake recipe, so I'm asking whether you are interested in any PRs. The would bump the minimum required CMake version significantly.

    opened by Xeverous 7
  • Singleton initializer issue

    Singleton initializer issue

    Hi, im trying to do something similar to the recv_header.cpp example but inside of a class.

    I have no issue with compile/link but when running my class i get memory issues here:

    // curl_interface.h
    // Implementation of the singleton initializer
    template<class T> curl_interface<T>::global_initializer::global_initializer(const long flag) {
        const CURLcode code = curl_global_init(flag);
        if (code != CURLE_OK) {
            throw curl_easy_exception(code,__FUNCTION__);
        }
    }
    
    Exception has occurred: W32/0xC0000374
    Unhandled exception at 0x00007FFCC208F199 (ntdll.dll) in main.exe: 0xC0000374
    

    My class is like:

    class CurlCppClient
    {
      private:
        std::ostringstream body_var;
        std::ostringstream header_var;
        curl::curl_ios<std::ostringstream> body;
        curl::curl_ios<std::ostringstream> header;
        curl::curl_easy curl_handler;
        ....
      public:
        ...
    }
    
    CurlCppClient::CurlCppClient()
      : body{header_var}, header{body_var}
    {
      curl_handler.add<CURLOPT_WRITEFUNCTION>(header.get_function());
      curl_handler.add<CURLOPT_HEADERDATA>(header.get_stream());
      curl_handler.add<CURLOPT_WRITEDATA>(body.get_stream());
      ...
    }
    

    I have no issue if I only use one std::ostringstream like in easy_info.cpp but once i add the second std::ostringstream (even if i dont set the write function) it fails at the singleton.

    Any ideas?

    opened by pipawoz 1
  • NOEXCEPT

    NOEXCEPT

    I don't get the use of NOEXCEPT macro

    https://github.com/JosephP91/curlcpp/blob/0c2f06df81c6cb24fad11fd12d69a2dd19360285/include/curl_config.h#L25-L35

    • noexcept is a mandatory language feature and a conforming C++11 compiler must support it
    • <ciso646> has been removed in C++20, so a conforming implementation may actually fail to build
    • The __curlcpp__curl_config__ is technically undefined behavior (any names containing __, especially the ones starting with double underscore or an underscore + uppercase letter are reserved for the implementation) - this is obviously very unlikely to cause problems, but mentioning this in case you care for maximum conformance.
    opened by Xeverous 0
Releases(2.1)
  • 2.1(Oct 24, 2022)

  • 2.0(Oct 11, 2022)

  • 1.5(Sep 15, 2022)

    What's Changed

    • cmake: don't hardcode libdir value by @nE0sIghT in https://github.com/JosephP91/curlcpp/pull/130
    • Update CMake code for installing target by @prateek9623 in https://github.com/JosephP91/curlcpp/pull/132
    • General warning removal, curl_pair specialization. #128 by @pipawoz in https://github.com/JosephP91/curlcpp/pull/133
    • initialising order warnings by @mihir3445 in https://github.com/JosephP91/curlcpp/pull/139
    • Hotfix/build test option by @sakthi-vivek in https://github.com/JosephP91/curlcpp/pull/140
    • Fix cmake CURL dependency by @fferflo in https://github.com/JosephP91/curlcpp/pull/142
    • Add getter for underlying handle in curl_share by @memcorrupt in https://github.com/JosephP91/curlcpp/pull/145
    • Fix needed while build with curl 7.83 by @prateek9623 in https://github.com/JosephP91/curlcpp/pull/144
    • add pkg-config definitions by @guijan in https://github.com/JosephP91/curlcpp/pull/146
    • Code cleanup to remove warnings by @memcorrupt in https://github.com/JosephP91/curlcpp/pull/147

    New Contributors

    • @nE0sIghT made their first contribution in https://github.com/JosephP91/curlcpp/pull/130
    • @prateek9623 made their first contribution in https://github.com/JosephP91/curlcpp/pull/132
    • @pipawoz made their first contribution in https://github.com/JosephP91/curlcpp/pull/133
    • @mihir3445 made their first contribution in https://github.com/JosephP91/curlcpp/pull/139
    • @sakthi-vivek made their first contribution in https://github.com/JosephP91/curlcpp/pull/140
    • @fferflo made their first contribution in https://github.com/JosephP91/curlcpp/pull/142
    • @memcorrupt made their first contribution in https://github.com/JosephP91/curlcpp/pull/145
    • @guijan made their first contribution in https://github.com/JosephP91/curlcpp/pull/146

    Full Changelog: https://github.com/JosephP91/curlcpp/compare/1.4...1.5

    Source code(tar.gz)
    Source code(zip)
    curlcpp-1.5.zip(74.33 KB)
  • 1.4(Jun 3, 2020)

  • 1.3(Jun 2, 2020)

  • 1.2(Mar 17, 2020)

    What's Changed

    • Static analyser issues by @lunixoid in https://github.com/JosephP91/curlcpp/pull/114
    • Fixed curl_pair<CURLformoption,string> handling of string constants by @hatkirby in https://github.com/JosephP91/curlcpp/pull/115
    • modern CMake by @Xeverous in https://github.com/JosephP91/curlcpp/pull/126

    New Contributors

    • @lunixoid made their first contribution in https://github.com/JosephP91/curlcpp/pull/114
    • @Xeverous made their first contribution in https://github.com/JosephP91/curlcpp/pull/126

    Full Changelog: https://github.com/JosephP91/curlcpp/compare/1.1...1.2

    Source code(tar.gz)
    Source code(zip)
    curlcpp-1.2.zip(71.32 KB)
  • 1.1(Oct 21, 2017)

    What's Changed

    • Disabled copying for curl_global, added curl_global_cleanup call by @sergey-shambir in https://github.com/JosephP91/curlcpp/pull/105
    • Made curl_multi movable not copyable. by @sergey-shambir in https://github.com/JosephP91/curlcpp/pull/104
    • Added method get_next_finished by @desertkun in https://github.com/JosephP91/curlcpp/pull/106
    • Fix value type for CURLOPT_PREQUOTE by @novadan in https://github.com/JosephP91/curlcpp/pull/110
    • get pointer from unique_ptr in curl_multi in https://github.com/JosephP91/curlcpp/pull/112

    New Contributors

    • @sergey-shambir made their first contribution in https://github.com/JosephP91/curlcpp/pull/105
    • @desertkun made their first contribution in https://github.com/JosephP91/curlcpp/pull/106
    • @novadan made their first contribution in https://github.com/JosephP91/curlcpp/pull/110

    Full Changelog: https://github.com/JosephP91/curlcpp/compare/1.0...1.1

    Source code(tar.gz)
    Source code(zip)
    curlcpp-1.1.zip(71.51 KB)
  • 1.0(Apr 22, 2017)

Owner
Giuseppe Persico
Lead Software Engineer
Giuseppe Persico
xpload is a C++ library to communicate with a calibration database via libcurl

xpload is a C++ library to communicate with a calibration database via libcurl

BNL Nuclear and Particle Physics Software Group 1 Jan 10, 2022
This is example for coding with Kotlin/Native, linking C libraries and comparison java.net.* with libcurl

KotlinNativeExample This is example for coding with Kotlin/Native, linking C libraries and comparison java.net.* with libcurl Running Running mingw64

Artem Musatenko 2 Jan 22, 2022
Data-oriented networking playground for the reliable UDP transports

NetDynamics is a data-oriented networking playground for the reliable UDP transports. The application was created for stress testing and debugging a p

Stanislav Denisov 92 Nov 9, 2022
A small data-oriented and SIMD-optimized 3D rigid body physics library.

nudge Nudge is a small data-oriented and SIMD-optimized 3D rigid body physics library. For more information, see: http://rasmusbarr.github.io/blog/dod

null 238 Nov 30, 2022
High-level networking API for real-time simulations with primitives for remote procedure call and object state replication

tnl2 - Torque Network Library version 2 tnl2 is a high-level networking API for real-time simulations with primitives for remote procedure call and o

Mark Frohnmayer 23 Apr 10, 2022
Wrapper library for the BSD sockets API with a nicer C99 interface

A wrapper library for the BSD sockets API. Why? This library trades the series of getaddrinfo, socket, connect, bind, listen, etc. functions and their

Scott Vokes 135 Oct 28, 2022
Header-only, event based, tiny and easy to use libuv wrapper in modern C++ - now available as also shared/static library!

Do you have a question that doesn't require you to open an issue? Join the gitter channel. If you use uvw and you want to say thanks or support the pr

Michele Caini 1.5k Nov 28, 2022
WinINet wrapper - tiny windows HTTPS library, no dependencies.

WNetWrap A tiny, dependency-free wrapper around WinINet for developers targeting Windows only, who need a lightweight native solution. Inspired by the

hack-tramp 26 Nov 4, 2022
Wrapper for linux TCP/UDP/unix/USB socket connections

Socket Connection wrapper shared library Shared library that realize sockets connections and could transfer data-packages. Navigation Navigation Insta

Dmitry Golgovsky 7 Dec 21, 2021
Portable, single-file, protocol-agnostic TCP and UDP socket wrapper, primarily for game networking

Documentation This is a header-only library, as such most of its functional documentation is contained within the "header section" of the source code

null 65 Aug 29, 2022
C++ wrapper for librg network library

librg-cpp Description C++ wrapper for librg network library Warning: The wrapper is under heavy development and will have breaking changes still a fir

null 6 Sep 28, 2020
A universal C++20 wrapper for cross-platform sockets.

NetSockets A fast and clean, universal C++20 wrapper for cross-platform sockets. This wrapper uses ENet by lsalzman (https://github.com/lsalzman/enet)

null 3 Apr 17, 2022
curl4cpp - single header cURL wrapper for C++ around libcURL.

curl4cpp - single header cURL wrapper for C++ around libcURL.

Ferhat Geçdoğan 15 Oct 13, 2022
curl cmake module libcurl build with msvc x86

curl-msvc Infomation curl cmake module libcurl build with MSVC10.0 arch (x86 | i386) source from https://github.com/curl/curl tags: curl-7_79_1 Usage

Jason Payne 0 May 16, 2022
Repository for the Object-oriented programming course for academic year 2020/21

Object-Oriented Programming 2020/21 Repository for the Object-oriented programming course for the 2020/21 academic year. Structure exam -- tasks given

Atanas Semerdzhiev 19 Oct 21, 2021
Loop is an object oriented programming language

Loop Loop is an object oriented programming language. How do I build and run loop? Make sure, you installed the requirements for clang and make: Debia

Loop 24 Aug 9, 2021
[3DV 2021] DSP-SLAM: Object Oriented SLAM with Deep Shape Priors

DSP-SLAM Project Page | Video | Paper This repository contains code for DSP-SLAM, an object-oriented SLAM system that builds a rich and accurate joint

Jingwen Wang 354 Nov 25, 2022
FEMTIC is a 3-D magnetotelluric inversion code. FEMTIC is made by object-oriented programming with C++.

FEMTIC FEMTIC is a 3-D magnetotelluric inversion code based on the following studies. FEMTIC was made using object-oriented programming with C++. FEMT

Yoshiya Usui 18 Nov 25, 2022
Object oriented programming(with C++)

Object oriented programming(with C++) finalTestReview vector push_back() size() (for iteration) inheritance pure function(virtual) in Base class must

Kim Moon Jeong 1 Dec 22, 2021
Carts - Simple Algorithm in C++ with Object-Oriented Flavor

It's a simple algorithm implemented in C++ with intentionally heavy usages of classes, inheritance, encapsulation, and polymorphism. There is a stock

Yegor Bugayenko 4 Jan 21, 2022