binary_test.cpp

#include "nifpp.h"
#include <iostream>
using namespace std;
class BinaryStore
{
    ERL_NIF_TERM binary_term;
public:
    BinaryStore(ERL_NIF_TERM binary)
    {
        binary_term =  binary;
    }
    ERL_NIF_TERM increment_binary(ErlNifEnv* env, ERL_NIF_TERM ext_binary)
    {
        ErlNifBinary ebin, ibin, new_bin1, new_bin2;
        nifpp::get_throws(env, ext_binary, ebin); 
        nifpp::get_throws(env, binary_term, ibin); 
        enif_alloc_binary(ebin.size, &new_bin1);
        memcpy(new_bin1.data, ebin.data, ebin.size);
        enif_alloc_binary(ibin.size, &new_bin2);
        memcpy(new_bin2.data, ibin.data, ibin.size);
        printf("%d\n", new_bin1.data[0]);
        printf("%d\n", new_bin2.data[0]);
        new_bin1.data[0] = new_bin1.data[0] + new_bin2.data[0];
        printf("%d\n", new_bin2.data[0]);
        binary_term = nifpp::make(env, new_bin1);
        return binary_term;
    }
};
 
static int load(ErlNifEnv* env, void** priv, ERL_NIF_TERM load_info)
{
    nifpp::register_resource<BinaryStore>(env, nullptr, "binary");
    return 0;
}
 
static ERL_NIF_TERM open_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    try
    {
        ERL_NIF_TERM result;
        ErlNifBinary ebin, new_bin;
        auto map_ptr = nifpp::construct_resource<BinaryStore>(argv[0]);
        result = nifpp::make(env, map_ptr);
        return result;
    }
    catch(nifpp::badarg) {}
    catch(...) {}
    return enif_make_badarg(env);
}
 
static ERL_NIF_TERM increment_binary_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    try
    {
        nifpp::resource_ptr<BinaryStore> ptr;
        printf("%d\n", nifpp::get(env, argv[0], ptr));
        ERL_NIF_TERM term = (*ptr).increment_binary(env, argv[1]);
        return term;
    }
    catch(...) {}
    return enif_make_badarg(env);
}
extern "C" {
 
static ErlNifFunc nif_funcs[] = { {"open", 1, open_nif},{"increment", 2, increment_binary_nif} };
 
ERL_NIF_INIT(binary_test, nif_funcs, load, NULL, NULL, NULL)
 
} //extern C