public void Add(RangeTypes type)
{
if(RangeTypes.None >= type || RangeTypes.InvalidRangeType <= type)
return;
this.List.Add(type);
}
private void cbbRangeType_SelectedIndexChanged(object sender, EventArgs e)
{
if (DesignMode || LicenseManager.UsageMode == LicenseUsageMode.Designtime || currentDate == DateTime.MinValue)
{
return;
}
rangeType = eRangeTypeManager.GetValue();
SetDate();
}
private void ApplyRules(string content, RangeTypes rangeType)
{
foreach(WsScanRule rule in m_scanRules)
{
if((rule.Ranges.Count != 0) && (!rule.Ranges.Contains(rangeType)))
continue;
m_results.Add(rangeType, rule.Condition, rule.Apply(content));
}
}
internal WsMatchInRangeCollection GetMatches(RangeTypes type, string condition)
{
WsMatchInRangeCollection matches = new WsMatchInRangeCollection();
foreach(WsMatchInRange match in this.List)
{
if(type == match.RangeType && condition == match.Condition)
matches.Add(match);
}
return matches;
}
internal void Add(RangeTypes rangeType, string condition, ArrayList matches)
{
this.List.Add(new WsMatchInRange(rangeType, condition, matches));
m_totalMatchCount += matches.Count;
foreach(string match in matches)
{
if(m_rawList.ContainsKey(match))
m_rawList[match] = Convert.ToInt32(m_rawList[match])+1;
else
m_rawList.Add(match, 1);
}
}
internal WsMatchInRange(RangeTypes rangeType, string condition, ArrayList matches)
{
m_rangeType = rangeType;
m_matches = new Hashtable();
m_totalCount = matches.Count;
m_condition = condition;
foreach(string match in matches)
{
if(!m_matches.ContainsKey(match))
m_matches.Add(match, 1);
else
m_matches[match] = Convert.ToInt32(m_matches[match]) + 1;
}
}
/// <summary>
/// Creates a new color range from memory.
/// </summary>
/// <param name="buffer">A <see cref="byte"/> array that contains the <see cref="ColorRange"/> data.</param>
public ColorRange(byte[] buffer)
{
if (buffer.Length != SIZE)
{
throw new ArgumentOutOfRangeException($"The buffer must be contains a {SIZE} array length.");
}
using (var stream = new BinaryReader(new MemoryStream(buffer)))
{
this.colors = (RangeColors)stream.ReadByte();
this.type = (RangeTypes)stream.ReadByte();
this.isFixed = stream.ReadBoolean();
this.blackColor = stream.ReadByte();
this._rangeColors = stream.ReadBytes(LENGTH);
}
}
private RangeParseResult ParseRangeGroup(IEnumerator <Lexem> tokens, string context)
{
Type rangeType = null;
while (tokens.Current.NextLexem != null && RangeTypes.Contains(tokens.Current.NextLexem.Value))
{
rangeType = ParseRangeType(tokens, context: context);
}
if (rangeType == null)
{
ExpectNextToken(tokens, RangeTypes, context);
}
return(ParseRangeGroupContents(tokens, rangeType, context));
}
public override string ToString()
{
return "QueryPlanIndexItemForge{" +
"unique=" +
IsUnique +
", hashProps=" +
HashProps.RenderAny() +
", rangeProps=" +
RangeProps.RenderAny() +
", hashTypes=" +
HashTypes.RenderAny() +
", rangeTypes=" +
RangeTypes.RenderAny() +
", advanced=" +
AdvancedIndexProvisionDesc?.IndexDesc.IndexTypeName +
"}";
}
/// <summary>
/// Creates a new <see cref="ColorRange"/> instance with default values.
/// </summary>
/// <param name="startColorIndex">The start color index to setup the range.</param>
/// <remarks>By default, when initialize the 16 ranges in a <see cref="PAL"/>,
/// the idea is create a ramp values from 0 to 255 values and repeat until completes all 16 ranges.
/// This process is automatically setup in <see cref="ColorRangeTable"/> default constructor.</remarks>
public ColorRange(ref byte startColorIndex)
{
this.colors = DEFAULT_RANGE_COLORS;
this.type = DEFAULT_TYPE;
this.isFixed = DEFAULT_FIXED_STATE;
this.blackColor = DEFAULT_BLACK_COLOR;
this._rangeColors = new byte[LENGTH];
byte range = startColorIndex;
for (int i = 0; i < LENGTH; i++)
{
this._rangeColors[i] = range;
if (++range > byte.MaxValue)
{
range = 0;
}
}
startColorIndex = range;
}
private RangeParseResult ParseRangeGroupContents(IEnumerator <Lexem> tokens, Type rangeType, string context)
{
List <object> minimumValues = new List <object>();
List <object> maximumValues = new List <object>();
var range = ParseRange(tokens, rangeType, context: context);
minimumValues.AddRange(range.Select(r => r.Item1));
maximumValues.AddRange(range.Select(r => r.Item2));
if (tokens.Current.NextLexem != null)
{
RangeParseResult nextRange = null;
if (tokens.Current.NextLexem.Value == "(")
{
nextRange = ParseRangeGroupContents(tokens, rangeType, context);
}
else if (RangeTypes.Contains(tokens.Current.NextLexem.Value))
{
nextRange = ParseRangeGroup(tokens, context);
if (!nextRange.Type.Equals(rangeType))
{
throw new InvalidDataException("Non-uniform ranges are not supported. First encountered range: " + TypeToRangeDescription(rangeType) + ", next: " + TypeToRangeDescription(nextRange.Type));
}
}
if (nextRange != null)
{
minimumValues.AddRange(nextRange.MinimumValues);
maximumValues.AddRange(nextRange.MaximumValues);
}
}
return(new RangeParseResult()
{
Type = rangeType, MinimumValues = minimumValues, MaximumValues = maximumValues
});
}
public static void ParseOptionalFields(EmoteType type, string fields, Dictionary <EmoteField, string> fieldDict)
{
DefaultFields.TryGetValue(type, out var defaultFields);
if (defaultFields == null)
{
Console.WriteLine($"ParseOptionalFields({type}): couldn't find default field for {type}");
return;
}
// custom parsers
var tokens = new List <string>()
{
fields
};
if (defaultFields.Count > 1)
{
tokens = GetSubTokens(fields);
if (tokens.Count > defaultFields.Count)
{
Console.WriteLine($"Warning: ParseOptionalFields({type}): {fields} contains more than default # of fields");
}
}
for (var i = 0; i < tokens.Count && i < defaultFields.Count; i++)
{
var token = tokens[i];
var defaultField = defaultFields[i];
switch (defaultField)
{
case EmoteField.Amount:
var amount = token;
if (token.Equals("false", StringComparison.OrdinalIgnoreCase))
{
amount = "0";
}
else if (token.Equals("true", StringComparison.OrdinalIgnoreCase))
{
amount = "1";
}
fieldDict.Add(EmoteField.Amount, amount);
break;
case EmoteField.CharacterTitle:
var title = Parser.TryParseCharacterTitle(token);
if (title != null)
{
fieldDict.Add(EmoteField.Amount, ((int)title).ToString());
}
break;
case EmoteField.PropertyAttributeStat:
var propAttr = Parser.TryParsePropertyAttribute(token);
if (propAttr != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propAttr).ToString());
}
break;
case EmoteField.PropertyAttribute2ndStat:
var propVital = Parser.TryParsePropertyAttribute2nd(token);
if (propVital != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propVital).ToString());
}
break;
case EmoteField.PropertyBoolStat:
var propBool = Parser.TryParsePropertyBool(token);
if (propBool != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propBool).ToString());
}
break;
case EmoteField.PropertyFloatStat:
var propFloat = Parser.TryParsePropertyFloat(token);
if (propFloat != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propFloat).ToString());
}
break;
case EmoteField.PropertyIntStat:
var propInt = Parser.TryParsePropertyInt(token);
if (propInt != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propInt).ToString());
}
break;
case EmoteField.PropertyInt64Stat:
var propInt64 = Parser.TryParsePropertyInt64(token);
if (propInt64 != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propInt64).ToString());
}
break;
case EmoteField.PropertyStringStat:
var propStr = Parser.TryParsePropertyString(token);
if (propStr != null)
{
fieldDict.Add(EmoteField.Stat, ((int)propStr).ToString());
}
break;
case EmoteField.SkillStat:
var skill = Parser.TryParseSkill(token);
if (skill != null)
{
fieldDict.Add(EmoteField.Stat, ((int)skill).ToString());
}
break;
case EmoteField.Percent:
var percent = Parser.TryParsePercent(token, out _);
if (percent != null)
{
fieldDict.Add(EmoteField.Percent, percent.ToString());
}
break;
case EmoteField.Range:
if (!RangeTypes.TryGetValue(type, out var rangeType))
{
Console.WriteLine($"Emote_Line.ParseOptionalTypes({type}) couldn't find RangeType");
break;
}
var range = Parser.TryParseRange(token, rangeType, out _);
if (range != null)
{
if (range.Min != null)
{
fieldDict.Add(EmoteField.Min, range.Min.ToString());
}
if (range.Max != null)
{
fieldDict.Add(EmoteField.Max, range.Max.ToString());
}
}
break;
case EmoteField.RangeFloat:
if (!RangeTypes.TryGetValue(type, out rangeType))
{
Console.WriteLine($"Emote_Line.ParseOptionalTypes({type}) couldn't find RangeType");
break;
}
var rangeFloat = Parser.TryParseRangeFloat(token, rangeType, out _);
if (rangeFloat != null)
{
if (rangeFloat.Min != null)
{
fieldDict.Add(EmoteField.MinFloat, rangeFloat.Min.ToString());
}
if (rangeFloat.Max != null)
{
fieldDict.Add(EmoteField.MaxFloat, rangeFloat.Max.ToString());
}
}
break;
case EmoteField.Range64:
if (!RangeTypes.TryGetValue(type, out rangeType))
{
Console.WriteLine($"Emote_Line.ParseOptionalTypes({type}) couldn't find RangeType");
break;
}
var range64 = Parser.TryParseRange64(token, rangeType, out _);
if (range64 != null)
{
if (range64.Min != null)
{
fieldDict.Add(EmoteField.Min64, range64.Min.ToString());
}
if (range64.Max != null)
{
fieldDict.Add(EmoteField.Max64, range64.Max.ToString());
}
}
break;
case EmoteField.WeenieClassId:
var wcid = Parser.TryParseWeenieClassId(token);
if (wcid != null)
{
fieldDict.Add(EmoteField.WeenieClassId, wcid.ToString());
}
break;
case EmoteField.Angles:
var angles = Parser.TryParseQuaternion(token);
if (angles != null)
{
AddAngles(angles.Value, fieldDict);
}
break;
case EmoteField.OriginAngles:
var frame = Parser.TryParseFrame(token, false);
if (frame != null)
{
AddOrigin(frame.Origin, fieldDict);
AddAngles(frame.Orientation, fieldDict);
}
else
{
var origin = Parser.TryParseVector3(token);
if (origin != null)
{
AddOrigin(origin.Value, fieldDict);
}
}
break;
case EmoteField.Position:
var pos = Parser.TryParsePosition(token);
if (pos != null)
{
fieldDict.Add(EmoteField.ObjCellId, pos.ObjCellId.ToString());
AddOrigin(pos.Frame.Origin, fieldDict);
AddAngles(pos.Frame.Orientation, fieldDict);
}
break;
case EmoteField.PScript:
var physScript = Parser.TryParsePlayScript(token);
if (physScript != null)
{
fieldDict.Add(EmoteField.PScript, ((int)physScript).ToString());
}
break;
case EmoteField.ContractId:
var contractId = Parser.TryParseContractId(token);
if (contractId != null)
{
fieldDict.Add(EmoteField.Amount, ((int)contractId).ToString());
}
break;
default:
fieldDict.Add(defaultField, token);
break;
}
}
}
public bool Contains(RangeTypes rangeType)
{
return(List.Contains(rangeType));
}
public WsMatchInRangeCollection GetMatches(RangeTypes type, string condition)
{
return m_matches.GetMatches(type, condition);
}
/// <summary>
/// Bestimmt ob ein Wert in einem bestimmten Bereich liegt.
/// </summary>
/// <param name="val">Der zu prüfende Wert.</param>
/// <param name="min">Die Untergrenze des Bereichs.</param>
/// <param name="max">Die Obergrenze des Bereichs.</param>
/// <param name="rangeType">Bestimmt ob die Grenzen inklusiv oder exklusiv sind.</param>
/// <returns><c>True</c>, wenn <paramref name="value"/> in den angegebenen Grenzen liegt. Andernfalls <c>False</c>.</returns>
public static bool IsInRange(this double val, double min, double max, RangeTypes rangeType)
{
return(((rangeType == RangeTypes.Excl || rangeType == RangeTypes.ExclIncl) ? val > min : val >= min) &&
((rangeType == RangeTypes.Excl || rangeType == RangeTypes.InclExcl) ? val < max : val <= max));
}
private IEnumerable <Tuple <object, object> > ParseRange(IEnumerator <Lexem> tokens, Type rangeType, string context)
{
if (tokens.Current.NextLexem != null && RangeTypes.Contains(tokens.Current.NextLexem.Value))
{
return(Enumerable.Empty <Tuple <object, object> >());
}
ExpectNextToken(tokens, "(", context: context + " range");
TypeConverter converter = TypeDescriptor.GetConverter(rangeType);
List <Tuple <object, object> > result = new List <Tuple <object, object> >();
List <string> rangeTokens = new List <string>();
string token = GetNextToken(tokens, context: context + " range");
while (token != ")") // scanner guarantees that all parentheses are matched
{
rangeTokens.Add(token);
token = GetNextToken(tokens, context: context + " range");
}
if (rangeTokens.Count == 2)
{
result.Add(ParseRangeValues(rangeTokens[0], rangeTokens[1], converter, context: context));
}
else if (rangeTokens.Count == 3)
{
int count = 0;
Exception innerException = null;
try
{
count = int.Parse(rangeTokens[0], CultureInfo.InvariantCulture);
}
catch (FormatException e)
{
innerException = e;
}
catch (OverflowException e)
{
innerException = e;
}
catch (ArgumentNullException e)
{
innerException = e;
}
if (innerException != null)
{
throw new InvalidDataException("Could not parse range multiplicity value: '" + rangeTokens[0] + "' when parsing " + context);
}
var rangeTuple = ParseRangeValues(rangeTokens[1], rangeTokens[2], converter, context: context);
for (int i = 0; i < count; ++i)
{
result.Add(rangeTuple);
}
}
return(result);
}
public RangeTypes[] ToArray()
{
RangeTypes[] types = new RangeTypes[this.Count];
int i = 0;
foreach(RangeTypes type in this.List)
{
types[i++] = type;
}
return types;
}