/// <summary>
/// Gets short description for operation..
/// </summary>
/// <param name="operation">Operation to describe.</param>
/// <returns>Operation description.</returns>
public static string GetShortDescription(UltimaPacketFilterTypeOperation operation)
{
string start = "{0} ";
switch (operation)
{
case UltimaPacketFilterTypeOperation.Greater: return(start + "> {1}");
case UltimaPacketFilterTypeOperation.Lesser: return(start + "< {1}");
case UltimaPacketFilterTypeOperation.Contains: return(start + "\u2208 {1}");
case UltimaPacketFilterTypeOperation.In: return(start + "\u220B {1}");
}
return(null);
}
/// <summary>
/// Gets long description for operation..
/// </summary>
/// <param name="operation">Operation to describe.</param>
/// <returns>Operation description.</returns>
public static string GetLongDescription(UltimaPacketFilterTypeOperation operation)
{
string start = "Packet is visible if value of the property {0} ";
switch (operation)
{
case UltimaPacketFilterTypeOperation.Greater: return(start + "is more than {1}");
case UltimaPacketFilterTypeOperation.Lesser: return(start + "is less than {1}");
case UltimaPacketFilterTypeOperation.Contains: return(start + "contains one of the values in {1}");
case UltimaPacketFilterTypeOperation.In: return(start + "is in {1}");
}
return(null);
}
/// <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));
}
}
/// <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);
}
private static void Definition_Changed(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
UltimaPacketFilterProperty property = d as UltimaPacketFilterProperty;
if (property != null)
{
property._Code = Type.GetTypeCode(property.Definition.Info.PropertyType);
// Check operation
if (property.Definition != null)
{
UltimaPacketFilterTypeOperation operation = UltimaPacketFilterTypeOperation.Greater;
if (!UltimaPacketFilterParser.IsValidOperation(property.Definition, property.Operation, ref operation))
{
property.Operation = operation;
}
}
property.Validate();
}
}
/// <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);
}
/// <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);
}
/// <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);
}
