public T getUnit <T>()
{
Type paramType = typeof(T);
if (paramType == typeof(Parameters.Units[]))
{
// request to return as Parameters.Units[]
// create a copy (since an array is passed by reference)
Parameters.Units[] cUnits = new Parameters.Units[units.Length];
for (int i = 0; i < units.Length; i++)
{
cUnits[i] = units[i];
}
// return value
return((T)Convert.ChangeType(cUnits, typeof(Parameters.Units[])));
}
else
{
// request to return as other
// message and return false
logger.Error("Could not retrieve the unit for parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') as '" + paramType.Name + "', can only return value as 'Parameters.Units[]'. Returning 0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}
public T getValue <T>()
{
Type paramType = typeof(T);
if (paramType == typeof(string[][]))
{
// request to return as string[][]
// create a copy (since an array is passed by reference, and we don't want values being changed this way)
string[][] cValues = new string[values.Length][];
for (int c = 0; c < values.Length; c++)
{
cValues[c] = new string[values[c].Length];
for (int r = 0; r < values[c].Length; r++)
{
cValues[c][r] = values[c][r];
}
}
// return value
return((T)Convert.ChangeType(cValues, typeof(string[][])));
}
else
{
// request to return as other
// message and return 0
logger.Error("Could not retrieve the values for parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') as '" + paramType.Name + "', can only return values as a matrix of strings (string[][]). Returning empty matrix");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}
public T getValue <T>()
{
Type paramType = typeof(T);
if (paramType == typeof(int[]))
{
// request to return as int[]
// create a copy (since an array is passed by reference, and we don't want values being changed this way)
int[] cValues = new int[values.Length];
for (int i = 0; i < values.Length; i++)
{
cValues[i] = values[i];
}
// return value
return((T)Convert.ChangeType(cValues, typeof(int[])));
}
else
{
// request to return as other
// message and return 0
logger.Error("Could not retrieve the values for parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') as '" + paramType.Name + "', can only return values as an array of integers (int[]). Returning empty array");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}
public T getUnit <T>()
{
Type paramType = typeof(T);
if (paramType == typeof(Parameters.Units[]))
{
// request to return as Parameters.Units[]
// return value
Parameters.Units[] units = new Parameters.Units[values.Length];
for (int i = 0; i < values.Length; i++)
{
units[i] = Parameters.Units.ValueOrSamples;
}
return((T)Convert.ChangeType(units, typeof(Parameters.Units[])));
}
else
{
// request to return as other
// message and return false
logger.Error("Could not retrieve the unit for parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') as '" + paramType.Name + "', can only return value as 'Parameters.Units[]'. Returning 0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}
public T getValueInSamples <T>(string paramName, int[] ignoreColumns)
{
lock (lockParameters) {
// try to retrieve the parameter
iParam param = getParameter(paramName);
if (param == null)
{
// message and return 0
logger.Error("Could not find parameter '" + paramName + "' in parameter set '" + paramSetName + "', returning 0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
// if int[][] or double[][] matrix then get values in samples while ignoring columns
if (param.GetType() == typeof(ParamDoubleMat) || param.GetType() == typeof(double[][]))
{
return(((ParamDoubleMat)param).getValueInSamples <T>(ignoreColumns));
}
else if (param.GetType() == typeof(ParamIntMat) || param.GetType() == typeof(int[][]))
{
return(((ParamIntMat)param).getValueInSamples <T>(ignoreColumns));
}
else
{
// message and return 0
logger.Error("Could not retrieve the values (in samples) for parameter '" + paramName + "' (parameter set: '" + paramSetName + "'), the getValueInSamples functionality with ignoreColumns can only be used for matrix parameters (int[][] or double[][]). Returning 0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}
}
public T getValueInSamples <T>()
{
// message
logger.Error("Trying to retrieve the value in samples for string parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') in number of samples, cannot convert a boolean, returning 0");
// return value
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
public T getValueInSamples <T>(string paramName)
{
lock (lockParameters) {
iParam param = getParameter(paramName);
if (param == null)
{
// message
logger.Error("Could not find parameter '" + paramName + "' in parameter set '" + paramSetName + "', returning 0");
// return 0
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
// return the value
return(param.getValueInSamples <T>());
}
}
public T getValueInSamples <T>(int[] ignoreColumns)
{
Type paramType = typeof(T);
if (paramType == typeof(int[][]) || paramType == typeof(double[][]))
{
// request to return as int[][] or double[][]
// retrieve the values in samples
double[][] retValues = getValueInSamples(ignoreColumns);
// return as int[][]
if (paramType == typeof(int[][]))
{
// convert doubles to int
int[][] intRetValues = new int[retValues.Length][];
for (int c = 0; c < units.Length; c++)
{
intRetValues[c] = new int[retValues[c].Length];
for (int r = 0; r < retValues[c].Length; r++)
{
intRetValues[c][r] = (int)Math.Round(retValues[c][r]);
if (intRetValues[c][r] != retValues[c][r])
{
logger.Warn("A value in parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') was rounded from a double (" + retValues[c][r] + ") to an integer (" + intRetValues[c][r] + ") with a loss of precision, retrieve as this parameter as double[][] to retain precision");
}
}
}
// return int[][]
return((T)Convert.ChangeType(intRetValues, typeof(int[][])));
}
// return as double[][]
return((T)Convert.ChangeType(retValues, typeof(double[][])));
}
else
{
// request to return as other
// message and return 0
logger.Error("Could not retrieve the values (in samples) for parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') as '" + paramType.Name + "', can only return values as double[][] or int[][]. Returning 0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}
public T getValueInSamples <T>()
{
Type paramType = typeof(T);
if (paramType == typeof(int[]))
{
// request to return as int[]
// return value
return((T)Convert.ChangeType(getValueInSamples(), typeof(int[])));
}
else
{
// request to return as other
// message and return 0
logger.Error("Could not retrieve the values (in samples) for parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') as '" + paramType.Name + "', can only return values as int[]. Returning 0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}
public T getUnit <T>()
{
Type paramType = typeof(T);
if (paramType == typeof(Parameters.Units))
{
// request to return as Parameters.Units
// return value
return((T)Convert.ChangeType(Unit, typeof(Parameters.Units)));
}
else
{
// request to return as other
// message and return false
logger.Error("Could not retrieve the unit for parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') as '" + paramType.Name + "', can only return value as 'Parameters.Units'. Returning 0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}
public T getValue <T>()
{
Type paramType = typeof(T);
if (paramType == typeof(double))
{
// request to return as double
// return value
return((T)Convert.ChangeType(Value, typeof(double)));
}
else
{
// request to return as other
// message and return 0
logger.Error("Could not retrieve the value for parameter '" + this.Name + "' (parameter set: '" + this.getParentSetName() + "') as '" + paramType.Name + "', can only return value as double. Returning 0.0");
return((T)Convert.ChangeType(Parameters.emptyValue <T>(), typeof(T)));
}
}