Пример #1
0
        /// <summary>Returns the fully qualified type name of this instance.</summary>
        /// <returns>The fully qualified type name.</returns>
        public override string ToString()
        {
            if (!IsConstrained)
            {
                return(string.Empty);
            }

            // Use set notation for open/closed boundaries
            var sb = new StringBuilder();

            if (RangeOptions.HasFlag(RangeOptions.MinimumInclusive))
            {
                sb.Append("[");
            }
            else
            {
                sb.Append("(");
            }

            if (Minimum.HasValue)
            {
                sb.Append(Minimum.Value.ToString(CultureInfo.InvariantCulture));
            }
            else
            {
                sb.Append("-∞");
            }

            sb.Append(", ");

            if (Maximum.HasValue)
            {
                sb.Append(Maximum.Value.ToString(CultureInfo.InvariantCulture));
            }
            else
            {
                sb.Append("∞");
            }

            if (RangeOptions.HasFlag(RangeOptions.MaximumInclusive))
            {
                sb.Append("]");
            }
            else
            {
                sb.Append(")");
            }

            if (MultipleOf.HasValue &&
                MultipleOf.Value != 0)
            {
                sb.Append(" * ").Append(MultipleOf.Value.ToString(CultureInfo.InvariantCulture));
            }

            return(sb.ToString());
        }
Пример #2
0
        public Range(TValue start, TValue end, RangeOptions options)
        {
            if (options.HasFlag(RangeOptions.IsEmpty))
            {
                // clear other flags
                _options = RangeOptions.IsEmpty;
                Start    = default(TValue);
                End      = default(TValue);
                return;
            }

            if (ReferenceEquals(start, null))
            {
                options &= ~RangeOptions.HasStart;
            }

            if (ReferenceEquals(end, null))
            {
                options &= ~RangeOptions.HasEnd;
            }

            if (!options.HasFlag(RangeOptions.HasStart))
            {
                start    = default(TValue);
                options &= ~RangeOptions.IncludingStart;
            }

            if (!options.HasFlag(RangeOptions.HasEnd))
            {
                end      = default(TValue);
                options &= ~RangeOptions.IncludingEnd;
            }

            _options = options;

            if (!options.HasFlag(RangeOptions.HasStart) || !options.HasFlag(RangeOptions.HasEnd))
            {
                Start = start;
                End   = end;
                return;
            }

            Debug.Assert(start != null, "start != null");
            var compare = start.CompareTo(end);

            if (compare > 0)
            {
                throw new ArgumentException("'Start' must be less or equal to the 'End' parameter");
            }

            Start = start;
            End   = end;

            if (compare == 0)
            {
                if (!(options.HasFlag(RangeOptions.IncludingStart) ||
                      options.HasFlag(RangeOptions.IncludingEnd)))
                {
                    // empty
                    Start    = default(TValue);
                    End      = default(TValue);
                    _options = RangeOptions.IsEmpty;
                }
                else
                {
                    // ensure that everything are included
                    _options |= RangeOptions.IncludingStart | RangeOptions.IncludingEnd;
                }
            }
        }