Software Público Brasileiro

#include "argParser.h"

ArgParser::ArgParser(){}

ArgParser::~ArgParser(){}

void ArgParser::readArgs(char** argv, int argc)
{
	int opt;
	int long_index = 0;

	static struct option long_options[] = {
	{"audio",         required_argument, NULL, 'A'},
	{"subtitle",      required_argument, NULL, 'S'},
	{"text",          required_argument, NULL, 'T'},
	{"video",         required_argument, NULL, 'V'},
	{"language",      required_argument, NULL, 'l'},
	{"background",    required_argument, NULL, 'b'},
	{"resolution",    required_argument, NULL, 'r'},
	{"position",      required_argument, NULL, 'p'},
	{"mode",          required_argument, NULL, 'm'},
    {"id",            required_argument, NULL, 'i'},
    {"no-mixer",      no_argument,       NULL, 'x'},
    {"check-modules", no_argument,       NULL, 'C'},
    {"loglevel",      required_argument, NULL, 'v'},
    {"help",          no_argument,       NULL, 'h'},
    {0,               0,                 0,     0 }
	};

	while ((opt = getopt_long_only(argc, argv, "A:S:T:V:b:l:m:p:r:v:", long_options, &long_index))!= -1)
	{
	    switch (opt)
	    {
	    	case 'A':
	    		if(argc <= 9)
	    			returnErr("Insuficient arguments. Try again");

	        	globalArgs.service = _REC_AUDIO;
	        	globalArgs.input = optarg;
	        	break;

	      	case 'S':
	      		if(argc <= 11 || (globalArgs.service == _REC_VIDEO && argc <= 17))
	    			returnErr("Insuficient arguments. Try again");

	      		if(globalArgs.service == _REC_VIDEO){ // ativa o serviço de vídeo e legendas
	      			globalArgs.service = _VIDEO_WITH_SRT;
	      			globalArgs.input_srt = optarg;
	      		}else{
	      			globalArgs.service = _ONLY_SRT;
	      			globalArgs.input = optarg;
	      		}
	        	break;

	        case 'T':
	        	if(argc <= 9)
	    			returnErr("Insuficient arguments. Try again");

	        	globalArgs.service = _TEXT;
	        	globalArgs.input = optarg;
	        	break;

	      	case 'V':
	      		if(argc <= 13 || ((globalArgs.service == _ONLY_SRT && argc <= 17)))
	    			returnErr("Insuficient arguments. Try again");

	      		if(globalArgs.service == _ONLY_SRT){ // ativa o serviço de vídeo e legendas
	      			globalArgs.service = _VIDEO_WITH_SRT;
	      			globalArgs.input_srt = globalArgs.input;
	      		}else if(globalArgs.mixer == _NO_MIXER) // desativa a mixagem
	      			globalArgs.service = _WITHOUT_MIXER;
	      		else
	      			globalArgs.service = _REC_VIDEO;
	        	globalArgs.input = optarg;
	        	break;

	        case 'l':
	        	globalArgs.language = languageFromString(optarg);
	        	break;

	        case 'b':
	        	globalArgs.back = backgroundFromString(optarg);
	        	break;

	        case 'r':
	        	globalArgs.size = resolutionFromString(optarg);
	        	break;

	        case 'p':
	        	globalArgs.position = positionFromString(optarg);
	        	break;

	        case 'm':
	        	globalArgs.mode = executionModeFromString(optarg);
	        	break;

	        case 'i':
	      		globalArgs.id = optarg;
	      		break;

	        case 'x':
	      		if(globalArgs.service == _REC_VIDEO) // desativa a mixagem
	      			globalArgs.service = _WITHOUT_MIXER;
	      		else
	      			globalArgs.mixer = _NO_MIXER;
	      		break;

	      	case 'C':
	      		globalArgs.service = _TESTER;
	      		break;

	      	case 'v':
	      		globalArgs.l_level = logFromString(optarg);
	      		break;

	      	case 'h':
	      		help();
	      		break;
	     	case '?':
	     		/* o getopt já mostra o erro no terminal!*/
	     		break; 
	      	default:
	       		printf("\nUsage: %s [Service_option] filepath [Options] --id [name] --mode [devel,prod]\n", argv[0]);
	       		printf("\nTry --help for more informations.");
	       		throw lavidlib::RuntimeException();
	    }
	}

	if (argc < 2){
		printf("Not enough arguments.\nTry --help.\n");
		throw lavidlib::RuntimeException();
	}

	/* Mostra os argumentos restantes depois das opções de linha de comando */
	if (optind < argc)
	{
        printf("non-option ARGV-elements:\n");
        while (optind < argc)
            printf("%s\n", argv[optind++]);
    }
}

void ArgParser::help()
{
	std::cout << std::endl
	<< "Usage Summary: vlibras [Service_option] filepath [Options] --id [name] --mode [devel,prod]"
	<< "\n\nService_option:"
	<< "\n\tVideo with Subtitles -V, --video [filePath] -S, --subtitle [filePath]"
	<< "\n\tVideo Recognize      -V, --video [filePath]"
	<< "\n\tAudio Recognize      -A, --audio [filepath]"
	<< "\n\tText                 -T, --text  [filePath]"
	<< "\n\tSubtitles only       -S, --subtitle [filePath]"
	<< "\n\nOptions:"
	<< "\n\t-l, --language   [portugues,libras]"
	<< "\n\t-b, --background [opaque,transp]"
	<< "\n\t-r, --resolution [small,medium,large]"
	<< "\n\t-p, --position   [top_left,top_right,bottom_left,bottom_right]"
	<< "\n\t-m, --mode       [devel,prod]"
	<< "\n\t--id [name]       Relative to the unique ID on the Database."
	<< "\n\t--no-mixer       Disables mixing with the original video."
	<< "\n\nSee man vlibras for detailed descriptions."
	<< std::endl;
	throw lavidlib::RuntimeException(); //para nao iniciar o vlibras
}

void ArgParser::returnErr(const string& option)
{
	cout << "Option '" << option << "' contains an invalid argument." << endl;
	throw lavidlib::RuntimeException();
}

util::logLevel ArgParser::logFromString(const string& level)
{
	if(level == "quiet")
		return util::_QUIET;
	if(level == "debug")
		return util::_DEBUG;
	if(level == "info")
		return util::_INFO;
	if(level == "warning")
		return util::_WARNING;
	if(level == "error")
		return util::_ERROR;

	return util::_INFO;//default
}

ArgParser::Languages ArgParser::languageFromString(const string& language)
{
	if(language == "portugues")
		return _PORTUGUESE;
	if(language == "libras")
		return _GLOSA;

	returnErr("--language");
}

ArgParser::Positions ArgParser::positionFromString(const string& position)
{
	if(position == "top_left")
		return _TOP_LEFT;
	if(position == "top_right")
		return _TOP_RIGHT;
	if(position == "bottom_right")
		return _BOTTOM_RIGHT;
	if(position == "bottom_left")
		return _BOTTOM_LEFT;

	returnErr("--position");
}

ArgParser::Resolution ArgParser::resolutionFromString(const string& resolution)
{
	if(resolution == "small")
		return _SMALL;
	if(resolution == "medium")
		return _MEDIUM;
	if(resolution == "large")
		return _LARGE;

	returnErr("--resolution");
}

ArgParser::Background ArgParser::backgroundFromString(const string& back)
{
	if(back == "opaque")
		return _OPAQUE;
	if(back == "transp")
		return _TRANSPARENT;

	returnErr("--background");
}

ArgParser::Mode ArgParser::executionModeFromString(const string& mode)
{
	if(mode == "prod")
		return _PROD;
	if(mode == "devel")
		return _DEVEL;

	returnErr("--mode");
}

int ArgParser::getService()
{
	return globalArgs.service;
}

int ArgParser::getLanguage()
{
	return globalArgs.language;
}
	
int ArgParser::getPosition()
{
	return globalArgs.position;
} 
	
int ArgParser::getSize()
{
	return globalArgs.size;
}
	
int ArgParser::getBackground()
{
	return globalArgs.back;
}
	
int ArgParser::getMode()
{
	return globalArgs.mode;
}
	
int ArgParser::getOption()
{
	return globalArgs.mixer;
}

string ArgParser::getInput()
{
	return globalArgs.input;
}

string ArgParser::getInputSRT()
{
	return globalArgs.input_srt;
}

string ArgParser::getId()
{
	return globalArgs.id;
}

util::logLevel ArgParser::getLog()
{
	return globalArgs.l_level;
}