Category: Blog

This project was bootstrapped with Create React App.

Available Scripts

In the project directory, you can run:

`npm start`

Runs the app in the development mode.
Open http://localhost:3000 to view it in the browser.

The page will reload if you make edits.
You will also see any lint errors in the console.

`npm test`

Launches the test runner in the interactive watch mode.
See the section about running tests for more information.

`npm run build`

Builds the app for production to the build folder.
It correctly bundles React in production mode and optimizes the build for the best performance.

The build is minified and the filenames include the hashes.
Your app is ready to be deployed!

See the section about deployment for more information.

`npm run eject`

Note: this is a one-way operation. Once you eject, you can’t go back!

If you aren’t satisfied with the build tool and configuration choices, you can eject at any time. This command will remove the single build dependency from your project.

Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except eject will still work, but they will point to the copied scripts so you can tweak them. At this point you’re on your own.

You don’t have to ever use eject. The curated feature set is suitable for small and middle deployments, and you shouldn’t feel obligated to use this feature. However we understand that this tool wouldn’t be useful if you couldn’t customize it when you are ready for it.

Learn More

You can learn more in the Create React App documentation.

To learn React, check out the React documentation.

🖥 tv-managing-system

System designated to implement in company easy TV display system.
It allows deploy TVs (endpoints) based on linux (e.g. Raspberry Pi) and manage all of them using single pc.

Note

Project created for 100commitow challange.

🔍 Overview

System consists of 3 main parts:

Server – that manages whole system
Endpoint – any display connected to PC
Client – that allows to manage system (change settings etc.)

Main purpose of this system is to allow you to easily setup display system (e.g. in company) and give you user-friendly access to manage it.

Very important is that, this system is opensource, so you can customize it how you want and adapt to your needs.

🕹 Usage

Install server on linux machine that will have access to connect to endpoints and will give access for clients to connect. After installation and configuration you need to allow connections on firewall to server port.

Next step will be deploying endpoints. Follow installation process, and after that you can add your endpoints in server configuration. You can also deploy endpoints on the go (when server is running), but you will need to restart server after changing configuration.

Server and Endpoints are using syslog to write some logs. This allows you to verify if everything is working.

Client allows you to manage system. When server starts you will be able to connect to it using client and change configurations. You need to provide address, port and credentials to connect to server.

All new endpoints will use global configuration if config is not found.

📦 Installation

Server

To install server daemon you need to build and create default config files. To do that just run below command in repo directory:

sudo make clean install

Server do not require any external libraries

If you don’t want to override your configs use (probably temporary solution):

sudo make clean ndinstall

Next important step will be configuration of basic settings – read here

After that you can simply run tmsd.service. Ex:

systemctl start tmsd

You can verify if everything is correctly running in syslog.

To disable daemon just stop service. Ex:

systemctl stop tmsd

Client

Download installer .msi or portable version from Releases.

for installer follow simple installation process (by default client is installed in C:\Program Files (x86)\23vbq\TMSC)
for portable just extract .7z file (dll’s must be in same directory as executable)

If you want to build client by your self you need to download and install Qt, clone repository and open project from CMakeLists.txt.

To deploy your build you can use windeployqt tool which is installed with Qt. It will copy all required libraries to directory with executable. Also you can use AdvancedInstaller template to deploy it in installable package.

Endpoint

To install endpoint application first build it:

sudo make clean install

Required libraries

libx11

Or without overriding your existing config:

sudo make clean ndinstall

Next step will be configuration – read here

After configuring endpoint you can add it to server configuration.

To start endpoint you need to add it to your .xinitrc. If you don’t know how to do this here is xinit configuration. Installed binaries are in /usr/bin by default.

To run endpoint application use:

startx

Required packages

xorg-server
xorg-xinit

For closing endpoint there are two methods:

Kill it from shell (ex. pkill tmse)
Use keyboard shortcut ALT + Q

📜 Description

Server

Linux

Server is responsible for managing the entire system. It’s primary role is to communicate with endpoint to distribute configuration and manage them. The server doesn’t hosts any resources (e.g. images, files). These can be obtained with external solutions like Samba. Server performs various functions including: processing change requests, providing responses to queries, checking the connection with the endpoints, and ensuring that client is always updated with latest configuration.

Server also provides interface to manage configurations, endpoints and server it self with Client application.

Network functions:

Accepts connection from clients and response to their queries
Connects to endpoints and sends data to them

Client

Windows

Client application gives end-user ability to easily manage the system. It provides GUI based communication with server, so it is user-friendly. You can check actual status of endpoints, manage global / per endpoint configuration and reload endpoints settings.

Endpoint

Linux

Endpoint allows to display images on TV (any display connected to machine), using X11 library. Its main advantage is that is written in C++, so it allows to obtain low system requirements. That allows you to make low cost and practical display system (e.g. TV connected to Raspberry Pi). Endpoint program gets settings from server. Files to be displayed are obtained from provided path. To make fully centrally managed system (meaning easy access to files on endpoint) you can setup SMB server, mount it on every endpoint and configure path on tv-managing-system server to this mountpoint.

⚙ Configuration

After configuration you can copy your config files to .def files in repo to not be overridden after installing. In future maybe there will be provided some mechanism to not override your files and easily update configs, if new variables will be required.

Server

Server configuration is stored in /etc/tmsd/. Default settings are stored in def files in repo and are copied to desired location when installing.

Server uses two files for it’s configuration:

settings.cfg – to store basic server socket settings
authkey – to store authentication key for server (now it is stored in plain text – read here])

File settings.cfg stores configuration of basic server socket settings and also list of endpoints, that server needs to connect to.

You need to add your endpoints here.

Name – unique name of endpoint
Ip – address of endpoint
Port – port on that endpoint is listening
AuthKey – key to authenticate connection to that endpoint

In authkey you only need to store your server password (in plain text), that will need be required for clients to connect.

Configuration of each endpoint is stored in /etc/tmsd/epconf/ and is automatically generated by server on changes. By default endpoint configuration is empty struct. Global endpoint configuration is stored in file named [Global Settings].ep.

Important

Names of endpoint configurations are created from their names, so name definied in settings.cfg must be unique

Client

At this point client do not store any settings. Maybe in future it will be able to save IP, certificates etc.

Endpoint

Endpoint configuration is stored in /etc/tmse. Default settings are stored in def files in repo and are copied to desired location when installing.

Endpoint uses two files for it’s configuration:

settings.cfg – to store basic settings
authkey – to store authentication key for server (now it is stored in plain text – read here) NOW IS UNUSED – wait for update

By default endpoint is using feh, but it can be to any image viewer. You can set up any command you want for opening images (through settings.cfg). Opening images is implemented in SlideshowManager::OpenAllImages().

Endpoint do not store major configuration (meaning directory to lookup for images, etc.). It is provided by server when connection occurs. It prevents endpoint from loading old configuration. Endpoint waits for server and then will be able to display desired views. This configuration is stored in EndpointSettings struct in memory.

🔐 Security

At this point of developement all connections are not secured (in plain text). Also passwords are stored in plain text.

It is planned to implement hashed passwords and SSL secured connections.

Caution

Now this project probably doesn’t meet any security standards. (The project was created mainly for learning purposes – maybe in future will be improved)

🛠 Contribution

ToDo list: here

SEGFAULT COUNTER: 9

🖥 tv-managing-system

System designated to implement in company easy TV display system.
It allows deploy TVs (endpoints) based on linux (e.g. Raspberry Pi) and manage all of them using single pc.

Note

Project created for 100commitow challange.

🔍 Overview

System consists of 3 main parts:

Server – that manages whole system
Endpoint – any display connected to PC
Client – that allows to manage system (change settings etc.)

Main purpose of this system is to allow you to easily setup display system (e.g. in company) and give you user-friendly access to manage it.

Very important is that, this system is opensource, so you can customize it how you want and adapt to your needs.

🕹 Usage

Install server on linux machine that will have access to connect to endpoints and will give access for clients to connect. After installation and configuration you need to allow connections on firewall to server port.

Next step will be deploying endpoints. Follow installation process, and after that you can add your endpoints in server configuration. You can also deploy endpoints on the go (when server is running), but you will need to restart server after changing configuration.

Server and Endpoints are using syslog to write some logs. This allows you to verify if everything is working.

Client allows you to manage system. When server starts you will be able to connect to it using client and change configurations. You need to provide address, port and credentials to connect to server.

All new endpoints will use global configuration if config is not found.

📦 Installation

Server

To install server daemon you need to build and create default config files. To do that just run below command in repo directory:

sudo make clean install

Server do not require any external libraries

If you don’t want to override your configs use (probably temporary solution):

sudo make clean ndinstall

Next important step will be configuration of basic settings – read here

After that you can simply run tmsd.service. Ex:

systemctl start tmsd

You can verify if everything is correctly running in syslog.

To disable daemon just stop service. Ex:

systemctl stop tmsd

Client

Download installer .msi or portable version from Releases.

for installer follow simple installation process (by default client is installed in C:\Program Files (x86)\23vbq\TMSC)
for portable just extract .7z file (dll’s must be in same directory as executable)

If you want to build client by your self you need to download and install Qt, clone repository and open project from CMakeLists.txt.

To deploy your build you can use windeployqt tool which is installed with Qt. It will copy all required libraries to directory with executable. Also you can use AdvancedInstaller template to deploy it in installable package.

Endpoint

To install endpoint application first build it:

sudo make clean install

Required libraries

libx11

Or without overriding your existing config:

sudo make clean ndinstall

Next step will be configuration – read here

After configuring endpoint you can add it to server configuration.

To start endpoint you need to add it to your .xinitrc. If you don’t know how to do this here is xinit configuration. Installed binaries are in /usr/bin by default.

To run endpoint application use:

startx

Required packages

xorg-server
xorg-xinit

For closing endpoint there are two methods:

Kill it from shell (ex. pkill tmse)
Use keyboard shortcut ALT + Q

📜 Description

Server

Linux

Server is responsible for managing the entire system. It’s primary role is to communicate with endpoint to distribute configuration and manage them. The server doesn’t hosts any resources (e.g. images, files). These can be obtained with external solutions like Samba. Server performs various functions including: processing change requests, providing responses to queries, checking the connection with the endpoints, and ensuring that client is always updated with latest configuration.

Server also provides interface to manage configurations, endpoints and server it self with Client application.

Network functions:

Accepts connection from clients and response to their queries
Connects to endpoints and sends data to them

Client

Windows

Client application gives end-user ability to easily manage the system. It provides GUI based communication with server, so it is user-friendly. You can check actual status of endpoints, manage global / per endpoint configuration and reload endpoints settings.

Endpoint

Linux

Endpoint allows to display images on TV (any display connected to machine), using X11 library. Its main advantage is that is written in C++, so it allows to obtain low system requirements. That allows you to make low cost and practical display system (e.g. TV connected to Raspberry Pi). Endpoint program gets settings from server. Files to be displayed are obtained from provided path. To make fully centrally managed system (meaning easy access to files on endpoint) you can setup SMB server, mount it on every endpoint and configure path on tv-managing-system server to this mountpoint.

⚙ Configuration

After configuration you can copy your config files to .def files in repo to not be overridden after installing. In future maybe there will be provided some mechanism to not override your files and easily update configs, if new variables will be required.

Server

Server configuration is stored in /etc/tmsd/. Default settings are stored in def files in repo and are copied to desired location when installing.

Server uses two files for it’s configuration:

settings.cfg – to store basic server socket settings
authkey – to store authentication key for server (now it is stored in plain text – read here])

File settings.cfg stores configuration of basic server socket settings and also list of endpoints, that server needs to connect to.

You need to add your endpoints here.

Name – unique name of endpoint
Ip – address of endpoint
Port – port on that endpoint is listening
AuthKey – key to authenticate connection to that endpoint

In authkey you only need to store your server password (in plain text), that will need be required for clients to connect.

Configuration of each endpoint is stored in /etc/tmsd/epconf/ and is automatically generated by server on changes. By default endpoint configuration is empty struct. Global endpoint configuration is stored in file named [Global Settings].ep.

Important

Names of endpoint configurations are created from their names, so name definied in settings.cfg must be unique

Client

At this point client do not store any settings. Maybe in future it will be able to save IP, certificates etc.

Endpoint

Endpoint configuration is stored in /etc/tmse. Default settings are stored in def files in repo and are copied to desired location when installing.

Endpoint uses two files for it’s configuration:

settings.cfg – to store basic settings
authkey – to store authentication key for server (now it is stored in plain text – read here) NOW IS UNUSED – wait for update

By default endpoint is using feh, but it can be to any image viewer. You can set up any command you want for opening images (through settings.cfg). Opening images is implemented in SlideshowManager::OpenAllImages().

Endpoint do not store major configuration (meaning directory to lookup for images, etc.). It is provided by server when connection occurs. It prevents endpoint from loading old configuration. Endpoint waits for server and then will be able to display desired views. This configuration is stored in EndpointSettings struct in memory.

🔐 Security

At this point of developement all connections are not secured (in plain text). Also passwords are stored in plain text.

It is planned to implement hashed passwords and SSL secured connections.

Caution

Now this project probably doesn’t meet any security standards. (The project was created mainly for learning purposes – maybe in future will be improved)

🛠 Contribution

ToDo list: here

SEGFAULT COUNTER: 9

SirensDiscordBot

🇺🇦 Простий бот повітряних тривог для вашого Discord серверу. Ви можете безкошновно створити власного бота та розмістити його на власному віддаленому сервері (наприклад на Oracle Cloud Free Tier) за допомогою цієї інструкції, або використовувати готове рішення на вашому Discord серверу. Бот використовує стороннє API.
🇬🇧 A simple air-raid bot for your Discord server. You can create your own bot for free and place it on your own remote server (e.g. on Oracle Cloud Free Tier) using these instructions, or use a ready-made solution on your Discrod server. Bot uses API.

Для початку

1. Встановити Docker

2. Встановити Docker Compose

3. Копіювати репозиторій.

  $ git clone https://github.com/correaAlex/SirensDiscordBot.git

4. Перейти в репозиторій

  $ cd SirensDiscordBot

5. Змініть ім’я користувача та пароль бази даних в файлах:

docker-compose.yml

  MYSQL_USER: yourUserName
  MYSQL_PASSWORD: yourPassword

App.config

  <add key="ConnectionString" value="server=db;port=3306;user=yourUserName;password=yourPassword;database=sirens_bot"/>

6. Створити Discrod бота

7. Додайте токен свого бота в файл App.config

  <add key="Token" value="YOUR_TOKEN"/>

8. Додайте свого бота до вашого серверу

9. Виконайте команду:

  $ sudo docker-compose up

10. В текстовому каналі вашого серверу виконайте команду `!start` та слідуйте інструкціям

Getting started

1. Install Docker

2. Instal; Docker Compose

3. Copy repository.

  $ git clone https://github.com/correaAlex/SirensDiscordBot.git

4. Move to folder repository

  $ cd SirensDiscordBot

5. Change database settings in files:

docker-compose.yml

  MYSQL_USER: yourUserName
  MYSQL_PASSWORD: yourPassword

App.config

  <add key="ConnectionString" value="server=db;port=3306;user=yourUserName;password=yourPassword;database=sirens_bot"/>

6. Create Discrod bot

7. Add bot token App.config

  <add key="Token" value="YOUR_TOKEN"/>

8. Invite bot to you server

9. Run command:

  $ sudo docker-compose up

10. In text cahnel in you discord server type `!start` and follow instructions

RNode Web API client

This library is a thin layer around RNode HTTP API with helper functions to create, sign and validate deploy, pull deploy result until block is proposed and Ethereum signature support to enable use of Metamask with hardware wallet.

In the browser connection to RNode can be done with RNode Web API.
Web API has defined schema only in Scala source, for the new info please check RChain issue 2974.

For gRPC connection from nodejs please check @tgrospic/rnode-grpc-js.

Example of single page wallet can be found in this repository tgrospic/rnode-client-js.

RNode connection to Metamask (with hardware wallet)

Helper functions are in eth-wrapper.ts which contains the code for communication with Metamask, getting selected ETH address and sending deploys for signing.
In eth-sign.ts are functions to verify deploy signature and to extract public key.
This is all that is needed for communication with Metamask and also for connected hardware wallets (Ledger, Trezor). How to use these functions and send deploys to RNode is in rnode-web.ts.

Install

The package includes TypeScript definitions.

npm install @tgrospic/rnode-http-js

Deprecated

This app is old and not maintained. I leave this repository here, but you are probably better off if you look for a different app.

MindBike Mindmapping

MindBike is a Mindmap viewer and editor. It is still in alpha/beta-state but usable for mindmaps without extra-features. It reads and displays Mindmaps in the Freemind/Freeplane Format (*.mm). Its possible to edit and save the mindmaps in the same format, so they are still compatible with Freemind or Freeplane. It is written in Python + Kivy and thus runs under Android, iOS, Windows, Linux and MacOS – but the main target ist Android. It is the best mindmapping-application for Freeplane and Freemind files on Android to date (though that doesn’t mean much…). Wikipedia links here.

Features

Displaying and Editing of Mindmaps
Fully compatible with Freemind and Freeplane
- Mindbike can’t display or edit notes, icons, node-details and node-attributes. But it will preserve them, so they don’t get lost by opening/saving *.mm-Files
- no rich-text yet. No unicode on Android (should be solved in time)
Collaborative editing: Mindbike can merge two mindmaps easily. If you have two copies of the same map – one on your desktop and one on your smartphone – you can add nodes on both maps and merge them later. After merging you have all the new nodes of both maps in both maps! (No additional software (like Git) required)
Hashtags. Add #hashtags in your node-text to easily access nodes with similar content. Mindbike will generate a #Hashmap that bundles all the nodes with the same #hashtags. Use #hashtag:subtag to build subgroups. This enables an easy GTD (GettingThingsDone) workflow.

Installation

Download

Download APK Please note that the builds aren’t always up-to-date. For now, I only provide packages for Android, sometimes for Windows.

Android

[How to install apk-files on android] (http://pc.answers.com/tablets/how-to-install-third-party-android-apps)

Allow the installation of 3rd-Party Apps (check Settings->Security->”Unknown Sources”)
Copy the *.apk-file to your sd-card or internal memory. (tip: use dropbox over wifi)
Navigate to the apk-file and open it.

Windows

Download the zip-file
Unpack into a new directory
Start Mindbike…..exe (Note that packaging for Windows is still buggy)

From source (For Windows, Linux and MacOS), for advanced Users!

Install Python 2.7
Install Kivy
Check out the latest code via Mercurial or Git and Bitbucket
Run main.py as explained at Kivy

HowTo use MindBike

Double-tap into a node to edit its content
Tap outside to end editing
press the first of the 2 Buttons next to every node (f) to fold/unfold its children
press the second button (+) to add a child-node
On the desktop you can use your keyboard to navigate from node to node and to edit the nodes

Parse command line arguments by defining a struct

Quick Start

#include <structopt/app.hpp>

struct Options {
   // positional argument
   //   e.g., ./main <file>
   std::string config_file;

   // optional argument
   //   e.g., -b "192.168.5.3"
   //   e.g., --bind_address "192.168.5.3"
   //
   // options can be delimited with `=` or `:`
   // note: single dash (`-`) is enough for short & long option
   //   e.g., -bind_address=localhost
   //   e.g., -b:192.168.5.3
   //
   // the long option can also be provided in kebab case:
   //   e.g., --bind-address 192.168.5.3
   std::optional<std::string> bind_address;
 
   // flag argument
   // Use `std::optional<bool>` and provide a default value. 
   //   e.g., -v
   //   e.g., --verbose
   //   e.g., -verbose
   std::optional<bool> verbose = false;

   // directly define and use enum classes to limit user choice
   //   e.g., --log-level debug
   //   e.g., -l error
   enum class LogLevel { debug, info, warn, error, critical };
   std::optional<LogLevel> log_level = LogLevel::info;

   // pair argument
   // e.g., -u <first> <second>
   // e.g., --user <first> <second>
   std::optional<std::pair<std::string, std::string>> user;

   // use containers like std::vector
   // to collect "remaining arguments" into a list
   std::vector<std::string> files;
};
STRUCTOPT(Options, config_file, bind_address, verbose, log_level, user, files);

Create a structopt::app and parse the command line arguments into the Options struct:

int main(int argc, char *argv[]) {

  try {
  
    // Line of code that does all the work:
    auto options = structopt::app("my_app").parse<Options>(argc, argv);

    // Print out parsed arguments:

    // std::cout << "config_file  = " << options.config_file << "\n";
    // std::cout << "bind_address = " << options.bind_address.value_or("not provided") << "\n";
    // std::cout << "verbose      = " << std::boolalpha << options.verbose.value() << "\n";
    // ...

  } catch (structopt::exception& e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

Now let’s pass some arguments to this program:

foo@bar:~$ ./main config.csv file5.csv file6.json
config_file  = config.csv
bind_address = not provided
verbose      = false
log_level    = 1
user         = not provided
files        = { file5.csv file6.json }

foo@bar:~$ ./main config.csv --bind-address localhost:9000 -v -log-level error file1.txt file2.txt
config_file  = config.csv
bind_address = localhost:9000
verbose      = true
log_level    = 3
user         = not provided
files        = { file1.txt file2.txt }

foo@bar:~$ ./main config_2.csv --bind-address 192.168.7.3 -log-level debug file1.txt file3.txt file4.txt --user "John Doe" "john.doe@foo.com"
config_file  = config_2.csv
bind_address = 192.168.7.3
verbose      = false
log_level    = 0
user         = John Doe<john.doe@foo.com>
files        = { file1.txt file3.txt file4.txt }

Getting Started

structopt is a header-only library. Just add include/ to your include_directories and you should be good to go. A single header file version is also available in single_include/.

Positional Arguments

Here’s an example of two positional arguments: input_file and output_file. input_file is expected to be the first argument and output_file is expected to be the second argument

#include <structopt/app.hpp>

struct FileOptions {
  // Positional arguments
  // ./main <input_file> <output_file>
  std::string input_file;
  std::string output_file;
};
STRUCTOPT(FileOptions, input_file, output_file);



int main(int argc, char *argv[]) {

  try {
    auto options = structopt::app("my_app").parse<FileOptions>(argc, argv);

    // Print parsed arguments:
    std::cout << "\nInput file  : " << options.input_file << "\n";
    std::cout << "Output file : " << options.output_file << "\n";

  } catch (structopt::exception& e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

foo@bar:~$ ./main foo.txt bar.csv

Input file  : foo.txt
Output file : bar.csv

foo@bar:~$ ./main foo.csv
Error: expected value for positional argument `output_file`.

USAGE: ./my_app input_file output_file

ARGS:
    input_file
    output_file

Optional Arguments

Now, let’s look at optional arguments. To configure an optional argument, use std::optional in the options struct like below.

#include <structopt/app.hpp>

struct GccOptions {
  // language standard
  // e.g., -std=c++17
  // e.g., --std c++20
  std::optional<std::string> std = "c++11";

  // verbosity enabled with `-v` or `--verbose`
  // or `-verbose`
  std::optional<bool> verbose = false;

  // enable all warnings with `-Wall`
  std::optional<bool> Wall = false;

  // produce only the compiled code
  // e.g., gcc -C main.c
  std::optional<bool> Compile = false;

  // produce output with `-o <exec_name>`
  std::optional<std::string> output = "a.out";

  std::string input_file;
};
STRUCTOPT(GccOptions, std, verbose, Wall, Compile, output, input_file);


int main(int argc, char *argv[]) {
  try {
    auto options = structopt::app("gcc").parse<GccOptions>(argc, argv);

    // Print parsed arguments

    std::cout << "std        : " << options.std.value() << "\n";
    std::cout << "verbose    : " << std::boolalpha << options.verbose.value() << "\n";
    std::cout << "Wall       : " << std::boolalpha << options.Wall.value() << "\n";
    std::cout << "Compile    : " << std::boolalpha << options.Compile.value() << "\n";
    std::cout << "Output     : " << options.output.value() << "\n";
    std::cout << "Input file : " << options.input_file << "\n";
  } catch (structopt::exception &e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

NOTE structopt supports two option delimiters, = and : for optional arguments. This is meaningful and commonly used in single-valued optional arguments, e.g., --std=c++17.

foo@bar:~$ ./main -C main.cpp
std        : c++11
verbose    : false
Wall       : false
Compile    : true
Output     : a.out
Input file : main.cpp

foo@bar:~$ ./main -std=c++17 -o main main.cpp
std        : c++17
verbose    : false
Wall       : false
Compile    : false
Output     : main
Input file : main.cpp

foo@bar:~$ ./main main.cpp -v -std:c++14 --output:main -Wall
std        : c++14
verbose    : true
Wall       : true
Compile    : false
Output     : main
Input file : main.cpp

NOTE In summary, for a field in your struct named bind_address, the following are all legal ways to provide a value:

Short form:
- -b <value>
Long form:
- --bind_address <value>
- -bind_address <value>
Kebab case:
- --bind-address <value>
- -bind-address <value>
Equal ('=') option delimiter
- -b=<value>
- --bind_address=<value>
- -bind_address=<value>
- --bind-address=<value>
- -bind-address=<value>
Colon ':' option delimiter
- -b:<value>
- --bind_address:<value>
- -bind_address:<value>
- --bind-address:<value>
- -bind-address:<value>

Double dash (`--`) Argument

A double dash (--) is used in most bash built-in commands and many other commands to signify the end of command options, after which only positional parameters are accepted.

Example use: lets say you want to grep a file for the string -v – normally -v will be considered the option to reverse the matching meaning (only show lines that do not match), but with -- you can grep for string -v like this:

#include <structopt/app.hpp>

struct GrepOptions {
  // reverse the matching
  // enable with `-v`
  std::optional<bool> v = false;
  
  // positional arguments
  std::string search;
  std::string pathspec;
};
STRUCTOPT(GrepOptions, v, search, pathspec);



int main(int argc, char *argv[]) {

  try {
    auto options = structopt::app("my_app").parse<GrepOptions>(argc, argv);

    if (options.v == true) {
      std::cout << "`-v` provided - Matching is now reversed\n";
    }

    std::cout << "Search   : " << options.search << "\n";
    std::cout << "Pathspec : " << options.pathspec << "\n";
  }
  catch (structopt::exception& e) {
    std::cout << e.what();
    std::cout << e.help();
  }

}

foo@bar:~$ ./main -v foo bar.txt
`-v` provided - Matching is now reversed
Search   : foo
Pathspec : bar.txt

foo@bar:~$ ./main -- -v bar.txt
Search   : -v
Pathspec : bar.txt

Flag Arguments

Flag arguments are std::optional<bool> with a default value.

NOTE The default value here is important. It is not a flag if a default value isn’t provided. It will simply be an optional argument.

NOTE If --verbose is a flag argument with a default value of false, then providing the argument will set it to true. If --verbose does not have a default value, then structopt will expect the user to provide a value, e.g., --verbose true.

#include <structopt/app.hpp>

struct Options {
  // verbosity flag
  // -v, --verbose
  // remember to provide a default value
  std::optional<bool> verbose = false;
};
STRUCTOPT(Options, verbose);



int main(int argc, char *argv[]) {
  auto options = structopt::app("my_app").parse<Options>(argc, argv);

  if (options.verbose == true) {
    std::cout << "Verbosity enabled\n";
  }
}

foo@bar:~$ ./main

foo@bar:~$ ./main -v
Verbosity enabled

foo@bar:~$ ./main --verbose
Verbosity enabled

Enum Class Arguments

Thanks to magic_enum, structopt supports enum classes. You can use an enum classes to ask the user to provide a value given a choice of values, restricting the possible set of allowed input arguments.

#include <structopt/app.hpp>

struct StyleOptions {
  enum class Color {red, green, blue};

  // e.g., `--color red`
  std::optional<Color> color = Color::red;
};
STRUCTOPT(StyleOptions, color);



int main(int argc, char *argv[]) {

  try {
    auto options = structopt::app("my_app").parse<StyleOptions>(argc, argv);

    // Use parsed argument `options.color`

    if (options.color == StyleOptions::Color::red) {
        std::cout << "#ff0000\n";
    }
    else if (options.color == StyleOptions::Color::blue) {
        std::cout << "#0000ff\n";
    }
    else if (options.color == StyleOptions::Color::green) {
        std::cout << "#00ff00\n";
    }

  } catch (structopt::exception& e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

foo@bar:~$ ./main --color red
#ff0000

foo@bar:~$ ./main -c blue
#0000ff

foo@bar:~$ ./main --color green
#00ff00

foo@bar:~$ ./main -c black
Error: unexpected input `black` provided for enum argument `color`. Allowed values are {red, green, blue}

USAGE: ./my_app [OPTIONS]

OPTIONS:
    -c, --color <color>

Tuple Arguments

Now that we’ve looked at enum class support, let’s build a simple calculator. In this sample, we will use an std::tuple to pack all the arguments to the calculator:

#include <structopt/app.hpp>

struct CalculatorOptions {

  // types of operations supported
  enum class operation { add, subtract, multiply, divide };

  // single tuple positional argument
  std::tuple<operation, int, int> input;

};
STRUCTOPT(CalculatorOptions, input);



int main(int argc, char *argv[]) {

  try {
    auto options = structopt::app("my_app").parse<CalculatorOptions>(argc, argv);

    auto op = std::get<0>(options.input);
    auto lhs = std::get<1>(options.input);
    auto rhs = std::get<2>(options.input);
    switch(op)
    {
        case CalculatorOptions::operation::add:
            std::cout << lhs + rhs << "\n";
            break;
        case CalculatorOptions::operation::subtract:
            std::cout << lhs - rhs << "\n";
            break;
        case CalculatorOptions::operation::multiply:
            std::cout << lhs * rhs << "\n";
            break;
        case CalculatorOptions::operation::divide:
            std::cout << lhs / rhs << "\n";
            break;
    }
  }
  catch (structopt::exception& e) {
    std::cout << e.what();
    std::cout << e.help();
  }

}

foo@bar:~$ ./main add 1 2
3

foo@bar:~$ ./main subtract 5 9
-4

foo@bar:~$ ./main multiply 16 5
80

foo@bar:~$ ./main divide 1331 11
121

foo@bar:~$ ./main add 5
Error: failed to correctly parse tuple `input`. Expected 3 arguments, 2 provided.

USAGE: my_app input

ARGS:
    input

Vector Arguments

structopt supports gathering “remaining” arguments at the end of the command, e.g., for use in a compiler:

$ compiler file1 file2 file3

Do this by using an std::vector<T> (or other STL containers with .push_back(), e.g, std::deque or std::list).

NOTE Vector arguments have a cardinality of 0..*, i.e., zero or more arguments. Unlike array types, you can provide zero arguments to a vector and structopt will (try to) not complain.

#include <structopt/app.hpp>

struct CompilerOptions {
  // Language standard
  // e.g., --std c++17
  std::optional<std::string> std;

  // remaining arguments
  // e.g., ./compiler file1 file2 file3
  std::vector<std::string> files{};
};
STRUCTOPT(CompilerOptions, std, files);



int main(int argc, char *argv[]) {
  try {
    auto options = structopt::app("my_app").parse<CompilerOptions>(argc, argv);

    std::cout << "Standard : " << options.std.value_or("not provided") << "\n";
    std::cout << "Files    : { ";
    std::copy(options.files.begin(), options.files.end(),
              std::ostream_iterator<std::string>(std::cout, " "));
    std::cout << "}" << std::endl;
  } catch (structopt::exception &e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

NOTE Notice below that the act of gathering remaining arguments is arrested as soon as an optional argument is detected. See the output of ./main file1.cpp file2.cpp --std c++17 below. Notice that --std=c++17 is not part of the vector. This is because --std is a valid optional argument.

foo@bar:~$ ./main
Standard : not provided
Files    : { }

foo@bar:~$ ./main file1.cpp file2.cpp
Standard : not provided
Files    : { file1.cpp file2.cpp }

foo@bar:~$ ./main file1.cpp file2.cpp --std=c++17
Standard : c++17
Files    : { file1.cpp file2.cpp }

foo@bar:~$ ./main --std:c++20 file1.cpp file2.cpp
Standard : c++20
Files    : { file1.cpp file2.cpp }

Compound Arguments

Compound arguments are optional arguments that are combined and provided as a single argument. Example: ps -aux

#include <structopt/app.hpp>

struct Options {
  // Flag arguments
  std::optional<bool> a = false;
  std::optional<bool> b = false;

  // Optional argument
  // e.g., -c 1.1 2.2
  std::optional<std::array<float, 2>> c = {};
};
STRUCTOPT(Options, a, b, c);



int main(int argc, char *argv[]) {
  try {
    auto options = structopt::app("my_app").parse<Options>(argc, argv);

    // Print parsed arguments:

    std::cout << std::boolalpha << "a = " << options.a.value()
              << ", b = " << options.b.value() << "\n";
    if (options.c.has_value()) {
      std::cout << "c = [" << options.c.value()[0] << ", " << options.c.value()[1]
                << "]\n";
    }
  } catch (structopt::exception &e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

foo@bar:~$ ./main -ac 3.14 2.718
a = true, b = false
c = [3.14, 2.718]

foo@bar:~$ ./main -ba
a = true, b = true

foo@bar:~$ ./main -c 1.5 3.0 -ab
a = true, b = true
c = [1.5, 3]

Parsing Numbers

Integer Literals

structopt supports parsing integer literals including hexadecimal, octal, and binary notation.

#include <structopt/app.hpp>

struct IntegerLiterals {
  std::vector<int> numbers;
};
STRUCTOPT(IntegerLiterals, numbers);

int main(int argc, char *argv[]) {
  try {
    auto options = structopt::app("my_app").parse<IntegerLiterals>(argc, argv);

    for (auto &n : options.numbers)
      std::cout << n << "\n";
  } catch (structopt::exception &e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

foo@bar:~$ ./main 1 0x5B 071 0b0101 -35 +98
1
91
57
5
-35
98

Floating point Literals

As for floating point numbers, structopt supports parsing scientific notation (e/E-notation):

#include <structopt/app.hpp>

struct FloatLiterals {
  std::vector<float> numbers;
};
STRUCTOPT(FloatLiterals, numbers);

int main(int argc, char *argv[]) {
  try {
    auto options = structopt::app("my_app").parse<FloatLiterals>(argc, argv);

    for (auto &n : options.numbers)
      std::cout << n << "\n";
  } catch (structopt::exception &e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

foo@bar:~$ ./main -3.15 +2.717 2E-4 0.1e2 .5 -.3 +5.999
-3.15
2.717
0.0002
10
0.5
-0.3
5.999

Nested Structures

With structopt, you can define sub-commands, e.g., git init args or git config [flags] args using nested structures.

Simply create a nested structure that inherits from structopt::sub_command
You can use <nested_struct_object>.has_value() to check if it has been invoked.

The following program support two sub-commands: config and init:

#include <structopt/app.hpp>

struct Git {
  // Subcommand: git config
  struct Config : structopt::sub_command {
    // flag argument `--global`
    std::optional<bool> global = false;

    // key-value pair, e.g., `user.name "John Doe"`
    std::array<std::string, 2> name_value_pair{};
  };
  Config config;

  // Subcommand: git init
  struct Init : structopt::sub_command {

    // required argument
    // repository name
    std::string name;
  };
  Init init;
};
STRUCTOPT(Git::Config, global, name_value_pair);
STRUCTOPT(Git::Init, name);
STRUCTOPT(Git, config, init);



int main(int argc, char *argv[]) {


  try {
    auto options = structopt::app("my_app").parse<Git>(argc, argv);

    if (options.config.has_value()) {
      // config was invoked
      std::cout << "You invoked `git config`:\n";
      std::cout << "Global : " << std::boolalpha << options.config.global.value() << "\n";
      std::cout << "Input  : (" << options.config.name_value_pair[0] << ", " << options.config.name_value_pair[1] << ")\n";
    }
    else if (options.init.has_value()) {
      // init was invoked
      std::cout << "You invoked `git init`:\n";
      std::cout << "Repository name : " << options.init.name << "\n";
    }


  } catch (structopt::exception& e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

foo@bar:~$ ./main config user.email "john.doe@foo.com"
You invoked `git config`:
Global : false
Input  : (user.email, john.doe@foo.com)

foo@bar:~$ ./main config user.name "John Doe" --global
You invoked `git config`:
Global : true
Input  : (user.name, John Doe)

foo@bar:~$ ./main init my_repo
You invoked `git init`:
Repository name : my_repo



foo@bar:~$ ./main -h

USAGE: my_app [OPTIONS] [SUBCOMMANDS]

OPTIONS:
    -h, --help <help>
    -v, --version <version>

SUBCOMMANDS:
    config
    init




foo@bar:~$ ./main config -h

USAGE: config [FLAGS] [OPTIONS] name_value_pair

FLAGS:
    -g, --global

OPTIONS:
    -h, --help <help>
    -v, --version <version>

ARGS:
    name_value_pair




foo@bar:~$ ./main init -h

USAGE: init [OPTIONS] name

OPTIONS:
    -h, --help <help>
    -v, --version <version>

ARGS:
    name

NOTE Notice in the above stdout that the -h help option supports printing help both at the top-level struct and at the sub-command level.

NOTE structopt does not allow to invoke multiple sub-commands. If one has already been invoked, you will see the following error:

foo@bar:~$ ./main config user.name "John Doe" init my_repo
Error: failed to invoke sub-command `init` because a different sub-command, `config`, has already been invoked.

Sub-Commands, Vector Arguments, and Delimited Positional Arguments

Here’s a second example for nested structures with vector arguments and the double dash (--) delimiter

#include <structopt/app.hpp>

struct CommandOptions {
  struct Sed : structopt::sub_command {
    // --trace
    std::optional<bool> trace = false;

    // remaining args
    std::vector<std::string> args;

    // pattern
    std::string pattern;

    // file
    std::string file;
  };
  Sed sed;
};
STRUCTOPT(CommandOptions::Sed, trace, args, pattern, file);
STRUCTOPT(CommandOptions, sed);



int main(int argc, char *argv[]) {

  auto app = structopt::app("my_app");

  try {

    auto options = app.parse<CommandOptions>(argc, argv);

    if (options.sed.has_value()) {
      // sed has been invoked

      if (options.sed.trace == true) {
        std::cout << "Trace enabled!\n";
      }

      std::cout << "Args    : ";
      for (auto& a : options.sed.args) std::cout << a << " "; 
      std::cout << "\n";
      std::cout << "Pattern : " << options.sed.pattern << "\n";
      std::cout << "File    : " << options.sed.file << "\n";
    }
    else {
      std::cout << app.help();
    }

  } catch (structopt::exception &e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

foo@bar:~$ ./main

USAGE: my_app [OPTIONS] [SUBCOMMANDS]

OPTIONS:
    -h, --help <help>
    -v, --version <version>

SUBCOMMANDS:
    sed



foo@bar:~$ ./main sed --trace X=1 Y=2 Z=3 -- 's/foo/bar/g' foo.txt
Trace enabled!
Args    : X=1 Y=2 Z=3
Pattern : s/foo/bar/g
File    : foo.txt

Printing Help

structopt will insert two optional arguments for the user: help and version.

Using -h or --help will print the help message and exit.
Using -v or --version will print the program version and exit.

#include <structopt/app.hpp>

struct Options {
  // positional arguments
  std::string input_file;
  std::string output_file;

  // optional arguments
  std::optional<std::string> bind_address;

  // remaining arguments
  std::vector<std::string> files;
};
STRUCTOPT(Options, input_file, output_file, bind_address, files);



int main(int argc, char *argv[]) {
  auto options = structopt::app("my_app", "1.0.3").parse<Options>(argc, argv);
}

foo@bar:~$ ./main -h

USAGE: my_app [OPTIONS] input_file output_file files

OPTIONS:
    -b, --bind-address <bind_address>
    -h, --help <help>
    -v, --version <version>

ARGS:
    input_file
    output_file
    files

foo@bar:~$ ./main -v
1.0.3

Printing CUSTOM Help

structopt allows users to provide a custom help messages. Simply pass in your custom help as a string argument to structopt::app

#include <structopt/app.hpp>

struct Options {
  // positional arguments
  std::string input_file;
  std::string output_file;

  // optional arguments
  std::optional<std::string> bind_address;

  // remaining arguments
  std::vector<std::string> files;
};
STRUCTOPT(Options, input_file, output_file, bind_address, files);

int main(int argc, char *argv[]) {

  try {
    const std::string& custom_help = "Usage: ./my_app input_file output_file [--bind-address BIND_ADDRESS] [files...]\n";
    auto options = structopt::app("my_app", "1.0.3", custom_help).parse<Options>(argc, argv);
  } catch (structopt::exception &e) {
    std::cout << e.what() << "\n";
    std::cout << e.help();
  }
}

foo@bar:~$ ./main -h
Usage: ./my_app input_file output_file [--bind-address BIND_ADDRESS] [files...]

Building Samples and Tests

git clone https://github.com/p-ranav/structopt
cd structopt
mkdir build && cd build
cmake -DSTRUCTOPT_SAMPLES=ON -DSTRUCTOPT_TESTS=ON ..
make

WinLibs + MinGW

For Windows, if you use WinLibs like I do, the cmake command would look like this:

foo@bar:~$ mkdir build && cd build
foo@bar:~$ cmake -G "MinGW Makefiles" -DCMAKE_CXX_COMPILER="C:/WinLibs/mingw64/bin/g++.exe" -DSTRUCTOPT_SAMPLES=ON -DSTRUCTOPT_TESTS=ON ..
foo@bar:~$ make

foo@bar:~$ .\tests\structopt_tests.exe
[doctest] doctest version is "2.3.5"
[doctest] run with "--help" for options
===============================================================================
[doctest] test cases:     54 |     54 passed |      0 failed |      0 skipped
[doctest] assertions:    393 |    393 passed |      0 failed |
[doctest] Status: SUCCESS!

Compiler Compatibility

Clang/LLVM >= 5
MSVC++ >= 14.11 / Visual Studio >= 2017
Xcode >= 10
GCC >= 9

Generating Single Header

python3 utils/amalgamate/amalgamate.py -c single_include.json -s .

Contributing

Contributions are welcome, have a look at the CONTRIBUTING.md document for more information.

License

The project is available under the MIT license.

React-Weather

React-Weather is a user-friendly weather application built using React, React-Router, Redux, and powered by LocationIQ and RESTCountries APIs. This documentation will guide you through the app’s features, technologies, setup, and usage.

Features

Weather Information: Get current weather details, temperature, humidity, wind speed, and conditions for a specified location.
Location Autocomplete: Utilize LocationIQ API for location autocomplete and efficient search functionality.
Country Information: Display country information using RESTCountries API based on the user’s location.
Responsive Design: Enjoy a seamless experience on both desktop and mobile devices.
State Management: Leverage Redux for state management, ensuring a smooth and synchronized user experience.

Technologies Used

React: A JavaScript library for building user interfaces, offering reusable components and dynamic rendering.
React-Router: A routing library for React, enabling efficient navigation and URL handling.
Redux: A state management library, centralizing and synchronizing data across the app.
LocationIQ API: Access geolocation data, location details, and autocomplete suggestions.
RESTCountries API: Retrieve country information and details.
React-Bootstrap: Styling with CSS for a visually appealing and responsive design.

Run Locally

Clone the project

  git clone https://github.com/hsyntes/react-weather

Go to the project directory

  cd react-weather

Install dependencies

  npm install

Start the server

  npm start

Credits

Location data provided by LocationIQ API.
Country information provided by RESTCountries API.

Thank you for using the React-Weather app! Feel free to explore the source code, contribute, and enhance your weather experience using this intuitive React application.

Category: Blog

Available Scripts

npm start

npm test

npm run build

npm run eject

Learn More

Code Splitting

Analyzing the Bundle Size

Making a Progressive Web App

Advanced Configuration

Deployment

npm run build fails to minify

🖥 tv-managing-system

🔍 Overview

🕹 Usage

📦 Installation

Server

Client

Endpoint

📜 Description

Server

Client

Endpoint

⚙ Configuration

Server

Client

Endpoint

🔐 Security

🛠 Contribution

🖥 tv-managing-system

🔍 Overview

🕹 Usage

📦 Installation

Server

Client

Endpoint

📜 Description

Server

Client

Endpoint

⚙ Configuration

Server

Client

Endpoint

🔐 Security

🛠 Contribution

SirensDiscordBot

Для початку

1. Встановити Docker

2. Встановити Docker Compose

3. Копіювати репозиторій.

4. Перейти в репозиторій

5. Змініть ім’я користувача та пароль бази даних в файлах:

6. Створити Discrod бота

7. Додайте токен свого бота в файл App.config

8. Додайте свого бота до вашого серверу

9. Виконайте команду:

10. В текстовому каналі вашого серверу виконайте команду !start та слідуйте інструкціям

Getting started

1. Install Docker

2. Instal; Docker Compose

3. Copy repository.

4. Move to folder repository

5. Change database settings in files:

6. Create Discrod bot

7. Add bot token App.config

8. Invite bot to you server

9. Run command:

10. In text cahnel in you discord server type !start and follow instructions

RNode Web API client

RNode connection to Metamask (with hardware wallet)

Install

Deprecated

MindBike Mindmapping

Features

Installation

Download

Android

Windows

`npm start`

`npm test`

`npm run build`

`npm run eject`

`npm run build` fails to minify

10. В текстовому каналі вашого серверу виконайте команду `!start` та слідуйте інструкціям

10. In text cahnel in you discord server type `!start` and follow instructions

Double dash (`--`) Argument