366 lines
14 KiB
C++
366 lines
14 KiB
C++
// ------------------------------------------------------------------------- //
|
|
|
|
#include "tdm_reaper.hpp"
|
|
|
|
#include <filesystem>
|
|
#include <regex>
|
|
#include <thread>
|
|
#include <chrono>
|
|
|
|
// ------------------------------------------------------------------------- //
|
|
|
|
const std::string gittag("TAGSTRING");
|
|
const std::string githash("HASHSTRING");
|
|
|
|
void show_usage()
|
|
{
|
|
std::cout<<"\n"
|
|
<<"tdmreaper ["<<gittag<<"-g"<<githash<<"] (github.com/RecordEvolution/tdm_ripper.git)"
|
|
<<"\n\n"
|
|
<<"Decode TDM/TDX files and dump data as *.csv"
|
|
<<"\n\n"
|
|
<<"Usage:\n\n"
|
|
<<" tdmreaper <tdm-file> <tdx-file> [options]"
|
|
<<"\n\n"
|
|
<<"Options:"
|
|
<<"\n\n"
|
|
<<" -m, --showmeta show meta information about tdm dataset\n"
|
|
<<" -r, --showroot show root data of dataset\n"
|
|
<<" -g, --listgroups list channelgroups\n"
|
|
<<" -c, --listchannels list channels\n"
|
|
<<" -b, --listblocks list TDX blocks\n"
|
|
<<" -u, --listsubmatrices list submatrices\n"
|
|
<<" -l, --listlocalcolumns list localcolumns\n"
|
|
// <<"options with arguments must be provided as '--option arg' or '-o arg'\n"
|
|
<<" -d, --output (existing) output directory (default: no default)\n"
|
|
<<" -f, --filenames If an output directory is provided, all channels\n"
|
|
<<" of the dataset will be written to file(s).\n"
|
|
<<" The filenaming rule using %C (channel index), %c (channel name),\n"
|
|
<<" %G (group index), %g (group name) \n"
|
|
<<" determines whether the channels are collected in files according\n"
|
|
<<" to their channelgroups (as long as the filenaming rule includes\n"
|
|
<<" %G or %g) or written in separate files. For instance, to obtain\n"
|
|
<<" files with only one channel each use '--f channel_%C_%c.csv'.\n"
|
|
<<" (default: '--filenames channelgroup_%G_%g.csv' )\n"
|
|
<<" -s, --csvsep separator character used in .csv files (default is comma '--csvsep ,')\n"
|
|
<<" -i, --includemeta include channel(-group) meta-data into files\n"
|
|
<<" -h, --help show this help message \n"
|
|
<<" -v, --version display version\n"
|
|
<<"\n";
|
|
}
|
|
|
|
// ------------------------------------------------------------------------- //
|
|
|
|
// define type of key-value map object
|
|
typedef std::map<std::string,std::string> optkeys;
|
|
|
|
const std::string argmsg = std::string("both .tdm and .tdx file must be provided!");
|
|
const std::string arguse = std::string("see $ tdmreaper --help for usage");
|
|
|
|
optkeys parse_args(int argc, char* argv[], bool showargs = false)
|
|
{
|
|
if ( showargs )
|
|
{
|
|
std::cout<<"number of CLI-arguments: "<<argc<<"\n";
|
|
for ( int i = 0; i < argc; i++ ) std::cout<<i<<": "<<argv[i]<<"\n";
|
|
}
|
|
|
|
// declare empty key-value object
|
|
optkeys prsdkeys;
|
|
|
|
if ( argc == 2 )
|
|
{
|
|
if ( std::string(argv[1]) == std::string("--help")
|
|
|| std::string(argv[1]) == std::string("-h") )
|
|
{
|
|
show_usage();
|
|
}
|
|
else if ( std::string(argv[1]) == std::string("--version")
|
|
|| std::string(argv[1]) == std::string("-v") )
|
|
{
|
|
std::cout<<"tdmreaper "<<gittag<<"\n";
|
|
}
|
|
else
|
|
{
|
|
std::cerr<<argmsg + std::string("\n") + arguse + std::string("\n");
|
|
prsdkeys.insert(std::pair<std::string,std::string>("invalidoption",argv[1]));
|
|
return prsdkeys;
|
|
}
|
|
}
|
|
else if ( argc > 2 )
|
|
{
|
|
// tdm file
|
|
if ( std::string(argv[1]).find(std::string(".tdm")) != std::string::npos )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("tdm",argv[1]));
|
|
}
|
|
else
|
|
{
|
|
std::string tdmerr = std::string(argv[1])
|
|
+ std::string(" does not look like a .tdm file")
|
|
+ std::string(", evtl. add file extension *.tdm")
|
|
+ std::string("\n") + arguse;
|
|
std::cerr<<tdmerr + std::string("\n");
|
|
prsdkeys.insert(std::pair<std::string,std::string>("invalidoption",argv[1]));
|
|
return prsdkeys;
|
|
}
|
|
// tdx file
|
|
if ( std::string(argv[2]).find(std::string(".tdx")) != std::string::npos )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("tdx",argv[2]));
|
|
}
|
|
else
|
|
{
|
|
std::string tdxerr = std::string(argv[2])
|
|
+ std::string(" does not look like a .tdx file")
|
|
+ std::string(", evtl. add file extension *.tdx")
|
|
+ std::string("\n") + arguse;
|
|
std::cerr<<tdxerr + std::string("\n");
|
|
prsdkeys.insert(std::pair<std::string,std::string>("invalidoption",argv[2]));
|
|
return prsdkeys;
|
|
}
|
|
|
|
// options (in any order)
|
|
for ( int i = 3; i < argc; i++ )
|
|
{
|
|
if ( std::string(argv[i]) == std::string("--showmeta")
|
|
|| std::string(argv[i]) == std::string("-m") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("showmeta","showmeta"));
|
|
}
|
|
else if ( std::string(argv[i]) == std::string("--showroot")
|
|
|| std::string(argv[i]) == std::string("-r") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("showroot","showroot"));
|
|
}
|
|
else if ( std::string(argv[i]) == std::string("--listgroups")
|
|
|| std::string(argv[i]) == std::string("-g") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("listgroups","listgroups"));
|
|
}
|
|
else if ( std::string(argv[i]) == std::string("--listchannels")
|
|
|| std::string(argv[i]) == std::string("-c") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("listchannels","listchannels"));
|
|
}
|
|
else if ( std::string(argv[i]) == std::string("--listblocks")
|
|
|| std::string(argv[i]) == std::string("-b") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("listblocks","listblocks"));
|
|
}
|
|
else if ( std::string(argv[i]) == std::string("--listsubmatrices")
|
|
|| std::string(argv[i]) == std::string("-u") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("listsubmatrices","listsubmatrices"));
|
|
}
|
|
else if ( std::string(argv[i]) == std::string("--listlocalcolumns")
|
|
|| std::string(argv[i]) == std::string("-l") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("listlocalcolumns","listlocalcolumns"));
|
|
}
|
|
//
|
|
else if ( std::string(argv[i]) == std::string("--output")
|
|
|| std::string(argv[i]) == std::string("-d") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("output",argv[i+1]));
|
|
i += 1;
|
|
}
|
|
else if ( std::string(argv[i]) == std::string("--filenames")
|
|
|| std::string(argv[i]) == std::string("-f") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("filenames",argv[i+1]));
|
|
i += 1;
|
|
}
|
|
else if ( std::string(argv[i]) == std::string("--csvsep")
|
|
|| std::string(argv[i]) == std::string("-s") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("csvsep",argv[i+1]));
|
|
i += 1;
|
|
}
|
|
//
|
|
else if ( std::string(argv[i]) == std::string("--includemeta")
|
|
|| std::string(argv[i]) == std::string("-i") )
|
|
{
|
|
prsdkeys.insert(std::pair<std::string,std::string>("includemeta",argv[i+1]));
|
|
}
|
|
else
|
|
{
|
|
std::string argerr = std::string("unkown option '") + argv[i] + std::string("'");
|
|
std::cerr<<argerr + std::string("\n") + arguse + std::string("\n");
|
|
prsdkeys.insert(std::pair<std::string,std::string>("invalidoption",argv[i]));
|
|
return prsdkeys;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::cerr<<argmsg + std::string("\n") + arguse + std::string("\n");
|
|
}
|
|
|
|
return prsdkeys;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------- //
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
// parse CLI arguments
|
|
optkeys cfgopts = parse_args(argc,argv);
|
|
|
|
// show all CLI arguments
|
|
if ( false)
|
|
{
|
|
for ( optkeys::iterator it=cfgopts.begin(); it!=cfgopts.end(); ++it )
|
|
{
|
|
std::cout<<std::setw(20)<<std::left<<it->first<<it->second<<"\n";
|
|
}
|
|
}
|
|
|
|
// exit on any invalid option
|
|
if ( cfgopts.count("tdm") == 1 && cfgopts.count("tdx") == 1
|
|
&& cfgopts.count("invalidoption") == 0 )
|
|
{
|
|
// get options
|
|
bool showmeta = cfgopts.count("showmeta") == 1 ? true : false;
|
|
bool showroot = cfgopts.count("showroot") == 1 ? true : false;
|
|
bool listgroups = cfgopts.count("listgroups") == 1 ? true : false;
|
|
bool listchannels = cfgopts.count("listchannels") == 1 ? true : false;
|
|
bool listblocks = cfgopts.count("listblocks") == 1 ? true : false;
|
|
bool listsubmatrices = cfgopts.count("listsubmatrices") == 1 ? true : false;
|
|
bool listlocalcolumns = cfgopts.count("listlocalcolumns") == 1 ? true : false;
|
|
// bool includemeta = cfgopts.count("includemeta") == 1 ? true : false;
|
|
|
|
// set required option values
|
|
std::string output = cfgopts.count("output") == 1 ? cfgopts.at("output")
|
|
: std::string("");
|
|
std::string files = cfgopts.count("filenames") == 1 ? cfgopts.at("filenames")
|
|
: std::string("channel_%G_%C.csv");
|
|
std::string csvsep = cfgopts.count("csvsep") == 1 ? cfgopts.at("csvsep")
|
|
: std::string(",");
|
|
|
|
// declare and initialize tdm_reaper instance
|
|
tdm_reaper jack;
|
|
try {
|
|
jack.submit_files(cfgopts.at("tdm"),cfgopts.at("tdx"),false);
|
|
} catch (const std::exception& e) {
|
|
throw std::runtime_error( std::string("failed to load/parse tdm/tdx files: ")
|
|
+ e.what() );
|
|
}
|
|
|
|
// show some meta data of the dataset
|
|
if ( showmeta ) std::cout<<"\n"<<jack.get_meta().get_info()<<"\n";
|
|
if ( showroot ) std::cout<<"\n"<<jack.get_root().get_info()<<"\n";
|
|
|
|
// get complete channel(-group) overview
|
|
format grpformatter(26,false,false,' ');
|
|
if (listgroups) std::cout<<"\n"<<jack.get_overview<tdm_channelgroup>(grpformatter)<<"\n";
|
|
format chformatter(14,false,false,' ');
|
|
if (listchannels) std::cout<<"\n"<<jack.get_channel_overview(chformatter)<<"\n";
|
|
|
|
// get complete submatrix/localcolumns overview
|
|
format formatter(18,false,false,' ');
|
|
if (listblocks) std::cout<<jack.get_overview<block>(formatter)<<"\n";
|
|
if (listsubmatrices) std::cout<<jack.get_overview<submatrix>(formatter)<<"\n";
|
|
if (listlocalcolumns) std::cout<<jack.get_overview<localcolumn>(formatter)<<"\n";
|
|
|
|
// print data to files
|
|
if ( !output.empty() )
|
|
{
|
|
// declare filesystem path
|
|
std::filesystem::path pd = output;
|
|
|
|
// check for given directory
|
|
if ( std::filesystem::is_directory(pd) )
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
std::cerr<<std::string("directory '") + output
|
|
+ std::string("' does not exist") + std::string("\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( cfgopts.size() == 2 ) std::cerr<<"no output directory given\n";
|
|
}
|
|
|
|
// std::vector<std::string> chgrids = jack.get_channelgroup_ids();
|
|
// for ( auto id: chgrids )
|
|
// {
|
|
// std::string filenam = std::string("channelgroup_") + id + std::string(".dat");
|
|
// jack.print_group(id,filenam.c_str(),true);
|
|
// }
|
|
//
|
|
// std::vector<std::string> chids = jack.get_channel_ids();
|
|
// for ( auto id: chids )
|
|
// {
|
|
// std::string filenam = std::string("channel_") + id + std::string(".dat");
|
|
// // std::vector<tdmdatatype> chdata = jack.get_channel(id);
|
|
// jack.print_channel(id,filenam.c_str(),true);
|
|
// }
|
|
|
|
// print list of groups or channels to stdout
|
|
// if ( listgroups ) jack.list_groups();
|
|
// if ( listchannels ) jack.list_channels();
|
|
|
|
// // write data to filesystem
|
|
// if ( !listgroups && !listchannels )
|
|
// {
|
|
// // declare filesystem path
|
|
// std::filesystem::path pd = output;
|
|
//
|
|
// // check for given directory
|
|
// if ( std::filesystem::is_directory(pd) )
|
|
// {
|
|
// // print (group,channel) data
|
|
// for ( int g = 0; g < jack.num_groups(); g++ )
|
|
// {
|
|
// // get and sanitize group name
|
|
// std::string grpnm = jack.group_name(g);
|
|
// std::regex regg("([^A-Za-z0-9])");
|
|
// std::string grpname = std::regex_replace(grpnm,regg,"");
|
|
//
|
|
// for ( int c = 0; c < jack.no_channels(g); c++ )
|
|
// {
|
|
// // get overall channel index/id
|
|
// int chidx = jack.obtain_channel_id(g,c);
|
|
//
|
|
// // get and sanitize channel name
|
|
// std::string chnm = jack.channel_name(g,c);
|
|
// std::regex regc("([^A-Za-z0-9])");
|
|
// std::string chname = std::regex_replace(chnm,regc,"");
|
|
//
|
|
// // construct file name according to filenaming rule
|
|
// std::string filenm = files;
|
|
// filenm = std::regex_replace(files,std::regex("\\%C"),std::to_string(c+1));
|
|
// filenm = std::regex_replace(filenm,std::regex("\\%c"),chname);
|
|
// filenm = std::regex_replace(filenm,std::regex("\\%G"),std::to_string(g+1));
|
|
// filenm = std::regex_replace(filenm,std::regex("\\%g"),grpname);
|
|
//
|
|
// // concat paths
|
|
// std::filesystem::path outfile = pd / filenm;
|
|
//
|
|
// // write channel to filesystem
|
|
// jack.print_channel(chidx,outfile.c_str());
|
|
// }
|
|
// }
|
|
//
|
|
// // print meta data
|
|
// jack.print_meta((pd / "meta-data.log").c_str());
|
|
// }
|
|
// else
|
|
// {
|
|
// std::cerr<<std::string("directory '") + output
|
|
// + std::string("' does not exist") + std::string("\n");
|
|
// }
|
|
// }
|
|
}
|
|
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(10000));
|
|
|
|
return 0;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------- //
|