internal string AsStringInternal(TInt value, EnumMemberInternal <TInt, TIntProvider> member) => IsFlagEnum?FormatFlagsInternal(value, member, null, null) : FormatInternal(value, member, EnumFormat.Name, EnumFormat.UnderlyingValue);
internal string AsStringInternal(TInt value, EnumMemberInternal <TInt, TIntProvider> member, EnumFormat[] formats) => formats?.Length > 0 ? FormatInternal(value, member, formats) : AsStringInternal(value, member);
internal bool TryParse(string formattedValue, bool ignoreCase, out EnumMemberInternal <TInt, TIntProvider> result) => _formatValueMap.TryGetValue(formattedValue, out result) || (ignoreCase && FormatIgnoreCase.TryGetValue(formattedValue, out result));
public EnumCache(Type enumType, IEnumInfoInternal <TInt, TIntProvider> enumInfo)
{
_enumTypeName = enumType.Name;
EnumInfo = enumInfo;
_hasCustomValidator = enumInfo.HasCustomValidator;
IsFlagEnum = enumType.IsDefined(typeof(FlagsAttribute), false);
var fields =
#if TYPE_REFLECTION
enumType.GetFields(BindingFlags.Public | BindingFlags.Static);
#else
enumType.GetTypeInfo().DeclaredFields.Where(fieldInfo => (fieldInfo.Attributes & (FieldAttributes.Static | FieldAttributes.Public)) == (FieldAttributes.Static | FieldAttributes.Public)).ToArray();
#endif
_valueMap = new Dictionary <TInt, EnumMemberInternal <TInt, TIntProvider> >(fields.Length);
if (fields.Length == 0)
{
return;
}
var duplicateValues = new List <EnumMemberInternal <TInt, TIntProvider> >();
// This is necessary due to a .NET reflection bug with retrieving Boolean Enums values
Dictionary <string, TInt> fieldDictionary = null;
var isBoolean = typeof(TInt) == typeof(bool);
if (isBoolean)
{
fieldDictionary = new Dictionary <string, TInt>();
var values = (TInt[])Enum.GetValues(enumType);
var names = Enum.GetNames(enumType);
for (var i = 0; i < names.Length; ++i)
{
fieldDictionary.Add(names[i], values[i]);
}
}
foreach (var field in fields)
{
var name = field.Name;
var value = isBoolean ? fieldDictionary[name] : (TInt)field.GetValue(null);
var attributes = new AttributeCollection(
#if TYPE_REFLECTION
Attribute.GetCustomAttributes(field, false));
#else
field.GetCustomAttributes(false).ToArray());
#endif
var member = new EnumMemberInternal <TInt, TIntProvider>(value, name, attributes, this);
EnumMemberInternal <TInt, TIntProvider> existing;
if (_valueMap.TryGetValue(value, out existing))
{
if (attributes.Has <PrimaryEnumMemberAttribute>())
{
_valueMap[value] = member;
member = existing;
}
duplicateValues.Add(member);
}
else
{
_valueMap.Add(value, member);
// Is Power of Two
if (Provider.And(value, Provider.Subtract(value, Provider.One)).Equals(Provider.Zero))
{
AllFlags = Provider.Or(AllFlags, value);
}
}
}
var isInOrder = true;
TInt previous = default(TInt);
var isFirst = true;
foreach (var pair in _valueMap)
{
var key = pair.Key;
if (isFirst)
{
_minDefined = key;
isFirst = false;
}
else if (previous.CompareTo(key) > 0)
{
isInOrder = false;
break;
}
previous = key;
}
if (isInOrder)
{
_maxDefined = previous;
}
else
{
// Makes sure is in increasing value order, due to no removals
var values = _valueMap.ToArray();
Array.Sort(values, (first, second) => first.Key.CompareTo(second.Key));
_valueMap = new Dictionary <TInt, EnumMemberInternal <TInt, TIntProvider> >(_valueMap.Count);
foreach (var pair in values)
{
_valueMap.Add(pair.Key, pair.Value);
}
_maxDefined = values[values.Length - 1].Key;
_minDefined = values[0].Key;
}
_isContiguous = Provider.Subtract(_maxDefined, Provider.Create(_valueMap.Count - 1)).Equals(_minDefined);
if (duplicateValues.Count > 0)
{
duplicateValues.TrimExcess();
// Makes sure is in increasing order
duplicateValues.Sort((first, second) => first.Value.CompareTo(second.Value));
_duplicateValues = duplicateValues;
_duplicateValues.Capacity = _duplicateValues.Count;
}
}
public EnumMember CreateEnumMember(EnumMemberInternal <TInt, TIntProvider> member) => new EnumMember <TEnum, TInt, TIntProvider>(member);
private bool TryParseInternal(string value, bool ignoreCase, out TInt result, out EnumMemberInternal <TInt, TIntProvider> member, EnumFormat[] formats, bool getValueOnly)
{
foreach (var format in formats)
{
if (format == EnumFormat.UnderlyingValue)
{
if (Provider.TryParseNative(value, out result))
{
member = getValueOnly ? null : GetMember(result);
return(true);
}
}
else if (format == EnumFormat.DecimalValue || format == EnumFormat.HexadecimalValue)
{
if (Provider.TryParseNumber(value, format == EnumFormat.DecimalValue ? NumberStyles.AllowLeadingSign : NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out result))
{
member = getValueOnly ? null : GetMember(result);
return(true);
}
}
else
{
var parser = GetEnumMemberParser(format);
if (parser.TryParse(value, ignoreCase, out member))
{
result = member.Value;
return(true);
}
}
}
result = default(TInt);
member = null;
return(false);
}
internal string FormatInternal(TInt value, EnumMemberInternal <TInt, TIntProvider> member, EnumFormat format0, EnumFormat format1, EnumFormat format2)
{
var isInitialized = member != null;
return(FormatInternal(value, ref isInitialized, ref member, format0) ?? FormatInternal(value, ref isInitialized, ref member, format1) ?? FormatInternal(value, ref isInitialized, ref member, format2));
}
internal string AsStringInternal(TInt value, EnumMemberInternal <TInt, TIntProvider> member, string format) => string.IsNullOrEmpty(format) ? AsStringInternal(value, member) : FormatInternal(value, member, format);
private protected EnumMember(EnumMemberInternal member)
{
Member = member;
}
