/// <summary>
/// Gets a list of operations supported by specific type.
/// </summary>
/// <param name="property">Property to get operations for.</param>
/// <returns>Array of operations.</returns>
public static UltimaPacketFilterTypeOperation[] GetTypeOperations(UltimaPacketPropertyDefinition property)
{
List <UltimaPacketFilterTypeOperation> operations = new List <UltimaPacketFilterTypeOperation>();
TypeCode code = Type.GetTypeCode(property.Info.PropertyType);
switch (code)
{
case TypeCode.Boolean: return(_BooleanOperations);
case TypeCode.Byte:
case TypeCode.Char:
case TypeCode.Decimal:
case TypeCode.Double:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.SByte:
case TypeCode.Single:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64: return(_NumberOperations);
case TypeCode.String: return(_StringOperations);
}
return(null);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
UltimaPacketPropertyDefinition definition = parameter as UltimaPacketPropertyDefinition;
if (definition != null)
{
return(UltimaPacketFilterParser.GetTypeOperations(definition));
}
return(null);
}
/// <summary>
/// Gets short composed filter.
/// </summary>
/// <param name="property">Filter property.</param>
/// <param name="operation">Filter operation.</param>
/// <param name="value">Filter value.</param>
/// <returns>Composed filter.</returns>
public static string GetComposedFilter(UltimaPacketPropertyDefinition property, UltimaPacketFilterTypeOperation operation, string value)
{
string format = GetShortDescription(operation);
if (format != null)
{
return(String.Format(format, property, value));
}
return(null);
}
private void UpdateSample()
{
UltimaPacketFilterProperty filter = Filters.SelectedValue as UltimaPacketFilterProperty;
UltimaPacketPropertyDefinition property = Definition.SelectedValue as UltimaPacketPropertyDefinition;
UltimaPacketFilterTypeOperation?operation = Operation.SelectedValue as UltimaPacketFilterTypeOperation?;
if (filter != null && property != null && operation != null)
{
SampleValue.Text = UltimaPacketFilterParser.GetSample(property, (UltimaPacketFilterTypeOperation)operation, false);
Sample.Text = UltimaPacketFilterParser.GetComposedSample(property, (UltimaPacketFilterTypeOperation)operation, false, false);
}
}
/// <summary>
/// Gets sample for property.
/// </summary>
/// <param name="property">Property definition.</param>
/// <param name="operation">Property operation.</param>
/// <param name="alternate">Determines whether to compose alternate sample.</param>
/// <returns>Composed sample.</returns>
public static string GetSample(UltimaPacketPropertyDefinition property, UltimaPacketFilterTypeOperation operation, bool alternate)
{
TypeCode code = Type.GetTypeCode(property.Info.PropertyType);
if (operation == UltimaPacketFilterTypeOperation.Contains || operation == UltimaPacketFilterTypeOperation.In)
{
return(GetSampleList(code));
}
else if (alternate)
{
return(GetSampleOne(code));
}
else
{
return(GetSampleTwo(code));
}
}
private void Definition_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
UltimaPacketFilterProperty filter = Filters.SelectedValue as UltimaPacketFilterProperty;
UltimaPacketPropertyDefinition property = Definition.SelectedValue as UltimaPacketPropertyDefinition;
if (property != null)
{
Operation.ItemsSource = UltimaPacketFilterParser.GetTypeOperations(property);
}
if (filter != null)
{
Operation.SelectedValue = null;
Operation.SelectedValue = filter.Operation;
}
UpdateSample();
}
/// <summary>
/// Determines if operation is valid for sepecific property.
/// </summary>
/// <param name="property">Property to check for.</param>
/// <param name="operation">Operation to validate.</param>
/// <param name="first">First valid operation if operation is not valid.</param>
/// <returns>True if valid, false otherwise.</returns>
public static bool IsValidOperation(UltimaPacketPropertyDefinition property, UltimaPacketFilterTypeOperation operation, ref UltimaPacketFilterTypeOperation first)
{
UltimaPacketFilterTypeOperation[] validOperations = GetTypeOperations(property);
if (validOperations != null)
{
foreach (UltimaPacketFilterTypeOperation typeOperation in validOperations)
{
if (operation == typeOperation)
{
return(true);
}
}
first = validOperations[0];
return(false);
}
return(false);
}
/// <summary>
/// Gets sample description for property.
/// </summary>
/// <param name="property">Property definition.</param>
/// <param name="operation">Property operation.</param>
/// <param name="shorty">Determines whether to compose short sample.</param>
/// <param name="alternate">Determines whether to compose alternate sample.</param>
/// <returns>Composed sample.</returns>
public static string GetComposedSample(UltimaPacketPropertyDefinition property, UltimaPacketFilterTypeOperation operation, bool shorty, bool alternate)
{
string format = null;
if (shorty)
{
format = GetShortDescription(operation);
}
else
{
format = GetLongDescription(operation);
}
if (format != null)
{
TypeCode code = Type.GetTypeCode(property.Info.PropertyType);
string sample = null;
if (operation == UltimaPacketFilterTypeOperation.Contains || operation == UltimaPacketFilterTypeOperation.In)
{
sample = GetSampleList(code);
}
else if (alternate)
{
sample = GetSampleOne(code);
}
else
{
sample = GetSampleTwo(code);
}
if (sample != null)
{
return(String.Format(format, property, sample));
}
}
return(null);
}
/// <summary>
/// Tries to parse string into specific type based on operation.
/// </summary>
/// <param name="value">Value to parse.</param>
/// <param name="property">Property to parse to.</param>
/// <param name="operation">Operation to parse for.</param>
/// <param name="result">Result.</param>
/// <returns>True if successful, false otherwise.</returns>
public static bool TryParse(string value, UltimaPacketPropertyDefinition property, UltimaPacketFilterTypeOperation operation, out object result)
{
result = null;
if (String.IsNullOrEmpty(value))
{
return(false);
}
TypeCode code = Type.GetTypeCode(property.Info.PropertyType);
switch (operation)
{
case UltimaPacketFilterTypeOperation.Greater:
case UltimaPacketFilterTypeOperation.Lesser:
{
return(TryParseSingle(value, code, ref result));
}
case UltimaPacketFilterTypeOperation.Contains:
case UltimaPacketFilterTypeOperation.In:
{
string[] split = value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (split.Length > 0)
{
switch (code)
{
case TypeCode.Boolean: result = TryParseList <Boolean>(split); break;
case TypeCode.Char: result = TryParseList <Char>(split); break;
case TypeCode.Byte: result = TryParseList <Byte>(split); break;
case TypeCode.Decimal: result = TryParseList <Decimal>(split); break;
case TypeCode.Double: result = TryParseList <Double>(split); break;
case TypeCode.Int16: result = TryParseList <Int16>(split); break;
case TypeCode.Int32: result = TryParseList <Int32>(split); break;
case TypeCode.Int64: result = TryParseList <Int64>(split); break;
case TypeCode.SByte: result = TryParseList <SByte>(split); break;
case TypeCode.Single: result = TryParseList <Single>(split); break;
case TypeCode.String: result = TryParseList <String>(split); break;
case TypeCode.UInt16: result = TryParseList <UInt16>(split); break;
case TypeCode.UInt32: result = TryParseList <UInt32>(split); break;
case TypeCode.UInt64: result = TryParseList <UInt64>(split); break;
}
if (result != null)
{
return(true);
}
}
return(false);
}
}
return(false);
}
