Extensions.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using UnityEngine;
using Object = UnityEngine.Object;

namespace HoloToolkit.Unity
{
    public static class Extensions
    {
        public static float Duration(this AnimationCurve curve)
        {
            if (curve == null || curve.length <= 1)
            {
                return 0.0f;
            }

            return Mathf.Abs(curve[curve.length - 1].time - curve[0].time);
        }

        public static bool IsValid(this Ray ray)
        {
            return (ray.direction != Vector3.zero);
        }

        #region Collections

        public static ReadOnlyCollection<TElement> AsReadOnly<TElement>(this IList<TElement> elements)
        {
            return new ReadOnlyCollection<TElement>(elements);
        }

        public static ReadOnlyCollection<TElement> ToReadOnlyCollection<TElement>(this IEnumerable<TElement> elements)
        {
            return elements.ToArray().AsReadOnly();
        }

        public static int SortedInsert<TElement>(this List<TElement> elements, TElement toInsert, IComparer<TElement> comparer = null)
        {
            var effectiveComparer = (comparer ?? Comparer<TElement>.Default);

#if DEBUG || UNITY_EDITOR
            for (int iElement = 0; iElement < (elements.Count - 1); iElement++)
            {
                var element = elements[iElement];
                var nextElement = elements[iElement + 1];

                if (effectiveComparer.Compare(element, nextElement) > 0)
                {
                    Debug.Assert(false, "elements must already be sorted to call this method.");
                    break;
                }
            }
#endif

            int searchResult = elements.BinarySearch(toInsert, effectiveComparer);

            int insertionIndex = (searchResult >= 0)
                ? searchResult
                : (~searchResult);

            elements.Insert(insertionIndex, toInsert);

            return insertionIndex;
        }

        public static void DisposeElements<TElement>(this IEnumerable<TElement> elements)
            where TElement : IDisposable
        {
            foreach (var element in elements)
            {
                if (element != null)
                {
                    element.Dispose();
                }
            }
        }

        public static void DisposeElements<TElement>(this IList<TElement> elements)
            where TElement : IDisposable
        {
            for (int iElement = 0; iElement < elements.Count; iElement++)
            {
                var element = elements[iElement];

                if (element != null)
                {
                    element.Dispose();
                }
            }
        }

        #endregion

        #region Numerics

        public static bool Approximately(this float number, float other, float tolerance)
        {
            return (Mathf.Abs(number - other) <= tolerance);
        }

        public static bool Approximately(this double number, double other, double tolerance)
        {
            return (Math.Abs(number - other) <= tolerance);
        }

        #endregion

        #region UnityEngine.Object

        public static void DontDestroyOnLoad(this Object target)
        {
#if UNITY_EDITOR // Skip Don't Destroy On Load when editor isn't playing so test runner passes.
            if (UnityEditor.EditorApplication.isPlaying)
#endif
                Object.DontDestroyOnLoad(target);
        }

        #endregion

        #region GameObject

        public static bool IsInLayerMask(this GameObject gameObject, LayerMask layerMask)
        {
            LayerMask gameObjectMask = (1 << gameObject.layer);
            return ((gameObjectMask & layerMask) == gameObjectMask);
        }

        #endregion

        #region Comparer

        public static IComparer<TElement> GetReversed<TElement>(this IComparer<TElement> originalComparer)
        {
            return new ReverseComparer<TElement>(originalComparer);
        }

        private class ReverseComparer<TElement> :
            IComparer<TElement>
        {
            private readonly IComparer<TElement> originalComparer;

            public ReverseComparer(IComparer<TElement> originalComparer)
            {
                Debug.Assert(originalComparer != null, "originalComparer cannot be null.");

                this.originalComparer = originalComparer;
            }

            public int Compare(TElement left, TElement right)
            {
                return originalComparer.Compare(right, left);
            }
        }

        #endregion
    }
}