Convert from CSV file to “JSON file” of “TFDMemTable format”.

This program uses C++Builder 10.2 Tokyo Release 1.

include

#include <iostream>
#include <fstream>
#include <string>
#include <codecvt>
#include <FireDAC.Comp.Client.hpp>
#include <FireDAC.Stan.StorageJSON.hpp>
#include <FireDAC.Stan.Intf.hpp>
#include <memory>
#include <vector>
#include <sstream>
#include <mutex>
#include <thread>
#include <chrono>

code

struct _Tcsv_to_memtable
{
    std::mutex mx_;
    std::vector<std::thread> vth_;
    std::unique_ptr<TFDMemTable> mem_table_{std::make_unique<TFDMemTable>(nullptr)};
    std::unique_ptr<TFDStanStorageJSONLink> jl_{std::make_unique<TFDStanStorageJSONLink>(nullptr)};
    void create_column(std::vector<String>& v)
    {
        //Field creation of "TFDMemTable"
        //The field name is the first line of CSV File
        for (auto s: v)
        {
            auto fld = mem_table_->FieldDefs->AddFieldDef();
            //Discard the "BOM (Byte Order Mark)" if present.
            fld->Name = StringReplace(s, L'\x0feff', "", TReplaceFlags());
            fld->DataType = TFieldType::ftWideString;
        }
        mem_table_->Active = true;
    }
    void create_line(std::vector<String>& v)
    {
        //Add 1 line of "CSV File" to "TFDMemTable"
        int i{0};
        mem_table_->Append();
        for (auto s: v)
        {
            //One item for one field.
            mem_table_->Fields->operator[](i)->AsWideString = s;
            ++i;
        }
        mem_table_->Post();
    }
    void create_line(std::wstring ws, int line_num)
    {
        std::lock_guard<std::mutex> lk(mx_);
        if (ws.length() > 0)
        {
            //Inserted by dividing one line of CSV File to vector<String>.
            std::vector<String> v1;
            std::wstring column_data;
            std::wistringstream line_data(ws);
            while (std::getline(line_data, column_data, L','))
            {
                v1.push_back(column_data.c_str());
            }
            switch (line_num)
            {
            case 0:
                create_column(v1);
                break;
            default:
                create_line(v1);
            }
        }

    }
    void threads_join()
    {
        //Wait for the termination of all threads.
        for (auto& th: vth_)
        {
            th.join();
        }
    }

};
int _tmain(int argc, _TCHAR* argv[])
{
    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
    _Tcsv_to_memtable memtable_;
    UnicodeString argv_     = argv[1];  //Specify CSV Fire for input.
    UnicodeString arg_o_    = argv[2];  //JSON output destination specification made with "TFDMemTable".
    if (FileExists(argv_))
    {
        std::wfstream file_;
        file_.open(argv_.w_str(), std::ios::in);
        //The CSV file is utf8 format.
        file_.imbue(std::locale(std::locale::empty(), new std::codecvt_utf8<wchar_t>));

        std::wstring buff;
        int line_num_{0};
        while (std::getline(file_, buff))
        {
            //The append processing to "TFDMemTable" threads line by line.
            memtable_.vth_.push_back(std::thread([&memtable_, &buff, line_num_](){
                memtable_.create_line(buff, line_num_);
                }));
            //Since the command line is multibyte, AnsiString conversion is done.
            AnsiString as_ = buff.c_str();
            std::cout << as_ << std::endl;
            ++line_num_;
        }

        memtable_.threads_join();
        //Finally, save the TFDMemTable contents as a JSON file.
        memtable_.mem_table_->SaveToFile(arg_o_, TFDStorageFormat::sfJSON);

    }
    auto keika =  std::chrono::system_clock::now() - now;
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(keika).count();
    std::cout << " millisecond." << std::endl ;
    return 0;
}

There is a project file in github, you can try it right away.
GitHub - mojeld/csvfstream_to_TFDMemTable: Create json file of TFDMemTable format from CSV file.

f:id:mojeld:20170901174729p:plain

RAD Server is a turn-key application foundation for rapidly building and deploying services based applications. RAD Server enables developers to quickly build new application back-ends or migrate existing Delphi or C++ client/server business logic to a modern services based architecture that is open, stateless, secure and scalable. RAD Server is easy to develop, deploy and operate making it ideally suited for ISVs and OEMs building re-deployable solutions. RAD Server allows you to take your existing code and convert it to REST API endpoints.

Solution Name: RAD Server Hospitality Survey Application

Industry: Hospitality: Restaurants, Hotels etc.

Solution Overview: The RAD Server hospitality sample application includes a mobile client application for collecting survey data, a back-end server to store data and administer surveys and a web client for viewing survey results. The solution includes RAD Server multi-tenancy support for managing surveys from multiple restaurants.

How to download: Available through GetIt (Tools > GetIt Package Manager > Industry Templates) in RAD Studio 10.2.

Setup Instructions: We have a detailed document with setup instructions for the sample project. Download the PDF here.

Overview:

The industry template consists of four different projects that interconnect with each other. The projects are:

Hospitality Survey Setup
Hospitality Survey EMS
Hospitality Survey Admin
Hospitality Survey Client

1) Hospitality Survey Setup app

This app will help you set up your database, the tables and data, and your RAD Server EMS user accounts.

2) Hospitality Survey EMS

This is the RAD Server side REST resource which both the Hospitality Survey Client and the Hospitality Survey Admin interface with. It should be deployable on Windows and Linux through IIS, Apache, or the standalone EMS server.

3) Hospitality Survey Client

This is a RAD Studio client application for Android, iOS, macOS and Windows. The client application should allow you to select a tenant from your RAD Server and then log in as a user. Once logged in, it will download the survey data for your current tenant and allow the survey to be filled out. Once the survey is complete it can be submitted back to the server and a new survey can be started.

4) The Hospitality Survey Admin app

This is an AngularJS application for the web. You can log into the application with your Tenant ID and RAD Server user ID. The web app allows you to view statistics and graphs about the results of the survey questions and each individual question and answer. You can also export a list of emails collected from the surveys.

[DownloadButton Product='RAD' Caption='Download a RAD Studio 10.2 Trial today!']

Add MPVolumeView to the main form Class

Add “_di_MPVolumeView” and “_di_UISlider” to the form class.

class TForm1 : public TForm { __published: // IDE-managed Components TButton *Button1; TLayout *Layout1; TButton *Button2; void __fastcall Button1Click(TObject *Sender); void __fastcall Button2Click(TObject *Sender); private: // User declarations _di_MPVolumeView MPVolumeView1; _di_UISlider slider1; public: // User declarations __fastcall TForm1(TComponent* Owner); };

Main Form constructor

__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner) { //Use "TMPVolumeView" to create "_di_MPVolumeView". MPVolumeView1 = TMPVolumeView::Create(); for (int i = 0; i < MPVolumeView1->subviews()->count(); i++) { switch (i) { case 0: //Setting the _di_UISlider in the "MPVolumeView1". slider1 = TUISlider::Wrap(MPVolumeView1->subviews()->objectAtIndex(i)); //Set the slider to 0.0. slider1->setValue(0.0); } } }

struct T_thread_proc : TCppInterfacedObject<TProc>{ TNotifyEvent f_ev_; struct T_sync_proc : TCppInterfacedObject<TThreadProcedure>{ TNotifyEvent f_ev_; T_sync_proc(TNotifyEvent& ev2){ f_ev_ = ev2; } virtual void __fastcall Invoke() { //Inside Synchronize. f_ev_(NULL); //Execute "TNotifyEvent". } }; T_thread_proc(TNotifyEvent ev1){f_ev_ = ev1; } virtual void __fastcall Invoke() { //Write thread execution code here. Sleep(3000); //example //Finally call Synchronize. TThread::Synchronize( TThread::CurrentThread,_di_TThreadProcedure(new T_sync_proc(f_ev_))); } };

void __fastcall TForm1::do_thread_event(TObject *Sender) { Button1->Enabled = true; ActivityIndicator1->Visible = false; ActivityIndicator1->Animate = false; Caption = "End CreateAnonymousThread"; }

Call TThread::CreateAnonymousThread() with a TButton event.

void __fastcall TForm1::Button1Click(TObject *Sender) { TThread::CreateAnonymousThread(_di_TProc( new T_thread_proc(&do_thread_event)))->Start(); Caption = "Started CreateAnonymousThread"; ActivityIndicator1->Visible = true; ActivityIndicator1->Animate = true; Button1->Enabled = false; }

type Tproc_func = record {When TFunc is an argument as shown below. } function func1(func: TFunc<Integer, String>):String; end; implementation function Tproc_func.func1(func: TFunc<Integer, String>): String; begin Result := func(CurrentYear); end;

#include <sstream> template<typename T1, typename T2> struct T_func1 : TCppInterfacedObject<TFunc__2<T1,T2> > { String __fastcall to_string(int i) { std::stringstream lss; lss << i; return lss.str().c_str(); } T2 __fastcall Invoke(T1 i) { //Write the code you want to pass to TFunc__2 here. return static_cast<T2>("Delphi was released in " + to_string(i - 22) + " for the first edition."); } };