/// <summary>
/// Load a record of parameters from the configured <see cref="IValuesReader">reader</see> using the key provided, and set value of the properties.
/// All properties are set.
/// </summary>
/// <param name="parametersKey">Parameters key of the record to load</param>
public void LoadParameters(string parametersKey /*, params KeyValuePair<string, string>[] varInfoNamesToIgnore*/)
{
if (_containingObject == null)
{
throw new Exception("The ContainingObject is not configured");
}
if (_reader == null)
{
throw new Exception("The reader is not configured");
}
_parametersSet = _reader.ReadValues();
var varInfoValues = _parametersSet.Values.Where(kv => kv.Key.Name.Equals(parametersKey)).SingleOrDefault();
if (varInfoValues.Key == null)
{
throw new Exception("The parameters key '" + parametersKey + "' is not present.");
}
if (varInfoValues.Value == null)
{
throw new Exception("Values set for the parameters key '" + parametersKey + "' is null.");
}
foreach (var keyAndValue in varInfoValues.Value)
{
var varInfo = keyAndValue.Key;
//if (!varInfoNamesToIgnore.Contains(new KeyValuePair<string, string>(parametersKey, varInfo.Name)))
//{
/*dfuma 2/oct/2012 - added check of the presence of the parameter in the properties description parameters list - new START */
PropertyInfo propertyInfo;
if (!_containingObject.PropertiesDescription.TryGetValue(varInfo.Name, out propertyInfo))
{
//suppress any error in case of looking for a parameter that is not defined in the parameters class
continue;
//throw new Exception("Property '" + varInfo.Name + " not found in the properties list of class " + _containingObject.GetType());
}
/*dfuma 2/oct/2012 - new END*/
/*dfuma 2/oct/2012 - added check of the presence of the parameter in the properties description parameters list - old START
* var propertyInfo = _containingObject.PropertiesDescription[varInfo.Name];
* dfuma 2/oct/2012 - old END*/
if (propertyInfo.PropertyType != varInfo.ValueType.TypeForCurrentValue)
{
throw new Exception("Type for property '" + propertyInfo.Name + "' (" + propertyInfo.PropertyType + ") is not coherent with the corresponding " +
"VarInfo type (" + varInfo.ValueType.TypeForCurrentValue + ")");
}
var setMethod = propertyInfo.GetSetMethod();
try
{
setMethod.Invoke(_containingObject,
new object[]
{ varInfo.ValueType.Converter.GetParsedValueFromMPE(keyAndValue.Value) });
}catch (Exception e)
{
throw new ArgumentException("Error reading VarInfo '" + keyAndValue.Key.Name + "' (parameters key '" + parametersKey + "'):" + e.Message, e);
}
//}
}
}
/// <summary>
/// Reads the values of parameter sets from the form of persistence.
/// </summary>
/// <returns>instance of <see cref="IParametersSet"> parameters set</see></returns>
public IParametersSet ReadValues()
{
// call the abstract version and store the list of parameter key values
IParametersSet _parameterSet = InternalReadValues();
_parameterKeyValues = _parameterSet.Values.Select(kvp => kvp.Key.Name).ToList();
return(_parameterSet);
}
/// <summary>
/// Writes the parameters values to the xml file.
/// </summary>
/// <param name="e">set to write</param>
/// <exception cref="ArgumentNullException">The argument is null.</exception>
/// <exception cref="InvalidOperationException">Data path has not been
/// defined.</exception>
/// <exception cref="IOException">An I/O error is occured.</exception>
public void WriteValues(IParametersSet e)
{
// Check arguments
if (e == null)
{
throw new ArgumentNullException();
}
WriteValues(e, (new List <IKeyValue>(e.Values.Keys)).ToArray());
}
/// <summary>
/// Save the current value of class properties to overwrite the record of variables identified by the parameters key.
/// It uses the configured <see cref="IValuesWriter">writer</see>.
/// </summary>
/// <param name="parametersKey">Parameters key of the record to save</param>
public string SaveParameters(string parametersKey)
{
string returnMessage = null;
if (_containingObject == null)
{
throw new Exception("The ContainingObject is not configured");
}
//if (_parametersSet == null) throw new Exception("The parameters set is not defined: invoke 'LoadParameters()' first.");
if (_writer == null)
{
throw new Exception("The writer is not configured");
}
if (_reader == null)
{
throw new Exception("The reader is not configured");
}
_parametersSet = _reader.ReadValues();
IKeyValue keyValue = _parametersSet.Values.Keys.Where(k => k.Name.Equals(parametersKey)).SingleOrDefault();
if (keyValue == null)
{
int maxId = 0;
if (_parametersSet.Values.Count > 0)
{
maxId = _parametersSet.Values.Keys.Select(k => k.Id).Max();
}
keyValue = DataTypeFactory.NewKeyValue(maxId + 1, parametersKey, parametersKey);
_parametersSet.Values.Add(keyValue, new Dictionary <VarInfo, List <string> >());
foreach (var varInfo in _parametersSet.Parameters)
{
_parametersSet.Values[keyValue].Add(varInfo, null);
}
}
else
{
returnMessage = "Overwriting key value '" + parametersKey + "'.";
}
foreach (var varInfo in _parametersSet.Parameters)
{
PropertyInfo propertyInfo = _containingObject.PropertiesDescription[varInfo.Name];
if (propertyInfo.PropertyType != varInfo.ValueType.TypeForCurrentValue)
{
throw new Exception("Type for property '" + propertyInfo.Name + "' (" + propertyInfo.PropertyType + ") is not coherent with the corresponding " +
"VarInfo type (" + varInfo.ValueType.TypeForCurrentValue + ")");
}
MethodInfo getMethod = propertyInfo.GetGetMethod();
object propertyValue = getMethod.Invoke(_containingObject, new object[0]);
List <string> serializedValue = varInfo.ValueType.Converter.ParseValueForMPE(propertyValue);
_parametersSet.Values[keyValue][varInfo] = serializedValue;
}
_writer.WriteValues(_parametersSet);
return(returnMessage);
}
/// <summary>
/// Returns the list of VarInfo objects representing the parameters of the parameters class by using the currently selected <see cref="IValuesReader">IValuesReader</see> .
/// Reader must be alredy set before invoking this method.
/// </summary>
/// <param name="parameterClass"></param>
/// <returns></returns>
public static ReadOnlyCollection <VarInfo> GetParameters(this IParameters parameterClass)
{
KeyValuePair <IValuesReader, ReadOnlyCollection <VarInfo> > parametersKVP;
bool found = _cachedVarInfoLists.TryGetValue(parameterClass, out parametersKVP);
if (found && parameterClass.Reader != parametersKVP.Key)
{
_cachedVarInfoLists.Remove(parameterClass);
found = false;
}
if (!found)
{
if (parameterClass.Reader == null)
{
throw new ArgumentNullException("Cannot retrieve parameters if the Reader is not configured.");
}
List <VarInfo> listVarInfo = new List <VarInfo>();
IParametersSet parametersSet = parameterClass.Reader.ReadValues();
foreach (VarInfo originalVarInfo in parametersSet.Values.First().Value.Select(p => p.Key))
{
try
{
PropertyInfo property = parameterClass.PropertiesDescription[originalVarInfo.Name];
SetPropertyVarInfo wrappingVarInfo = new SetPropertyVarInfo(parameterClass, property)
{
DefaultValue = originalVarInfo.DefaultValue,
Description = originalVarInfo.Description,
Id = originalVarInfo.Id,
MaxValue = originalVarInfo.MaxValue,
MinValue = originalVarInfo.MinValue,
Name = originalVarInfo.Name,
Size = originalVarInfo.Size,
Units = originalVarInfo.Units,
URL = originalVarInfo.URL,
ValueType = originalVarInfo.ValueType,
VarType = originalVarInfo.VarType
};
listVarInfo.Add(wrappingVarInfo);
}catch (KeyNotFoundException)
{
//suppress any error in case of looking for a parameter that is not defined in the parameters class
//TODO: must be managed better, for example launching a proper exception
}
}
parametersKVP = new KeyValuePair <IValuesReader, ReadOnlyCollection <VarInfo> >(parameterClass.Reader, new ReadOnlyCollection <VarInfo>(listVarInfo));
_cachedVarInfoLists.Add(parameterClass, parametersKVP);
}
return(parametersKVP.Value);
}
/// <summary>
/// Writes the parameters values only for specified key values to the xml file.
/// </summary>
/// <param name="e">set to write</param>
/// <param name="keyValues">key values to write</param>
/// <exception cref="ArgumentNullException">The argument is null.
/// </exception>
/// <exception cref="InvalidOperationException">Data path has not been
/// defined.</exception>
/// <exception cref="IOException">An I/O error is occured.</exception>
public void WriteValues(IParametersSet e, IKeyValue[] keyValues)
{
// Check arguments
if ((e == null) || (keyValues == null))
{
throw new ArgumentNullException();
}
// If there is no key value to write, return
if (keyValues.Length == 0)
{
return;
}
XmlTextWriter xwriter = null;
try
{
// Write Xml document
if (Directory.Exists(FilePath))
{
xwriter = new XmlTextWriter(FilePath + Path.DirectorySeparatorChar +
e.Descriptor.Component + "_" + e.Descriptor.Model + ".xml",
System.Text.Encoding.UTF8);
}
/* 11/6/2012 - DFa - Dependency Injection - begin */
else if (File.Exists(FilePath))
{
if (File.Exists(FilePath))
{
xwriter = new XmlTextWriter(FilePath,
System.Text.Encoding.UTF8);
}
}
/* 11/6/2012 - DFa - Dependency Injection - end */
else
{
xwriter = new XmlTextWriter(FilePath, System.Text.Encoding.UTF8);
}
xwriter.Formatting = Formatting.Indented;
xwriter.WriteStartDocument(true);
// Write start element
xwriter.WriteStartElement(DOCUMENT_NAME);
// Write the description
xwriter.WriteStartElement(E_DESCRIPTION);
xwriter.WriteElementString(E_DESC_E_NAMESPACE, e.Descriptor.Component);
xwriter.WriteElementString(E_DESC_E_TYPENAME, e.Descriptor.Model);
xwriter.WriteElementString(E_DESC_E_URL, e.Descriptor.URL);
xwriter.WriteElementString(E_DESC_E_PARAMETER_KEY, e.Descriptor.KeyType);
xwriter.WriteElementString(E_DESC_E_DESCRIPTION, e.Descriptor.Description);
xwriter.WriteEndElement();
// Write parameters
xwriter.WriteStartElement(E_VARINFO_ATTRIBUTES);
foreach (VarInfo vInfo in e.Parameters)
{
xwriter.WriteStartElement(E_VIATT_E_VARINFO);
xwriter.WriteAttributeString(E_VIATT_E_VARINFO_A_NAME, vInfo.Name);
xwriter.WriteElementString(E_VIATT_E_DESCRIPTION, vInfo.Description);
xwriter.WriteElementString(E_VIATT_E_MAXVALUE,
vInfo.MaxValue.ToString(NumberFormatInfo.InvariantInfo));
xwriter.WriteElementString(E_VIATT_E_MINVALUE,
vInfo.MinValue.ToString(NumberFormatInfo.InvariantInfo));
xwriter.WriteElementString(E_VIATT_E_DEFAULTVALUE,
vInfo.DefaultValue.ToString(NumberFormatInfo.InvariantInfo));
xwriter.WriteElementString(E_VIATT_E_TYPE, vInfo.ValueType.Converter.GetTypeNameRepresentation(vInfo.Size));
xwriter.WriteElementString(E_VIATT_E_UNITS, vInfo.Units);
xwriter.WriteElementString(E_VIATT_E_URL, vInfo.URL);
xwriter.WriteEndElement();
}
xwriter.WriteEndElement();
// Write values
xwriter.WriteStartElement(E_VALUES);
foreach (IKeyValue kv in keyValues)
{
xwriter.WriteStartElement(E_VALS_E_KEYVALUE);
xwriter.WriteAttributeString(E_VALS_E_KEYVALUE_A_NAME, kv.Name);
xwriter.WriteElementString(E_VALS_E_KV_E_DESCRIPTION, kv.Description);
foreach (VarInfo param in e.Values[kv].Keys)
{
IVarInfoConverter converter = param.ValueType.Converter;
xwriter.WriteRaw(converter.ParseValue(converter.GetParsedValueFromMPE(e.Values[kv][param]), param.Name).ToString());
}
xwriter.WriteEndElement();
}
xwriter.WriteEndElement();
xwriter.WriteEndElement();
}
catch (Exception ex)
{
throw new InvalidOperationException(ex.Message, ex);
}
finally
{
// Closes writer
xwriter.Close();
}
}
public bool Equals(IParametersSet other)
{
return(other.Descriptor.Component.Equals(Descriptor.Component) &&
other.Descriptor.Model.Equals(Descriptor.Model));
}
