public void Load(MSBuildBasedProject project, string configuration, string platform)
{
PropertyStorageLocations newLocation;
string v;
if (treatPropertyValueAsLiteral)
{
v = project.GetProperty(configuration, platform, propertyName, out newLocation);
}
else
{
v = project.GetUnevalatedProperty(configuration, platform, propertyName, out newLocation);
}
if (newLocation == PropertyStorageLocations.Unknown)
{
newLocation = defaultLocation;
}
isLoading = true;
try {
this.Value = GenericConverter.FromString(v, defaultValue);
this.Location = newLocation;
} finally {
isLoading = false;
}
}
public SupplierDto Convert(SupplierPoco source, SupplierDto destination, ResolutionContext context)
{
var gc = new GenericConverter <SupplierPoco, SupplierDto>();
var value = gc.Convert(source, destination, context);
return(value);
}
public bool Save(MSBuildBasedProject project, string configuration, string platform)
{
string newValue = GenericConverter.ToString(val);
project.SetProperty(configuration, platform, propertyName, newValue, location, treatPropertyValueAsLiteral);
return(true);
}
public void SetProperty <T>(string propertyName, T value,
bool treatPropertyValueAsLiteral,
PropertyStorageLocations location)
{
project.SetProperty(configuration, platform, propertyName,
GenericConverter.ToString(value), location, treatPropertyValueAsLiteral);
}
/// <summary>
/// Execute mapping for baseic types
/// </summary>
public void MapTypes()
{
var wkbConverter = new WellKnownBinaryConverter(this._geometryFactory);
var genericConverter = new GenericConverter();
var int32Converter = new Int32Converter();
var map = new TypeMap(DbType.Int32, typeof(uint), genericConverter);
this._typeRegister.Set(map);
map = new TypeMap(DbType.Int32, typeof(int), int32Converter);
this._typeRegister.Set(map);
map = new TypeMap(DbType.String, typeof(string), genericConverter);
this._typeRegister.Set(map);
map = new TypeMap(DbType.DateTime, typeof(DateTime), genericConverter);
this._typeRegister.Set(map);
map = new TypeMap(DbType.Binary, typeof(IMapPoint), wkbConverter);
this._typeRegister.Set(map);
map = new TypeMap(DbType.Binary, typeof(ILineString), wkbConverter);
this._typeRegister.Set(map);
map = new TypeMap(DbType.Binary, typeof(IPolygon), wkbConverter);
this._typeRegister.Set(map);
map = new TypeMap(DbType.Binary, typeof(IGeometry), wkbConverter);
this._typeRegister.Set(map);
}
public void ConvertObject_VTypeNoMismatch_ResultOk()
{
int cacheItem = 10;
int returnItem = GenericConverter.ConvertObject <int>(cacheItem);
Assert.AreEqual(cacheItem, returnItem);
}
public void TryConvertObject_RTypeMismatch_ReturnNull()
{
int cacheItem = 10;
var returnItem = GenericConverter.TryConvertObject <TestClass>(cacheItem);
Assert.AreEqual(returnItem, null);
}
public void TryConvertObject_RTypeIsNull_ReturnNull()
{
TestClass cacheItem = null;
var returnItem = GenericConverter.TryConvertObject <TestClass>(cacheItem);
Assert.IsNull(returnItem);
}
public void TryConvertObject_VTypeMismatch_ReturnZero()
{
TestClass cacheItem = new TestClass();
int returnItem = GenericConverter.TryConvertObject <int>(cacheItem);
Assert.AreEqual(returnItem, 0);
}
public void ConvertObject_RTypeNoMismatch_ReturnNull()
{
TestClass cacheItem = new TestClass();
var returnItem = GenericConverter.ConvertObject <TestClass>(cacheItem);
Assert.NotNull(returnItem);
Assert.AreEqual(returnItem.Test, cacheItem.Test);
}
public void Json(string inputFilename, string expectedOutputFilename)
{
string input = File.ReadAllText(inputFilename);
string expectedOutput = File.ReadAllText(expectedOutputFilename);
IConverter rebalanceInfoConverter = new GenericConverter <Node>(new ValveFormatParser(),
new Tf2RebalanceTransformation(new ItemInfoSource(_itemInfos),
new ClassNameSource()));
IRebalanceInfoFormatter formatter = new RebalanceInfoJsonFormatter();
IEnumerable <RebalanceInfo> rebalanceInfos = rebalanceInfoConverter.Execute(input);
string output = formatter.Create(rebalanceInfos);
Assert.AreEqual(expectedOutput, output);
}
public T GetProperty <T>(string propertyName, T defaultValue,
bool treatPropertyValueAsLiteral)
{
string v;
if (treatPropertyValueAsLiteral)
{
v = project.GetProperty(configuration, platform, propertyName);
}
else
{
v = project.GetUnevalatedProperty(configuration, platform, propertyName);
}
return(GenericConverter.FromString(v, defaultValue));
}
/// <summary>
/// Edits the specified object's value using the editor style indicated by the <see cref="M:System.Drawing.Design.UITypeEditor.GetEditStyle"/> method.
/// </summary>
/// <returns>
/// The new value of the object. If the value of the object has not changed, this should return the same object it was passed.
/// </returns>
/// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"/> that can be used to gain additional context information. </param><param name="provider">An <see cref="T:System.IServiceProvider"/> that this editor can use to obtain services. </param><param name="value">The object to edit. </param>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
AppearanceEditor editor;
if (context != null && context.Instance != null && provider != null)
{
object currentValue = value;
if (value is string)
{
var convet = new GenericConverter <MonthCalanderAppearance>();
currentValue = convet.ConvertTo(value, typeof(MonthCalanderAppearance));
}
editor = new AppearanceEditor((MonthCalanderAppearance)currentValue);
editor.ShowDialog();
value = editor.Value;
if (context.Instance is MonthCalander)
{
((MonthCalander)context.Instance).Appearance.Assign(editor.Value);
((MonthCalander)context.Instance).SetThemeDefaults();
}
}
return(value);
}
public static string[] AlteOderGeloeschteDateienLoeschenUndHochzuladendeZurueckGeben(
string gaitoBotEditorID,
DateiPublizierungsInfos[] dateien)
{
de.springwald.gaitobot.publizierung.Gaitobot_de_publizieren.DateiPublizierungsInfos[] dateien1 = GenericConverter <DateiPublizierungsInfos[], de.springwald.gaitobot.publizierung.Gaitobot_de_publizieren.DateiPublizierungsInfos[]> .ConvertTo(dateien);
return(PublizierDienst.Webdienst.AlteOderGeloeschteDateienLoeschenUndHochzuladendeZurueckGeben(gaitoBotEditorID, dateien1));
}
/// <summary>
/// Sets the value of the specified meta data item. The value is escaped before
/// setting it to ensure characters like ';' or '$' are not interpreted by MSBuild.
/// </summary>
public void SetEvaluatedMetadata <T>(string metadataName, T value)
{
SetEvaluatedMetadata(metadataName, GenericConverter.ToString(value));
}
/// <summary>
/// Gets the value of the metadata item with the specified name.
/// Returns defaultValue for non-existing meta data items.
/// </summary>
public T GetEvaluatedMetadata <T>(string metadataName, T defaultValue)
{
return(GenericConverter.FromString(GetEvaluatedMetadata(metadataName), defaultValue));
}
//static class GenericDelegate<TDelegate> where TDelegate : MulticastDelegate
//{
// // TResult F(Tuple<PhpValue, Context>, arg1, ..., argN) => value.AsCallable().Invoke(Context, new[]{ arg1, ..., argN })
// public static readonly MethodInfo/*!*/s_func = CreateFunc();
// static MethodInfo CreateFunc()
// {
// }
//}
///// <summary>
///// Converts given value to <see cref="PhpValue"/>.
///// </summary>
///// <typeparam name="T">Source CLR type.</typeparam>
///// <param name="value">Value to be converted.</param>
///// <returns>Value converted to <see cref="PhpValue"/>.</returns>
//public static PhpValue ToPhpValue<T>(this T value) => GenericConverter<T>.s_toPhpValue(value);
/// <summary>
/// Casts <see cref="PhpValue"/> to a given type <typeparamref name="T"/>.
/// Throws an exception if cast is not possible.
/// </summary>
/// <typeparam name="T">Conversion target.</typeparam>
/// <param name="value">Value to be converted.</param>
/// <returns>Value as <typeparamref name="T"/>.</returns>
public static T Cast <T>(this PhpValue value) => GenericConverter <T> .s_fromPhpValue(value);
private void ReportSelectorComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
var selectedReport = ReportSelectorComboBox.SelectedItem as LeaveAnalysis;
ReportSummaryText.Text = selectedReport.Summary;
ReportPropertyGrid.RowDefinitions.Clear();
ReportPropertyGrid.Children.Clear();
foreach (var property in selectedReport.GetType().GetProperties())
{
if (property.CanRead && property.CanWrite)
{
var foundIgnoreAttribute = false;
foreach (var attribute in property.GetCustomAttributes(false))
if (attribute.GetType() == typeof(IgnorwAnalysisPropertyAttribute))
foundIgnoreAttribute = true;
if (foundIgnoreAttribute) continue;
AnalysisPropertyConverter converter = null;
foreach (var attribute in property.GetCustomAttributes(false))
if (attribute.GetType() == typeof(AnalysisPropertyConverterAttribute))
converter = (attribute as AnalysisPropertyConverterAttribute).MakeConverter();
if (converter == null) converter = new GenericConverter(property.PropertyType);
var lambdaProperty = property;
ReportPropertyGrid.RowDefinitions.Add(new RowDefinition());
var propLabel = new Label { Content = property.Name };
Grid.SetRow(propLabel, ReportPropertyGrid.RowDefinitions.Count - 1);
Grid.SetColumn(propLabel, 0);
ReportPropertyGrid.Children.Add(propLabel);
var propEditBox = new TextBox { HorizontalAlignment = HorizontalAlignment.Stretch, VerticalAlignment = VerticalAlignment.Stretch };
Grid.SetRow(propEditBox, ReportPropertyGrid.RowDefinitions.Count - 1);
Grid.SetColumn(propEditBox, 1);
ReportPropertyGrid.Children.Add(propEditBox);
DefaultBackground = propEditBox.Background;
propEditBox.Text = converter.ConvertToString(property.GetValue(selectedReport, null));
propEditBox.TextChanged += (_sender, _args) =>
{
var value = propEditBox.Text;
try
{
var newValue = converter.ConvertFromString(value);
lambdaProperty.SetValue(selectedReport, newValue, null);
propEditBox.Background = DefaultBackground;
}
catch (Exception xp)
{
propEditBox.Background = ErrorBackground;
}
};
}
}
}
/// <summary>
/// Converts a value to the specified type
/// </summary>
/// <param name="value">The value to convert</param>
/// <param name="targetType">The type to which the value should be converted</param>
/// <param name="targetDefaultValue">The default value to use instead of null or DBNull.Value</param>
/// <param name="format">The format used for conversion</param>
/// <param name="conversionObserver">Conversion observer</param>
/// <returns>The converted value</returns>
public static object Convert(object value, Type targetType, object targetDefaultValue, IFormatProvider format, IConversionObserver conversionObserver)
{
if (targetType == null)
{
throw new ArgumentNullException("targetType");
}
TypeInfo targetTypeInfo = targetType.GetTypeInfo();
if (targetTypeInfo == null)
{
throw new ArgumentException(string.Format("Unable to get type information for type {0}", targetType));
}
if (targetTypeInfo.IsValueType && ((targetDefaultValue == null) || (ConversionsHelper.IsDBNull(targetDefaultValue))))
{
// converting to a value type, but having the default value as null / DBNull
targetDefaultValue = ConversionsHelper.GetDefaultValue(targetType);
}
if ((value == null) || ConversionsHelper.IsDBNull(value) || ConversionsHelper.IsStringEmptyOrWhitespace(value))
{
// converting null / DBNull / empty or whitespaces-only string to target type => just return default value
if(conversionObserver != null)
{
conversionObserver.NotifyKnownFallbackToDefaultValue(
value: value,
targetType: targetType,
defaultTargetValue: targetDefaultValue,
format: format,
fallbackReason: new ArgumentNullException("value"));
}
return targetDefaultValue;
}
object converted = targetDefaultValue;
try
{
// Handle Nullable<T>: try to convert to underlying T
bool targetIsGenericType = ConversionsHelper.IsGenericType(targetTypeInfo);
if (targetIsGenericType)
{
Type nullableTypeArg;
if (ConversionsHelper.TryParseNullableType(targetType, out nullableTypeArg))
{
targetType = nullableTypeArg;
}
}
var bootstrapper = Converter.Settings.SpecializedConversionsBootstrapper;
if (bootstrapper == null)
{
bootstrapper = new DefaultSpecializedConversionsBootstrapper();
}
var converter = SpecializedConverterLocator.GetSpecializedConverter(value.GetType(), targetType, bootstrapper.DiscoveredSpecializedConverters);
if (converter == null)
{
converter = new GenericConverter(targetType);
}
converted = converter.Convert(value, targetDefaultValue, format, conversionObserver);
}
catch (Exception ex)
{
if (
// Convert.ChangeType may throw InvalidCastException when:
// - This conversion is not supported OR
// - value is null and conversionType is a value type OR
// - value does not implement the IConvertible interface
(ex is InvalidCastException) ||
// Convert.ChangeType may throw FormatException when :
// - value is not in a format for conversionType recognized by provider.
(ex is FormatException) ||
// Convert.ChangeType may throw OverflowException when:
// - value represents a number that is out of the range of conversionType.
// - or -
// Enum.Parse may throw OverflowException when:
// - value is outside the range of the underlying type of enumType
(ex is OverflowException) ||
// Convert.ChangeType may throw ArgumentNullException when :
// - conversionType is null.
// - or -
// Enum.IsDefined may throw System.ArgumentNullException when:
// - enumType or value is null
// - or -
// Enum.Parse may throw ArgumentNullException when :
// - enumType or value is null.
(ex is ArgumentNullException) ||
// Enum.IsDefined may throw System.ArgumentException when:
// - enumType is not an Enum.
// - The type of value is an enumeration, but it is not an enumeration of type enumType.
// - The type of value is not an underlying type of enumType.
// - or -
// Enum.Parse may throw ArgumentException when:
// - enumType is not an Enum
// - value is either an empty string or only contains white space
// - value is a name, but not one of the named constants defined for the enumeration
(ex is ArgumentException) ||
// Enum.IsDefined may throwSystem.InvalidOperationException when:
// - value is not type System.SByte, System.Int16, System.Int32, System.Int64, System.Byte, System.UInt16, System.UInt32, or System.UInt64, or System.String.
(ex is InvalidOperationException))
{
if (conversionObserver != null)
{
conversionObserver.NotifyCaughtConversionException(
value: value,
targetType: targetType,
defaultTargetValue: targetDefaultValue,
format: format,
conversionException: ex);
}
}
else
{
throw;
}
}
return converted;
}
public static T Get <T>(string key)
{
var retObj = GetInstance()[key];
return(GenericConverter.ConvertObject <T>(retObj));
}
/// <summary>
/// Converts a value to the specified type
/// </summary>
/// <param name="value">The value to convert</param>
/// <param name="targetType">The type to which the value should be converted</param>
/// <param name="targetDefaultValue">The default value to use instead of null or DBNull.Value</param>
/// <param name="format">The format used for conversion</param>
/// <param name="conversionObserver">Conversion observer</param>
/// <returns>The converted value</returns>
public static object Convert(object value, Type targetType, object targetDefaultValue, IFormatProvider format, IConversionObserver conversionObserver)
{
if (targetType == null)
{
throw new ArgumentNullException("targetType");
}
TypeInfo targetTypeInfo = targetType.GetTypeInfo();
if (targetTypeInfo == null)
{
throw new ArgumentException(string.Format("Unable to get type information for type {0}", targetType));
}
if (targetTypeInfo.IsValueType && ((targetDefaultValue == null) || (ConversionsHelper.IsDBNull(targetDefaultValue))))
{
// converting to a value type, but having the default value as null / DBNull
targetDefaultValue = ConversionsHelper.GetDefaultValue(targetType);
}
if ((value == null) || ConversionsHelper.IsDBNull(value) || ConversionsHelper.IsStringEmptyOrWhitespace(value))
{
// converting null / DBNull / empty or whitespaces-only string to target type => just return default value
if (conversionObserver != null)
{
conversionObserver.NotifyKnownFallbackToDefaultValue(
value: value,
targetType: targetType,
defaultTargetValue: targetDefaultValue,
format: format,
fallbackReason: new ArgumentNullException("value"));
}
return(targetDefaultValue);
}
object converted = targetDefaultValue;
try
{
// Handle Nullable<T>: try to convert to underlying T
bool targetIsGenericType = ConversionsHelper.IsGenericType(targetTypeInfo);
if (targetIsGenericType)
{
Type nullableTypeArg;
if (ConversionsHelper.TryParseNullableType(targetType, out nullableTypeArg))
{
targetType = nullableTypeArg;
}
}
var bootstrapper = Converter.Settings.SpecializedConversionsBootstrapper;
if (bootstrapper == null)
{
bootstrapper = new DefaultSpecializedConversionsBootstrapper();
}
var converter = SpecializedConverterLocator.GetSpecializedConverter(value.GetType(), targetType, bootstrapper.DiscoveredSpecializedConverters);
if (converter == null)
{
converter = new GenericConverter(targetType);
}
converted = converter.Convert(value, targetDefaultValue, format, conversionObserver);
}
catch (Exception ex)
{
if (
// Convert.ChangeType may throw InvalidCastException when:
// - This conversion is not supported OR
// - value is null and conversionType is a value type OR
// - value does not implement the IConvertible interface
(ex is InvalidCastException) ||
// Convert.ChangeType may throw FormatException when :
// - value is not in a format for conversionType recognized by provider.
(ex is FormatException) ||
// Convert.ChangeType may throw OverflowException when:
// - value represents a number that is out of the range of conversionType.
// - or -
// Enum.Parse may throw OverflowException when:
// - value is outside the range of the underlying type of enumType
(ex is OverflowException) ||
// Convert.ChangeType may throw ArgumentNullException when :
// - conversionType is null.
// - or -
// Enum.IsDefined may throw System.ArgumentNullException when:
// - enumType or value is null
// - or -
// Enum.Parse may throw ArgumentNullException when :
// - enumType or value is null.
(ex is ArgumentNullException) ||
// Enum.IsDefined may throw System.ArgumentException when:
// - enumType is not an Enum.
// - The type of value is an enumeration, but it is not an enumeration of type enumType.
// - The type of value is not an underlying type of enumType.
// - or -
// Enum.Parse may throw ArgumentException when:
// - enumType is not an Enum
// - value is either an empty string or only contains white space
// - value is a name, but not one of the named constants defined for the enumeration
(ex is ArgumentException) ||
// Enum.IsDefined may throwSystem.InvalidOperationException when:
// - value is not type System.SByte, System.Int16, System.Int32, System.Int64, System.Byte, System.UInt16, System.UInt32, or System.UInt64, or System.String.
(ex is InvalidOperationException))
{
if (conversionObserver != null)
{
conversionObserver.NotifyCaughtConversionException(
value: value,
targetType: targetType,
defaultTargetValue: targetDefaultValue,
format: format,
conversionException: ex);
}
}
else
{
throw;
}
}
return(converted);
}
public void ConvertObject_RTypeMismatch_ReturnNull()
{
int cacheItem = 10;
Assert.Throws <InvalidCastException>(() => GenericConverter.ConvertObject <TestClass>(cacheItem));
}
public void ConvertObject_VTypeMismatch_ThrowsException()
{
TestClass cacheItem = new TestClass();
Assert.Throws <InvalidCastException>(() => GenericConverter.ConvertObject <int>(cacheItem));
}
