#pragma once
struct
CommandLineConstants
{
/** Auth login/password set from launcher params (Format: String - e.g. "-authdata login,password") */
static
constexpr
wchar_t
AuthData
[
]
=
L
"authdata"
;
}
;
class
CommandLineManager
{
public
:
/**
        * No copying or copy assignment allowed for this class.
        */
CommandLineManager
(
CommandLineManager
const
&
)
=
delete
;
CommandLineManager
&
operator
=
(
CommandLineManager
const
&
)
=
delete
;
/**
        * Initialization using a string containing all params
        */
void
Init
(
const
wchar_t
*
lp_cmd_line
)
;
/**
        * Initialization using a collection of params
        */
void
Init
(
const
std
::
vector

&
cmd_line_params
)
;
/**
        * Checks command line arguments for a matching param
        *
        * @param param - Parameter to look for in command line arguments
        *
        * @return True if param is found in command line arguments
        */
bool
HasParam
(
const
std
::
wstring
&
param
)
;
/**
        * Retrieves value associated with given command line parameter
        *
        * @param param - Parameter to look for in command line arguments
        *
        * @return Value associated with command line parameter
        */
std
::
wstring
GetParamValue
(
const
std
::
wstring
&
param
)
;
/**
        * Checks command line arguments for a matching flag param
        *
        * @param param - Parameter to look for in command line arguments
        *
        * @return True if param is found in command line arguments and it is a flag param value
        */
bool
HasFlagParam
(
const
std
::
wstring
&
param
)
;
std
::
map

GetCommandLineArgs
(
)
{
return
command_line_args_
;
}
/**
        * Singleton
        */
static
CommandLineManager
&
Get
(
)
;
private
:
CommandLineManager
(
)
=
default
;
/** True if command line parser initialized */
static
bool
IsInitialized
;
/** Gets a collection of sub-arguments from a string of one or two arguments */
std
::
vector

GetSubArguments
(
const
std
::
wstring
&
sub_arg_list
)
;
/** Add commandline params from a collection of arguments */
void
AddArguments
(
const
std
::
vector

&
arg_list
)
;
/**
         * Adds parameter name to collection of command line parameters
         *
         * @param param_name - Parameter name to add
         */
void
AddParam
(
const
std
::
wstring
&
param_name
)
;
/** Collections of command line arguments */
std
::
map

command_line_args_
;
}
;

#include 
#include "CommandLineManager.h"
namespace
{
const
std
::
wstring FlagParamValue
=
L
"__FLAG__"
;
const
std
::
wstring UnusedParamValue
=
L
"unused"
;
}
bool
CommandLineManager
::
IsInitialized
=
false
;
CommandLineManager
&
CommandLineManager
::
Get
(
)
{
static
CommandLineManager command_line_manager
;
if
(
!
IsInitialized
)
{
// Support for DLL's
int
arg_count
=
0
;
const
LPWSTR
*
arg_list
=
CommandLineToArgvW
(
GetCommandLine
(
)
,
&
arg_count
)
;
std
::
vector

output
;
output
.
reserve
(
arg_count
)
;
for
(
int
i
=
0
;
i

&
cmd_line_params
)
{
if
(
!
IsInitialized
)
{
std
::
vector

args
;
for
(
std
::
wstring cmd_line_param
:
cmd_line_params
)
{
for
(
const
std
::
wstring
&
arg
:
GetSubArguments
(
cmd_line_param
)
)
{
args
.
push_back
(
arg
)
;
}
}
AddArguments
(
args
)
;
IsInitialized
=
true
;
}
}
std
::
vector

CommandLineManager
::
GetSubArguments
(
const
std
::
wstring
&
sub_arg_list
)
{
std
::
vector

args
;
if
(
const
std
::
wstring
::
size_type sub_arg_equals_pos
=
sub_arg_list
.
find_first_of
(
L
'='
)
;
sub_arg_equals_pos
!=
std
::
wstring
::
npos
)
{
// Add both args
args
.
push_back
(
sub_arg_list
.
substr
(
0
,
sub_arg_equals_pos
)
)
;
args
.
push_back
(
sub_arg_list
.
substr
(
sub_arg_equals_pos
+
1
,
sub_arg_list
.
length
(
)
-
1
)
)
;
}
else
{
// Add single arg
args
.
push_back
(
sub_arg_list
)
;
}
return
args
;
}
void
CommandLineManager
::
AddArguments
(
const
std
::
vector

&
arg_list
)
{
if
(
!
arg_list
.
empty
(
)
)
{
const
std
::
wstring
delimiters
(
L
"-,;\\"
)
;
std
::
wstring param_name
;
bool
bPrevWasParamName
=
false
;
const
int
num_args
=
static_cast

(
arg_list
.
size
(
)
)
;
for
(
int
i
=
0
;
i

0
&&
pos
!=
std
::
wstring
::
npos
)
{
if
(
bPrevWasParamName
)
{
// We have another param name so previous was a flag (no param value)
// Add a value to signify we have a flag param
AddParam
(
param_name
)
;
}
param_name
=
command_line_arg
;
// strip out first part so we're left with just the param name
param_name
.
erase
(
0
,
pos
)
;
if
(
i
==
num_args
-
1
)
{
// Add final flag param
AddParam
(
param_name
)
;
}
bPrevWasParamName
=
true
;
continue
;
}
bPrevWasParamName
=
false
;
// Make sure we're not adding a duplicate
if
(
auto
it
=
command_line_args_
.
find
(
{
param_name
}
)
;
it
==
command_line_args_
.
end
(
)
)
{
if
(
command_line_arg
.
empty
(
)
)
{
// Treat empty param value as a flag
command_line_args_
.
insert
(
{
param_name
,
FlagParamValue
}
)
;
}
else
{
command_line_args_
.
insert
(
{
param_name
,
command_line_arg
}
)
;
}
}
// Clear for next param
param_name
.
clear
(
)
;
}
}
}
void
CommandLineManager
::
AddParam
(
const
std
::
wstring
&
param_name
)
{
// Make sure we're not adding a duplicate
if
(
const
auto
it
=
command_line_args_
.
find
(
{
param_name
}
)
;
it
==
command_line_args_
.
end
(
)
)
{
command_line_args_
.
insert
(
{
param_name
,
FlagParamValue
}
)
;
}
}
bool
CommandLineManager
::
HasParam
(
const
std
::
wstring
&
param
)
{
if
(
const
auto
itr
=
command_line_args_
.
find
(
{
param
}
)
;
itr
!=
command_line_args_
.
end
(
)
)
{
if
(
itr
->
second
!=
UnusedParamValue
)
{
return
true
;
}
}
return
false
;
}
std
::
wstring CommandLineManager
::
GetParamValue
(
const
std
::
wstring
&
param
)
{
if
(
const
auto
itr
=
command_line_args_
.
find
(
{
param
}
)
;
itr
!=
command_line_args_
.
end
(
)
)
{
return
itr
->
second
;
}
return
std
::
wstring
(
)
;
}
bool
CommandLineManager
::
HasFlagParam
(
const
std
::
wstring
&
param
)
{
if
(
const
auto
itr
=
command_line_args_
.
find
(
{
param
}
)
;
itr
!=
command_line_args_
.
end
(
)
)
{
return
itr
->
second
==
FlagParamValue
;
}
return
false
;
}

std
::
wstring AutoLogin_Login
;
std
::
wstring AutoLogin_Password
;
if
(
CommandLineManager
::
Get
(
)
.
HasParam
(
CommandLineConstants
::
AuthData
)
)
{
const
std
::
wstring auth_string
=
CommandLineManager
::
Get
(
)
.
GetParamValue
(
CommandLineConstants
::
AuthData
)
;
if
(
std
::
vector

auth_data
=
StringUtils
::
Split
(
auth_string
,
','
)
;
auth_data
.
size
(
)
>=
2
)
{
AutoLogin_Login
=
auth_data
[
0
]
;
AutoLogin_Password
=
auth_data
[
1
]
;
}
}