main.cpp

Go to the documentation of this file.

#include <string>
#include <cassert>
#include <vector>
#include <fstream>
#include <streambuf>

#include <boost/program_options.hpp>

#include <Poco/String.h>
#include <Poco/SharedPtr.h>
#include <Poco/StringTokenizer.h>

#include <InDataRefine.hpp>
#include <LCoreData.hpp>
#include <CldPlugin.hpp>
#include <BoostPlugin.hpp>


namespace po = boost::program_options;


int main(int ac, char** av) {
    bool ret = EXIT_FAILURE;
    bool verbose = false;
    bool check = false;
    bool detect = false;
    po::options_description desc("Supported options");
    desc.add_options()
        ("help", "produce help message")
            ("input_file,i", po::value<std::string>(), "Input file")
            ("lang,l", po::value<std::string>(), "Input language")
            ("verbose,v", po::value(&verbose)->zero_tokens()->default_value(false), "verbose mode")
            ("check,c", po::value(&check)->zero_tokens()->default_value(false), "verbose mode")
            ("detect,d", po::value(&detect)->zero_tokens()->default_value(false), "verbose mode")
    ;

    po::variables_map vm;
    po::store(po::parse_command_line(ac, av, desc), vm);
    po::notify(vm);
    ret = EXIT_SUCCESS;

    if (vm.count("help")) {
        std::cout << desc << "\n";
    }

    if(ret==EXIT_SUCCESS) {
        if(check) {
            if (vm.count("input_file") && vm.count("lang")) {
                std::ifstream iss(vm["input_file"].as<std::string>());
                while(iss.good() && !iss.eof()) {
                    std::string word;
                    iss >> word;
                    if(word.length()) {
                        HCE::component::LCoreData lCData(word);
                        lCData._mapOffsets[0] = word.length();
                        lCData._mapTokens[0] = word;
                        HCE::component::CldPlugin cldPlugin;
                        cldPlugin.process(lCData);
                        std::string detectLang = lCData._mapLanguages[0];
                        if(detectLang!=vm["lang"].as<std::string>()) {
                            std::cout << "Error: " << word << '\t' << detectLang << std::endl;
                        }
                    }
                }
                iss.close();
            } else {
                std::cout << "Input file or language was not set.\n";
            }
        } else if(detect) {
            if (vm.count("input_file")) {
                std::ifstream iss(vm["input_file"].as<std::string>());
                std::map<std::string, unsigned int> mapLang;
                std::map<std::string, std::vector<std::string> > mapWordsByLang;
                while(iss.good() && !iss.eof()) {
                    std::string word;
                    iss >> word;
                    if(word.length()) {
                        HCE::component::LCoreData lCData(word);
                        lCData._mapOffsets[0] = word.length();
                        lCData._mapTokens[0] = word;
                        HCE::component::CldPlugin cldPlugin;
                        cldPlugin.process(lCData);
                        mapLang[lCData._mapLanguages[0]]++;
                        mapWordsByLang[lCData._mapLanguages[0]].push_back(word);
                    }
                }
                for(std::map<std::string, unsigned int>::const_iterator it=mapLang.begin(); it!=mapLang.end(); ++it) {
                    std::cout << it->first << '\t' << it->second << std::endl;
                    for(std::vector<std::string>::const_iterator itr=mapWordsByLang[it->first].begin(); itr!=mapWordsByLang[it->first].end(); ++itr) {
                        if(verbose) {
                            std::cout << *itr << std::endl;
                        }
                    }
                    std::cout << "-------------------------------------------" << std::endl;
                }
                iss.close();
            } else {
                std::cout << "Input file was not set.\n";
            }
        }
    }
    return ret;
    std::string content(std::istreambuf_iterator<char>(std::cin), std::istreambuf_iterator<char>());
    Poco::SharedPtr<HCE::DataBase> inData(new HCE::InDataRefine(HCE::CT_REFINE, 0, 0, content));
    HCE::component::LCoreData lCData(inData.cast<HCE::InDataRefine>()->getContent());

    HCE::component::BoostPlugin tokenizerPlugin;
    tokenizerPlugin.tokenizer(lCData);

    HCE::component::CldPlugin cldPlugin;
    cldPlugin.process(lCData);

    std::map<WORD_CONTENT_OFFSET, WORD_LENGTH>::const_iterator it1;
    for( it1=lCData._mapOffsets.begin(); it1!=lCData._mapOffsets.end(); ++it1) {
        /*
        int eq = strcmp(lCData._mapLanguages[it1->first].c_str(),"ru");
        assert(lCData._mapLanguages[it1->first].c_str()==std::string("en"));
        */
        /*
        std::cout << lCData._mapTokens[it1->first] << '\t'
                << lCData._mapLanguages[it1->first] << std::endl;
                */
    }
    return EXIT_SUCCESS;
}