static std::string callGetNameInfo(const NetworkAddress& address,
char* port_string) {
sockaddr_in addr;
address.FillAddr(&addr);
std::string retval;
// maximum length for IPv4 address is 16 (12 digits, 3 '.', 1 NUL)
// IPv6 is 16 bytes = 32 hex bytes + 7 ':' + NULL = 40
retval.resize(40);
int error = getnameinfo(reinterpret_cast<struct sockaddr*>(&addr),
sizeof(addr), stringArray(&retval),
static_cast<socklen_t>(retval.size()), port_string,
MAX_PORT_STRING, NI_NUMERICHOST | NI_NUMERICSERV);
if (error != 0) {
throw Exception("Could not get name info \n");
}
retval.resize(strlen(retval.data()));
return retval;
}
// Retrieves a series of interpolation values from a source node
void ReadSourceInterpolation(xmlNode* sourceNode, UInt32List& array)
{
if (sourceNode != NULL)
{
// Get the accessor's count
xmlNode* accessorNode = FindTechniqueAccessor(sourceNode);
uint32 count = ReadNodeCount(accessorNode);
array.resize(count);
// Backward compatibility: drop the unwanted interpolation values.
// Before, we exported one interpolation token for each dimension of a merged curve.
// Now, we export one interpolation token for each key of a merged curve.
uint32 stride = ReadNodeStride(accessorNode);
StringList stringArray(count * stride);
xmlNode* arrayNode = FindChildByType(sourceNode, DAE_NAME_ARRAY_ELEMENT);
const char* arrayContent = ReadNodeContentDirect(arrayNode);
FUStringConversion::ToStringList(arrayContent, stringArray);
for (uint32 i = 0; i < count; ++i)
{
array[i] = (uint32) FUDaeInterpolation::FromString(stringArray[i * stride]);
}
}
}
int main() {
/*
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ATTENTION !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* !!!! PLEASE VIEW THE BASIC EXAMPLE FIRST BEFORE READING THIS EXAMPLE. IT PROVIDES FUNDAMENTAL !!!!
* !!!! KNOWLEDGE THAT WILL BE VERY HELPFUL IN UNDERSTANDING THIS EXAMPLE. !!!!
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*/
/*
* Every supported data type (with the exception of bool and Teuchos::Array<bool>) has
* at least one validator. Lets take a look at them.
*/
/*
* The validator for number types has been templated. The validator has two constuctors.
* The first takes three arguments:
* 1. Minimum allowed value (inclusive).
* 2. Maximum allowed value (inclusive).
* 3. The step. This is the how much the value of the parameter should be changed
* when it is told to increase or decrease in the GUI. Play around with this value a bit
* to get a good idea of what it does. It really only has meaning when used with the GUI.
*
* The second constructor takes no arguments. It mearly enforces that a particular
* parameter is of a certain number type. If you use this second constructor, no
* minimum or maximum will be set. If you would like your validator to have a minimum
* and no maximum you may call the setMin function after using this constructor.
* The same can be done with the setMax if you wish to have a maximum and no minimum.
*/
/*
* First we create an empty parameter list. We will use this to define
* all of the parameters we wish to obtain from the user.
*/
Teuchos::RCP<Teuchos::ParameterList> My_List = Teuchos::RCP<Teuchos::ParameterList>(new Teuchos::ParameterList);
/*
* Here we create a validator for an int parameter. It's minimum value is 0, and it's maximum value is 10.
* The step is 1 (the default value for the argument).
*/
Teuchos::RCP<Optika::EnhancedNumberValidator<int> > intVali =
Teuchos::rcp(new Optika::EnhancedNumberValidator<int>(0,10));
/*
* We then create an int parameter and use intVali as the
* validator argument.
*/
My_List->set("Int", 8, "Int tester", intVali);
/*
* Here we create an int validator with a minimum of 0, a maximum of 100
* and a step value of 10. Try running the example program and press the up
* and down buttons that appear in the edit box of this parameter. That's
* the best way to explain what the step parameter specifies.
*/
Teuchos::RCP<Optika::EnhancedNumberValidator<int> > intStepVali =
Teuchos::rcp(new Optika::EnhancedNumberValidator<int>(0,100,10));
My_List->set("Step int", 10, "Step int tester", intStepVali);
/*
* Now suppose we wanted to make a validator for a short parameter that only
* had a minimum, and no maximum. First we creat it.
*/
Teuchos::RCP<Optika::EnhancedNumberValidator<short> > shortVali =
Teuchos::rcp(new Optika::EnhancedNumberValidator<short>());
/*
* We then call the setMin function with a value of 0.
*/
shortVali->setMin(0);
/*
* We then apply the validator to a short parameter.
*/
My_List->set("Short", (short)4, "short tester", shortVali);
/*
* Floats and Doubles have an extra argument that can be tacked on to their constructor,
* the precision argument. This controls how many decimals are displayed to the user in
* the GUI, NOT THE ACTUALL PRECISION USED TO STORE THE VALUE! Here we set the step of the
* double validator to 1e-6 and the precision to 6 decimal places. Try running the program
* to see it in action.
*/
Teuchos::RCP<Optika::EnhancedNumberValidator<double> > doubleVali =
Teuchos::rcp(new Optika::EnhancedNumberValidator<double>(0,20,1e-6, 6));
My_List->set("Double", (double)4.5, "double tester", doubleVali);
/*
* This validator is called a StringValidator. It takes a Teuchos tuple containg strings
* and then makes sure what every parameter it is applied to is only ever set to one of those values.
* Note: A Teuchos StringToIntegralParameterEntryValidator would also do the trick here, but they're
* a little more complicated to use and kind of overkill for what we're doing here.
*/
Teuchos::RCP<Optika::StringValidator> solverValidator = Teuchos::RCP<Optika::StringValidator>(
new Optika::StringValidator(Teuchos::tuple<std::string>( "GMRES", "CG", "TFQMR" )));
My_List->set("Solver", "GMRES", "The type of solver to use.", solverValidator);
/*
* The other validator that you may use is the FileNameValidator. This makes sure that the user supplies
* a valid filename for this parameter.
*/
Teuchos::RCP<Optika::FileNameValidator> filnameVali =
Teuchos::rcp(new Optika::FileNameValidator);
My_List->set("filename", "", "filename tester", filnameVali);
/*
* Array validators may also be used as well. For arrays containing numbers, simply use the ArrayNumberValidator wrapper class.
* The ArrayNumberValidator takes an ordinary EnhancedNumberValidator as an argument for its constructor, and then uses that
* validator to validate each entry in the array.
*
* If you would like to emulate the functionality of the StringValidator for an array, use the
* ArrayStringValidator wrapper class.
*
* If you would like to emulate the functionality of the FileNameValidator for an array, use the ArrayFileNameValidator
* wrapper class.
*
* Examples of all these are shown below.
*/
Teuchos::Array<int> intArray(10,0);
Teuchos::Array<std::string> stringArray(10,"Option1");
Teuchos::Array<std::string> filenameArray(3,"~/");
My_List->set("IntArray", intArray, "intarray tester",
Teuchos::RCP<Optika::ArrayNumberValidator<int> >(new Optika::ArrayNumberValidator<int>(
Teuchos::RCP<Optika::EnhancedNumberValidator<int> >(
new Optika::EnhancedNumberValidator<int>(0,20,5)
))));
Teuchos::RCP<Optika::StringValidator> optionsValidator = Teuchos::RCP<Optika::StringValidator>(
new Optika::StringValidator(Teuchos::tuple<std::string>("Option1", "Option2", "Option3", "Option4" )));
My_List->set("StringArray", stringArray, "string tester",
Teuchos::RCP<Optika::ArrayStringValidator>(new Optika::ArrayStringValidator(optionsValidator)));
Teuchos::RCP<Optika::FileNameValidator> arrayFilnameVali = Teuchos::rcp(new Optika::FileNameValidator);
My_List->set("Filename Array", filenameArray, "filename array tester",
Teuchos::RCP<Optika::ArrayFileNameValidator>(new Optika::ArrayFileNameValidator(arrayFilnameVali)));
/*
* Here we print ouf the user entered values in XML format.
*/
Optika::getInput(My_List);
Teuchos::RCP<Teuchos::FancyOStream> out = Teuchos::VerboseObjectBase::getDefaultOStream();
Teuchos::writeParameterListToXmlOStream(*My_List, *out);
/*
* Final Notes:
*
* Supported Validators:
* -EnhancedNumberValidator<S>
* -StringToIntegralValidator<S>
* -ArrayNumberValidator<S>
* -ArrayStringValidator
* -ArrayFileNameValidator
*
* If a validator is used that the GUI doesn't recognized, the GUI simply won't
* use it. So if you're using validators not supported by the Optika package
* make sure to check that your data is valid after running the getInput
* function.
*
* Note: There's a validator factory class so that you can make validators
* all quick and fast like. You should check it out if you use a lot of validators.
* Chances are it could make your life rediculously easier.
*
* Remember: You default value for a parameter should be within the valid range
* for the validator you are using on it. If this is not the case, an error will
* be thrown before the GUI can even start up.
*
* Remember: Make sure you're using the right type of validator with the right
* type of parameter, especially when it comes to arrays. If you don't use the
* correct validator on the parameter, an error will be thrown before the GUI
* can even startup.
*
* Careful! Reusing validators on multiple parameters is perfectly legal, but
* be careful. Things like the NumberValidatorDependency can cause validators
* min's and max's to change during the running of the GUI. Because we're
* using pointers this means any parameter using the same validator will have
* it's min's and max's changed too!
*/
return 0;
}
