public TInt Parse(string value, bool ignoreCase, ValueCollection <EnumFormat> formats)
        {
            if (IsFlagEnum)
            {
                return(ParseFlags(value, ignoreCase, null, formats));
            }

            Preconditions.NotNull(value, nameof(value));

            value = value.Trim();

            if (!formats.Any())
            {
                formats = Enums.DefaultFormats;
            }

            if (TryParseInternal(value, ignoreCase, out var result, out _, formats, true))
            {
                return(result);
            }
            if (IsNumeric(value))
            {
                throw new OverflowException("value is outside the underlying type's value range");
            }
            throw new ArgumentException($"string was not recognized as being a member of {_enumTypeName}", nameof(value));
        }
        public TInt ParseFlags(string value, bool ignoreCase, string delimiter, ValueCollection <EnumFormat> formats)
        {
            Preconditions.NotNull(value, nameof(value));

            if (string.IsNullOrEmpty(delimiter))
            {
                delimiter = FlagEnums.DefaultDelimiter;
            }

            var effectiveDelimiter = delimiter.Trim();

            if (effectiveDelimiter.Length == 0)
            {
                effectiveDelimiter = delimiter;
            }

            if (!formats.Any())
            {
                formats = Enums.DefaultFormats;
            }

            var result      = Provider.Zero;
            var startIndex  = 0;
            var valueLength = value.Length;

            while (startIndex < valueLength)
            {
                while (startIndex < valueLength && char.IsWhiteSpace(value[startIndex]))
                {
                    ++startIndex;
                }
                var delimiterIndex = value.IndexOf(effectiveDelimiter, startIndex, StringComparison.Ordinal);
                if (delimiterIndex < 0)
                {
                    delimiterIndex = valueLength;
                }
                var newStartIndex = delimiterIndex + effectiveDelimiter.Length;
                while (delimiterIndex > startIndex && char.IsWhiteSpace(value[delimiterIndex - 1]))
                {
                    --delimiterIndex;
                }
                var indValue = value.Substring(startIndex, delimiterIndex - startIndex);
                if (TryParseInternal(indValue, ignoreCase, out var valueAsTInt, out _, formats, true))
                {
                    result = Provider.Or(result, valueAsTInt);
                }
        public bool TryParse(string value, bool ignoreCase, out TInt result, ValueCollection <EnumFormat> formats)
        {
            if (IsFlagEnum)
            {
                return(TryParseFlags(value, ignoreCase, null, out result, formats));
            }

            if (value != null)
            {
                value = value.Trim();

                if (!formats.Any())
                {
                    formats = Enums.DefaultFormats;
                }

                return(TryParseInternal(value, ignoreCase, out result, out _, formats, true));
            }
            result = Provider.Zero;
            return(false);
        }
 public string AsString(ValueCollection <EnumFormat> formats) => _enumCache.FormatInternal(Value, this, formats);
        internal string FormatFlagsInternal(TInt value, EnumMemberInternal <TInt, TIntProvider> member, string delimiter, ValueCollection <EnumFormat> formats)
        {
            if (!formats.Any())
            {
                formats = Enums.DefaultFormats;
            }

            if (member == null)
            {
                member = GetMember(value);
            }

            if (member != null || value.Equals(Provider.Zero) || !IsValidFlagCombination(value))
            {
                return(FormatInternal(value, member, formats));
            }

            if (string.IsNullOrEmpty(delimiter))
            {
                delimiter = FlagEnums.DefaultDelimiter;
            }

            return(string.Join(delimiter,
                               GetFlags(value).Select(flag => FormatInternal(flag, null, formats))
#if NET20 || NET35
                               .ToArray()
#endif
                               ));
        }
 public string FormatFlags(TInt value, string delimiter, ValueCollection <EnumFormat> formats) => FormatFlagsInternal(value, null, delimiter, formats);
 private bool TryParseInternal(string value, bool ignoreCase, out TInt result, out EnumMemberInternal <TInt, TIntProvider> member, ValueCollection <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;
     member = null;
     return(false);
 }
        public EnumMemberInternal <TInt, TIntProvider> GetMember(string value, bool ignoreCase, ValueCollection <EnumFormat> formats)
        {
            Preconditions.NotNull(value, nameof(value));

            value = value.Trim();

            if (!formats.Any())
            {
                formats = Enums.NameFormat;
            }

            TryParseInternal(value, ignoreCase, out _, out var member, formats, false);
            return(member);
        }
        internal string FormatInternal(TInt value, EnumMemberInternal <TInt, TIntProvider> member, ValueCollection <EnumFormat> formats)
        {
            var isInitialized = member != null;

            foreach (var format in formats)
            {
                var formattedValue = FormatInternal(value, ref isInitialized, ref member, format);
                if (formattedValue != null)
                {
                    return(formattedValue);
                }
            }
            return(null);
        }
示例#10
0
 internal string AsStringInternal(TInt value, EnumMemberInternal <TInt, TIntProvider> member, ValueCollection <EnumFormat> formats) => formats.Any() ? FormatInternal(value, member, formats) : AsStringInternal(value, member);
示例#11
0
 public string AsString(TInt value, ValueCollection <EnumFormat> formats) => AsStringInternal(value, null, formats);
示例#12
0
 public abstract string?AsString(ValueCollection <EnumFormat> formats);
示例#13
0
 public abstract bool TryFormat(Span <char> destination, out int charsWritten, ValueCollection <EnumFormat> formats);