// Поиск объекта с тегом, а также компонента ArgumentHandler
private bool FindArgHandlerObj()
{
//Проверка на повторный запуск скрипта, так как находится в OnGUI и межет быть вызван более 1 раза
if (!isError)
{
var argHandlerObj = GameObject.FindGameObjectWithTag(argHandlerTag);
if (argHandlerObj == null)
{
// Если объект не найден, дальнейшая работа скрипта невозможна
Debug.LogError(TagErrorMessage);
isError = true;
return(false);
}
else
{
handler = argHandlerObj.GetComponentInParent <ArgumentHandler>();
}
if (handler == null)
{
// Если компонент не найден, дальнейшая работа скрипта невозможна
Debug.LogError(ArgHandlerErrorMessage);
isError = true;
return(false);
}
else
{
return(true); // вернем истину, если объект найден
}
}
else
{
return(false); // возвращает ложь,если была ранее выдана ошибка
}
}
public async Task should_parse_correct_enum_value()
{
// given
var result = SampleEnum.None;
var argumentLabel = "--enum-value";
var command = new LeafCommand
{
Label = "verb",
Options = new[]
{
new CommandOption(argumentLabel)
},
TaskToRun = args =>
{
result = args.GetArgument(argumentLabel).ExpectedAsEnumValue <SampleEnum>();
return(Task.CompletedTask);
}
};
var handler = new ArgumentHandler(new ArgumentHandlerSettings
{
CommandTree = new CommandTree
{
Root = command
}
});
// when
await handler.HandleAsync(new[] { "--enum-value", "Two" });
// then
Assert.Equal(SampleEnum.Two, result);
}
static void Main(string[] args)
{
// Set version
Assembly assembly = Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string version = fvi.FileVersion;
Console.WriteLine("");
Console.WriteLine("PPD - Parse Performance Data v{0}", version);
Console.WriteLine("Copyright (C) 2010-2016 Ryan Bijkerk");
Console.WriteLine("Logit Blog - www.logitblog.com");
Console.WriteLine("");
// Check for Excel 2013 or 2016
var ExcelCheck = new ReportHandler();
ExcelCheck.Version();
// Check the arguments
var argumentHandler = new ArgumentHandler();
var arguments = argumentHandler.Parse(args);
// Collecting the metrics
var settingsMetric = new MetricsHandler();
var metrics = settingsMetric.Load();
// File parsing
var file = new FileItemHandler();
var report = new ReportHandler();
// Start for the timer
var startTime = DateTime.Now;
foreach (var fileItem in arguments.fileLocation)
{
// File Check
file.Check(fileItem);
Console.WriteLine("{0}: Working on file: {1}", DateTime.Now, fileItem);
// File Parse for the data
var fileResults = file.Parse(fileItem, metrics);
// File time interval data
var fileTime = file.Time(fileItem);
// Create Excel file
var reportFile = report.Create(fileItem);
Console.WriteLine("{0}: Creating Excel report on location: {1}", DateTime.Now, reportFile);
// Add data to Excel file
report.AddData(reportFile, fileResults, fileTime);
// Add charts to Excel file
report.AddCharts(reportFile);
}
// Done and reporting total time
var stopTime = DateTime.Now;
Console.WriteLine("{0}: Done in {1} sec! ", DateTime.Now, Math.Round(stopTime.Subtract(startTime).TotalSeconds));
}
/// <summary>
/// Generira bodove ovisno o odabranom algoritmu bodovanja
/// </summary>
/// <param name="listOfRegistrations">Lista prijava</param>
/// <param name="finalScores">Rječnik u koji se spremaju finalni bodovi</param>
void GenerateFinalScores(List <Registration> listOfRegistrations, Dictionary <Registration, float> finalScores)
{
ArgumentHandler arguments = ArgumentHandler.GetInstance();
string scoringClass = (string)arguments.GetArgument("ScoringClass");
ScoringFactory scoringFactory;
if (string.Equals(scoringClass, "SumAllScores"))
{
scoringFactory = new SumAllScoresFactory();
}
else if (string.Equals(scoringClass, "BalancedScoring"))
{
scoringFactory = new BalancedScoringFactory();
}
else
{
scoringFactory = new ScoreByAverageFactory();
}
ScoreAlgorhitm scoringAlgorhitm = scoringFactory.Create();
Console.WriteLine("\n\nFinal Scores:");
foreach (Registration registration in listOfRegistrations)
{
float finalScore = scoringAlgorhitm.GenerateScore(registration);
finalScores[registration] = finalScore;
Console.WriteLine(registration.ID + " od " + registration.Competitor.Name + ": " + finalScore.ToString());
registration.FinalScore = finalScore;
}
}
public ParameterResolver(IClipboardService clipboardService, IDataSourceService dataService)
{
_dataService = dataService;
_handler = new TextHandler()
.SetNext(new UriHandler())
.SetNext(new ClipboardHandler(clipboardService));
}
public void Run()
{
ArgumentHandler arguments = ArgumentHandler.GetInstance();
string resultFile = (string)arguments.GetArgument("ResultFile");
Console.WriteLine(resultFile);
}
private static int Main(string[] args)
{
SetProfile();
ArgumentParseResult arguments;
var console = new ScriptConsole();
try
{
var parser = new ArgumentHandler(new ArgumentParser(), new ConfigFileParser(console), new FileSystem());
arguments = parser.Parse(args);
}
catch (Exception ex)
{
console.WriteLine(ex.Message);
var options = new ArgUsageOptions {
ShowPosition = false, ShowType = false
};
var usage = ArgUsage.GetUsage <ScriptCsArgs>(options: options);
console.WriteLine(usage);
return(1);
}
finally
{
console.Exit();
}
var scriptServicesBuilder = ScriptServicesBuilderFactory.Create(arguments.CommandArguments, arguments.ScriptArguments);
var factory = new CommandFactory(scriptServicesBuilder);
var command = factory.CreateCommand(arguments.CommandArguments, arguments.ScriptArguments);
return((int)command.Execute());
}
private static int Main(string[] args)
{
ProfileOptimization.SetProfileRoot(typeof(Program).Assembly.Location);
ProfileOptimization.StartProfile(typeof(Program).Assembly.GetName().Name + ".profile");
var console = new ScriptConsole();
var parser = new ArgumentHandler(new ArgumentParser(console), new ConfigFileParser(console), new FileSystem());
var arguments = parser.Parse(args);
var commandArgs = arguments.CommandArguments;
var scriptArgs = arguments.ScriptArguments;
var configurator = new LoggerConfigurator(commandArgs.LogLevel);
configurator.Configure(console);
var logger = configurator.GetLogger();
var scriptServicesBuilder = new ScriptServicesBuilder(console, logger)
.Cache(commandArgs.Cache)
.Debug(commandArgs.Debug)
.LogLevel(commandArgs.LogLevel)
.ScriptName(commandArgs.ScriptName)
.Repl(commandArgs.Repl);
var modules = GetModuleList(commandArgs.Modules);
var extension = Path.GetExtension(commandArgs.ScriptName);
if (string.IsNullOrWhiteSpace(extension) && !commandArgs.Repl)
{
// No extension was given, i.e we might have something like
// "scriptcs foo" to deal with. We activate the default extension,
// to make sure it's given to the LoadModules below.
extension = ".csx";
if (!string.IsNullOrWhiteSpace(commandArgs.ScriptName))
{
// If the was in fact a script specified, we'll extend it
// with the default extension, assuming the user giving
// "scriptcs foo" actually meant "scriptcs foo.csx". We
// perform no validation here thought; let it be done by
// the activated command. If the file don't exist, it's
// up to the command to detect and report.
commandArgs.ScriptName += extension;
}
}
scriptServicesBuilder.LoadModules(extension, modules);
var scriptServiceRoot = scriptServicesBuilder.Build();
var commandFactory = new CommandFactory(scriptServiceRoot);
var command = commandFactory.CreateCommand(commandArgs, scriptArgs);
var result = command.Execute();
return(result == CommandResult.Success ? 0 : -1);
}
public void Setup()
{
_testTools = new TestTools {
Placeholders = new[] {
new Placeholder("{projectRoot}", TestTools.GetTestFolder() + @"\TestData\testProject")
}
};
_argumentHandler = Program.GetArgumentHandler();
}
public void ArgumentHandler_works()
{
var x = new ArgumentHandler(
new Argument("px").Required().RequiredValueCount(1).LongId("profileXml"),
new Argument("p").Optional().RequiredValueCount(1));
var result = x.SetInputParam("-px", @"c:\abc.xml");
Assert.True(result);
}
public void ShouldHandleEmptyArgs()
{
var args = new string[0];
var sr = ArgumentHandler.SplitScriptArgs(args);
sr.CommandArguments.ShouldEqual(new string[0]);
sr.ScriptArguments.ShouldEqual(new string[0]);
}
public void ShouldHandleArgsAndScriptArgs()
{
var args = new string[] { "scriptname.csx", "-restore", "--", "-port", "8080" };
var sr = ArgumentHandler.SplitScriptArgs(args);
sr.CommandArguments.ShouldEqual(new[] { "scriptname.csx", "-restore" });
sr.ScriptArguments.ShouldEqual(new[] { "-port", "8080" });
}
public void ShouldHandleJustScriptArgs()
{
var args = new string[] { "--", "-port", "8080" };
var sr = ArgumentHandler.SplitScriptArgs(args);
sr.CommandArguments.ShouldEqual(new string[0]);
sr.ScriptArguments.ShouldEqual(new[] { "-port", "8080" });
}
public void ShouldHandleJustDoubledash()
{
var args = new string[] { "--" };
var sr = ArgumentHandler.SplitScriptArgs(args);
sr.CommandArguments.ShouldEqual(new string[0]);
sr.ScriptArguments.ShouldEqual(new string[0]);
}
public void ShouldHandleTrailingDoubledash()
{
var args = new string[] { "scriptname.csx", "-restore", "--" };
var sr = ArgumentHandler.SplitScriptArgs(args);
sr.CommandArguments.ShouldEqual(new[] { "scriptname.csx", "-restore" });
sr.ScriptArguments.ShouldEqual(new string[0]);
}
public void Run()
{
ArgumentHandler arguments = ArgumentHandler.GetInstance();
Randomizer rnd = Randomizer.GetInstance();
#region Generiranje tema
int maxNumberOfThemes = (int)arguments.GetArgument("MaxThemeNumber");
int numberOfThemes = rnd.GetNumber(1, maxNumberOfThemes);
Console.WriteLine("\nBroj tema: " + numberOfThemes);
List <Theme> listOfThemes = new List <Theme>();
listOfThemes = GenerateThemes(numberOfThemes);
Console.WriteLine("\nOdabrane teme:");
foreach (Theme theme in listOfThemes)
{
Console.WriteLine(theme.Name);
}
#endregion
#region Generiranje kategorija
int numberOfCategories = rnd.GetNumber(1, 3);
Console.WriteLine("\nBroj kategorija: " + numberOfCategories);
List <string> listOfCategories = new List <string>();
listOfCategories = GenerateCategories(numberOfCategories);
Console.WriteLine("Odabrane kategorije:");
foreach (string category in listOfCategories)
{
Console.WriteLine(category);
}
#endregion
#region Generiranje natjecatelja
int maxNumberOfCompetitors = (int)arguments.GetArgument("MaxCompetitorNumber");
int numberOfCompetitors = rnd.GetNumber(0, maxNumberOfCompetitors);
Console.WriteLine("\nBroj natjecatelja: " + numberOfCompetitors);
List <Competitor> listOfCompetitors = GenerateCompetitors(numberOfCompetitors);
Console.WriteLine("\nNatjecatelji:");
foreach (Competitor competitor in listOfCompetitors)
{
Console.WriteLine(competitor.Name);
}
#endregion
#region Generiranje prijava
int maxThemeNumberPerCompetitor = (int)arguments.GetArgument("MaxThemeNumberPerCompetitor");
int maxCategoryNumberPerCompetitor = (int)arguments.GetArgument("MaxCategoryNumberPerCompetitor");
List <Registration> listOfRegistrations = GenerateRegistrations(listOfCompetitors, maxThemeNumberPerCompetitor, maxCategoryNumberPerCompetitor, numberOfThemes, listOfThemes, numberOfCategories, listOfCategories);
#endregion
Competition competition = Competition.GetInstance();
competition.UploadCompetitionData(listOfRegistrations, listOfThemes, listOfCategories, listOfCompetitors);
Console.WriteLine("\nPrihvaćeno " + listOfRegistrations.Count.ToString() + " prijava");
}
public void Argument_property_stop_causes_execution_to_stop()
{
var x = new ArgumentHandler(
new Argument("p").RequiredValueCount(1).Required(),
new Argument("?").Optional().IgnoreOthers()
);
x.SetInputParam("-?", "-p", "abc");
Assert.True(x.Contains("?"));
Assert.False(x.Contains("p"));
}
public void ArgumentHandler_throws_exception_when_syntax_has_error()
{
var x = new ArgumentHandler(new Argument("a").RequiredValueCount(1));
var result = x.SetInputParam("-");
Assert.False(result);
Assert.NotNull(x.ExceptionThrown);
Assert.IsInstanceOf <UnknownArgumentIdException>(x.ExceptionThrown);
Assert.That(((UnknownArgumentIdException)x.ExceptionThrown).Code,
Is.EqualTo(UnknownArgumentIdException.ErrCode));
Assert.That(x.ExceptionThrown.Message, Is.EqualTo(string.Format(UnknownArgumentIdException.MsgMask, "-")));
}
public void ArgumentHandler_can_be_initialized_with_array_of_Arguments()
{
var x = new ArgumentHandler(
new Argument("px").Required().RequiredValueCount(1).LongId("profileXml"),
new Argument("p").Optional().RequiredValueCount(1));
Assert.NotNull(x);
var result = x.SetInputParam("-px", @"c:\abc.xml");
Assert.True(result);
}
static void Main(string[] args)
{
ArgumentHandler.parseParams(args);
foreach (KeyValuePair <string, int> s in downloadIds)
{
downloadFile(s.Value, s.Key);
while (!done)
{
Thread.Sleep(5000);
}
}
}
private static ArgumentParseResult ParseArguments(string[] args)
{
var console = new ScriptConsole();
try
{
var parser = new ArgumentHandler(new ArgumentParser(console), new ConfigFileParser(console), new FileSystem());
return(parser.Parse(args));
}
finally
{
console.Exit();
}
}
public void ShouldUseScriptOptsIfParsingFailed()
{
var parser = new Mock <IArgumentParser>();
parser.Setup(x => x.Parse(It.IsAny <string[]>())).Returns <ScriptCsArgs>(null);
var system = new Mock <IFileSystem>();
system.Setup(x => x.CurrentDirectory).Returns(@"C:");
var configParser = new Mock <IConfigFileParser>();
var argumentHandler = new ArgumentHandler(parser.Object, configParser.Object, system.Object);
var result = argumentHandler.Parse(new string[0]);
system.Verify(x => x.FileExists(@"C:\scriptcs.opts"), Times.Once());
}
public static async Task Main()
{
Console.Title = nameof(HitagiBot);
var botHandle = new TelegramBotClient(Config["Tokens:Telegram"]);
string botUsername = null;
try
{
var botUser = await botHandle.GetMeAsync();
botUsername = botUser.Username;
}
catch (AggregateException e)
{
Console.WriteLine($"An error occurred while retrieving the bot's info: {e.Message}");
Console.WriteLine("Press any key to terminate...");
Console.ReadKey();
Environment.Exit(1);
}
_messageHandler = new ArgumentHandler <Message>(botUsername);
_messageHandler.Add("/start", BaseCommands.Start);
_messageHandler.Add("/help", BaseCommands.Help);
_messageHandler.Add("/settings", BaseCommands.Settings);
_messageHandler.Add("/lastplayed", LastFmCommands.LastPlayed);
_messageHandler.Add("/setlastfm", LastFmCommands.SetLastFm);
_messageHandler.Add("/weather", WeatherCommands.WeatherCommand);
_messageHandler.Add("/forecast", WeatherCommands.Forecast);
_messageHandler.Add("/geocode", GeocodeCommands.Geocode);
_messageHandler.Add("/setlocation", GeocodeCommands.SetLocation);
_messageHandler.Add("/movie", MovieCommands.Movie);
_messageHandler.Add("/tvshow", TvCommands.TvShow);
_messageHandler.Add("/ping", MiscCommands.Ping);
_messageHandler.Add("/userid", MiscCommands.UserId);
botHandle.OnMessage += Bot_OnMessage;
botHandle.StartReceiving();
while (botHandle.IsReceiving)
{
await Task.Delay(TimeSpan.FromSeconds(10));
}
Environment.Exit(0);
}
private static int Main(string[] args)
{
var console = new ScriptConsole();
var parser = new ArgumentHandler(new ArgumentParser(console), new ConfigFileParser(console), new FileSystem());
var arguments = parser.Parse(args);
var commandArgs = arguments.CommandArguments;
var scriptArgs = arguments.ScriptArguments;
var configurator = new LoggerConfigurator(commandArgs.LogLevel);
configurator.Configure(console);
var logger = configurator.GetLogger();
var scriptServicesBuilder = new ScriptServicesBuilder(console, logger)
.InMemory(commandArgs.InMemory)
.LogLevel(commandArgs.LogLevel)
.ScriptName(commandArgs.ScriptName)
.Repl(commandArgs.Repl);
var modules = GetModuleList(commandArgs.Modules);
var extension = Path.GetExtension(commandArgs.ScriptName);
if (!string.IsNullOrWhiteSpace(extension))
{
extension = extension.Substring(1);
}
else if (extension == string.Empty)
{
console.WriteLine(string.Format("{0} is not a valid script name.", commandArgs.ScriptName));
return(1);
}
scriptServicesBuilder.LoadModules(extension, modules);
var scriptServiceRoot = scriptServicesBuilder.Build();
var commandFactory = new CommandFactory(scriptServiceRoot);
var command = commandFactory.CreateCommand(commandArgs, scriptArgs);
var result = command.Execute();
return(result == CommandResult.Success ? 0 : -1);
}
public void Initialize()
{
_person = new Person
{
Id = Guid.Parse("7AEC12CD-FD43-49DD-A2AB-3CDD19A3A5F4"),
Birthday = new DateTimeOffset(new DateTime(1980, 1, 1)),
Firstname = "John",
Lastname = "Doe"
};
_idFromExpressionProcessorMock = new Mock <IArgumentProcessor>(MockBehavior.Strict);
_argumentsDefinitionsProcessorMock = new Mock <IArgumentProcessor>(MockBehavior.Strict);
_templateArgumentsProcessorMock = new Mock <IArgumentProcessor>(MockBehavior.Strict);
_linkBuilderMock = new Mock <ILinkBuilder>(MockBehavior.Strict);
_handler = new ArgumentHandler(
_idFromExpressionProcessorMock.Object,
_argumentsDefinitionsProcessorMock.Object,
_templateArgumentsProcessorMock.Object);
}
public static void parseParams(string[] args)
{
if (args.Length > 1)
{
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "-a" || args[i] == "--artist")
{
try
{
if (ArgumentHandler.isValidArtistLink(args[i + 1]))
{
Program.getUserIds(args[i + 1]);
}
}
catch
{
ArgumentHandler.displayError("Invalid URL");
}
}
}
}
else if (args.Length == 1)
{
if (ArgumentHandler.isValidUrl(args[0]))
{
Program.getIdFromUrl(args[0]);
}
else if (args[0] == "-h" || args[0] == "--help")
{
displayHelpMessage();
}
}
else
{
displayHelpMessage();
}
}
public void ArgumentHandler_throws_exception_when_required_argument_is_missing()
{
const string requiredArgument = "a";
const string optionalArgument = "b";
var x = new ArgumentHandler(
new Argument(requiredArgument),
new Argument(optionalArgument).Optional());
var result = x.SetInputParam("-" + optionalArgument);
Assert.False(result);
Assert.NotNull(x.ExceptionThrown);
Assert.IsInstanceOf <MissingRequiredArgumentException>(x.ExceptionThrown);
Assert.That(((MissingRequiredArgumentException)x.ExceptionThrown).Code(),
Is.EqualTo(MissingRequiredArgumentException.Code));
Assert.That(x.ExceptionThrown.Message,
Is.EqualTo(string.Format(MissingRequiredArgumentException.MsgMask, requiredArgument)));
}
public void ArgumentHandler_throws_exception_when_value_is_missing(int requiredCount, string[] givenValueStrings,
string expectedValueCountMsg)
{
const string argumentName = "a";
var x = new ArgumentHandler(new Argument(argumentName).RequiredValueCount(requiredCount));
var a = new string[givenValueStrings.Length + 1];
a[0] = "-" + argumentName;
var index = 1;
foreach (var aGivenValueGivenString in givenValueStrings)
{
a[index++] = aGivenValueGivenString;
}
var result = x.SetInputParam(a);
Assert.False(result);
Assert.NotNull(x.ExceptionThrown);
Assert.IsInstanceOf <MissingValuesException>(x.ExceptionThrown);
Assert.That(((MissingValuesException)x.ExceptionThrown).Code(), Is.EqualTo(MissingValuesException.Code));
var expectedMessage = string.Format(
MissingValuesException.MsgMask,
"-" + argumentName,
expectedValueCountMsg,
string.Join(" ", givenValueStrings)
);
Assert.That(x.ExceptionThrown.Message, Is.EqualTo(expectedMessage));
}
/// <summary>
/// Ova funkcija učitava argumente iz komandne linije
/// </summary>
/// <param name="args">Polje argumenata</param>
/// <returns>True ako je sve dobro učitano, inače False</returns>
public static bool ReadArgs(string[] args)
{
ArgumentHandler arguments = ArgumentHandler.GetInstance();
try
{
if (args.Length < 8)
{
Console.WriteLine("Nisu upisani svi argumenti!");
return(false);
}
#region Učitaj generator slučajnog broja
int randomSeed = Int32.Parse(args[0]);
if (randomSeed < 100)
{
Console.WriteLine("Generator slučajnog broja mora imati bar 3 znamenke!");
return(false);
}
arguments.AddArgument("RandomSeed", "int", randomSeed, true);
#endregion
#region Učitaj maksimalni broj tema
int maxThemeNumber = Int32.Parse(args[1]);
if (maxThemeNumber <= 0 || maxThemeNumber > 10)
{
Console.WriteLine("Maksimalni broj tema mora biti u rangu 1-10!");
return(false);
}
arguments.AddArgument("MaxThemeNumber", "int", maxThemeNumber, true);
#endregion
#region Učitaj maksimalni broj tema po natjecatelju
int maxThemeNumberPerCompetitor = Int32.Parse(args[2]);
if (maxThemeNumberPerCompetitor <= 0 || maxThemeNumberPerCompetitor > maxThemeNumber)
{
Console.WriteLine("Maksimalni broj tema po natjecatelju mora biti veći od 0 i manji ili jedna maksimalnom broju tema!");
return(false);
}
arguments.AddArgument("MaxThemeNumberPerCompetitor", "int", maxThemeNumberPerCompetitor, true);
#endregion
#region Učitaj maksimalni broj kategorija po natjecatelju
int maxCategoryNumberPerCompetitor = Int32.Parse(args[3]);
if (maxCategoryNumberPerCompetitor <= 0 || maxCategoryNumberPerCompetitor > 3)
{
Console.WriteLine("Maksimalni broj kategorija po natjecatelju mora biti u rangu 1-3!");
return(false);
}
arguments.AddArgument("MaxCategoryNumberPerCompetitor", "int", maxCategoryNumberPerCompetitor, true);
#endregion
#region Učitaj maksimalni broj natjecatelja
int maxCompetitorNumber = Int32.Parse(args[4]);
if (maxCompetitorNumber < 0)
{
Console.WriteLine("Maksimalni broj natjecatelja ne smije biti manji od 0");
return(false);
}
arguments.AddArgument("MaxCompetitorNumber", "int", maxCompetitorNumber, true);
#endregion
#region Učitaj broj članova žiria
int juryNumber = Int32.Parse(args[5]);
if (maxCompetitorNumber <= 0)
{
Console.WriteLine("Maksimalni broj kategorija po natjecatelju mora biti veći od 0!");
return(false);
}
arguments.AddArgument("JuryNumber", "int", juryNumber, true);
#endregion
#region Učitaj naziv klase bodovanja
string scoringClass = args[6];
arguments.AddArgument("ScoringClass", "string", scoringClass, true);
#endregion
#region učitaj naziv datoteke u koju se spremaju svi rezultati i tablice bodova
string resultFile = args[7];
arguments.AddArgument("ResultFile", "string", resultFile, true);
#endregion
}
catch
{
Console.WriteLine("Došlo je do nepoznate pogreške");
return(false);
}
return(true);
}
private Framework()
{
m_Handler = new ArgumentHandler();
}
