Hydrogen.Validate Class Reference

Additional static functions used to extend existing Validation support inside of Unity. More...

Static Public Member Functions
static float	ColorPercentage (this Color sourceColor, Color targetColor)
	Calculate the percentage of similarity between two colors. More...
static bool	IsColorApproximatelySame (this Color sourceColor, Color targetColor)
	Are the colors approximately equal? More...
static bool	IsDictionaryEqual< TKey, TValue > (this IDictionary< TKey, TValue > first, IDictionary< TKey, TValue > second)
	Determines if dictionaries are equal. More...
static bool	IsNumericType (this object value)
	Determines whether the specified value is of numeric type. More...
static bool	IsPositive (this object value, bool zeroIsPositive=true)
	Determines whether the specified value is positive. More...
static bool	ScrambledEquals< T > (IEnumerable< T > list1, IEnumerable< T > list2)
	Determines whether the two scrambled enumerable objects are equal. More...

Detailed Description

Additional static functions used to extend existing Validation support inside of Unity.

Definition at line 39 of file Validate.cs.

Member Function Documentation

static float Hydrogen.Validate.ColorPercentage ( this Color  sourceColor, Color  targetColor  )

static

Calculate the percentage of similarity between two colors.

Returns

The percentage of similarity (0-1)

Parameters

sourceColor	Left Side Color
targetColor	Right Side Color

Definition at line 47 of file Validate.cs.

                {
                        return ((targetColor.r / sourceColor.r) +
                        (targetColor.g / sourceColor.g) +
                        (targetColor.b / sourceColor.b) +
                        (targetColor.a / sourceColor.a) / 4f);
                }

static bool Hydrogen.Validate.IsColorApproximatelySame ( this Color  sourceColor, Color  targetColor  )

static

Are the colors approximately equal?

Returns

true, if colors are approximately equal, false otherwise.

Parameters

sourceColor	Left Side Color
targetColor	Right Side Color

Definition at line 61 of file Validate.cs.

                {
                        return (Mathf.Approximately (sourceColor.r, targetColor.r) &&
                        Mathf.Approximately (sourceColor.g, targetColor.g) &&
                        Mathf.Approximately (sourceColor.b, targetColor.b) &&
                        Mathf.Approximately (sourceColor.a, targetColor.a));
                }

static bool Hydrogen.Validate.IsDictionaryEqual< TKey, TValue > ( this IDictionary< TKey, TValue >  first, IDictionary< TKey, TValue >  second  )

static

Determines if dictionaries are equal.

Returns

true if the left side equals the right side; otherwise, false.

Parameters

first	Left Side Dictionary.
second	Right Side Dictionary.

Template Parameters

TKey	The 1st type parameter.
TValue	The 2nd type parameter.

Definition at line 77 of file Validate.cs.

                {
                        if (first == second)
                                return true;
                        if ((first == null) || (second == null))
                                return false;
                        if (first.Count != second.Count)
                                return false;

                        var comparer = EqualityComparer<TValue>.Default;

                        foreach (KeyValuePair<TKey, TValue> kvp in first) {
                                TValue secondValue;
                                if (!second.TryGetValue (kvp.Key, out secondValue))
                                        return false;
                                if (!comparer.Equals (kvp.Value, secondValue))
                                        return false;
                        }
                        return true;
                }

static bool Hydrogen.Validate.IsNumericType ( this object  value )

static

Determines whether the specified value is of numeric type.

Returns

true if value is a numeric type; otherwise, false.

Parameters

value

The object to check.

Definition at line 107 of file Validate.cs.

                {
                        return (value is byte ||
                        value is sbyte ||
                        value is short ||
                        value is ushort ||
                        value is int ||
                        value is uint ||
                        value is long ||
                        value is ulong ||
                        value is float ||
                        value is double ||
                        value is decimal);
                }

static bool Hydrogen.Validate.IsPositive ( this object  value, bool  zeroIsPositive = true  )

static

Determines whether the specified value is positive.

Returns

true if the specified value is positive; otherwise, false.

Parameters

value	The value.
zeroIsPositive	if set to true treats 0 as positive. Defaults to true.

Definition at line 130 of file Validate.cs.

                {
                        switch (Type.GetTypeCode (value.GetType ())) {
                        case TypeCode.SByte:
                                return (zeroIsPositive ? (sbyte)value >= 0 : (sbyte)value > 0);
                        case TypeCode.Int16:
                                return (zeroIsPositive ? (short)value >= 0 : (short)value > 0);
                        case TypeCode.Int32:
                                return (zeroIsPositive ? (int)value >= 0 : (int)value > 0);
                        case TypeCode.Int64:
                                return (zeroIsPositive ? (long)value >= 0 : (long)value > 0);
                        case TypeCode.Single:
                                return (zeroIsPositive ? (float)value >= 0 : (float)value > 0);
                        case TypeCode.Double:
                                return (zeroIsPositive ? (double)value >= 0 : (double)value > 0);
                        case TypeCode.Decimal:
                                return (zeroIsPositive ? (decimal)value >= 0 : (decimal)value > 0);
                        case TypeCode.Byte:
                                return (zeroIsPositive || (byte)value > 0);
                        case TypeCode.UInt16:
                                return (zeroIsPositive || (ushort)value > 0);
                        case TypeCode.UInt32:
                                return (zeroIsPositive || (uint)value > 0);
                        case TypeCode.UInt64:
                                return (zeroIsPositive || (ulong)value > 0);
                        case TypeCode.Char:
                                return (zeroIsPositive || (char)value != '\0');
                        default:
                                return false;
                        }
                }

static bool Hydrogen.Validate.ScrambledEquals< T > ( IEnumerable< T >  list1, IEnumerable< T >  list2  )

static

Determines whether the two scrambled enumerable objects are equal.

Returns

true, if they are equal, false otherwise.

Parameters

list1	List1.
list2	List2.

Template Parameters

T	The 1st type parameter.

Definition at line 169 of file Validate.cs.

                {
                        var cnt = new Dictionary<T, int> ();

                        foreach (T s in list1) {
                                if (cnt.ContainsKey (s)) {
                                        cnt [s]++;
                                } else {
                                        cnt.Add (s, 1);
                                }
                        }

                        foreach (T s in list2) {
                                if (cnt.ContainsKey (s)) {
                                        cnt [s]--;
                                } else {
                                        return false;
                                }
                        }

                        return cnt.Values.All (c => c == 0);
                }