BinOM Prototype

# On Debian/Ubuntu and other GNU/Linux distributions with APT package manager
$ sudo apt install gcc
$ sudo apt install make
# On CentOS/RadHat and other GNU/Linux distributions with RPM package manager
$ sudo yum install gcc
$ sudo yum install make

$ git clone https://github.com/gbytegear/BinOM.git

$ cd BinOM
$ make all

$ g++ -Ipath/to/lbinom/includes -Lpath/to/libbinom/ -lbinom -lstdc++fs <your sources>

#include "binom/includes/binom.h"
#include "binom/includes/lexer.h"
#include <fstream>


int main() {

  using namespace binom;

  // Create BinOM variable
  Variable var = varr{ // Array
    vobj{ // Object
      {"prop_1", 42_ui8}, // Byte
      {"prop_2", ui32arr{1,2,3,4,5}}, // Word array
      {"prop_3", "Hello, world!"} // Byte array from c-string
    }
  };
  /* Description:
    In BinOM it is possible to initialize a structure using initialization lists.
    This method is most convenient for initializing BinOM structures of any complexity.
    The following initialization lists are available for specifying structures:
    * varr - array,
    * vobj - object,
    * ui8arr - byte array,
    * ui16arr - word array,
    * ui32arr - dword array,
    * ui64ahr - qword array,
    * i8arr - byte array,
    * i16arr - word array,
    * i32arr - dword array,
    * i64arr - qword array.
    To indicate the size of numbers, it is better to use the declared
    literals of numbers:
    * 1_ui8 - byte,
    * 2_ui16 - word,
    * 3_ui32 - dword,
    * 4_ui64 - qword,
    * 5_i8 - byte,
    * 6_i16 - word,
    * 7_i32 - dword,
    * 8_i64 - qword,
    * 9.5_f32 - dword,
    * 10.5_f64 - qword.
    You can also use strings of different encodings to initialize
    buffer arrays:
    * "..." and u8"..." - byte array
    * L"..." - implementation defined
    * u16"..." - word array
    * u32"..." - dword array
    
    All initialization lists declared in `libbinom/include/utils/types.h`
    All number literals declared in `libbinom/include/utils/ctypes.h`
  */

  // Create BinOM serialized storage file
  SerializedStorage s_storage("data.binom");
  s_storage = var; // Save Variable to BinOM file
  Variable loaded = s_storage; // Load Variable from BinOM file
  std::cout << loaded << '\n'; // Print Variable

  // Create BinOM dynamic storage file (with struct from var as default)
  DynamicStorage d_storage("data.binomdb", var);
  FileNodeVisitor root = d_storage; // Atomaticly call DynamicStorage::getRoot()
  // Change "prop_3" variable in data.binomdb file
  root[{0, "prop_3"}].setVariable("Goodbie, world!"); // or root[0].setVariable("prop_3", "Goodbie, world!");
  // Get "prop_2" value from data.binomdb file in Variable
  Variable from_storgae = root[0]["prop_2"]; // or auto from_storgae = root[0].getVariable("prop_2");

  // Convert structure description to Variable (More details in the BSDL section)
  std::ifstream t("struct.bsdl");
  std::stringstream str_stream;
  str_stream << t.rdbuf();
  Variable data = lexer << str_stream.str();
  std::cout << "From BSDL: " << data << '\n';

  // Serialize Variable
  ByteArray buffer = var.serialize();
  // ... And send it over network ...
}

{
  usr: [
    { login: "admin" password: "admin" access_lvl: 0xFF_ui8 attributes: [] data: {} }
    { login: "guest" password: "" access_lvl: 0x00_ui8 attributes: [] data: {} }
    { login: "user" password: "any_user_password" access_lvl: 0x7F_ui8 attributes: [] data: {} }
  ]
  
  grp: [
    { name: "SYSTEM" users: [ "admin" "guest" ] usr_attributes: [ "unremovable" "const_access_lvl" ] change_access_lvl: 0xFF_ui8 }
  ]
  
  msg: {
    admin_guest: [
      { from: "admin" to: "guest" content: "Hello, Guest. Please, login with your account." }
    ]
  }
}

$ make tk

$ binomtk cat <file_#1> <file_#2> ... <file_#N>

# path example: name[0]name_1.name_2
$ binomtk pnode <file> <path_to_node_#1> <path_to_node_#2> ... <path_to_node_#N>

$ binomtk mk <file>

$ binomtk edit <file>

$ binomtk build <source-file> <output-file>

$ binomtk convert <old_file> <new_file>

$ binomtk -help [or:-h, --help]

$ binomtk -license [or:-l, --license]

# primitive: 's' - signed int, 'u' - unsigned int, 'h' - hex
# buffer array: 'p' - primitive array, 't' - string (if printable)
$ binomtk -outflag hp
# primitive - hex, buffer array - primitive array