/// <summary> /// Searches for the specified value and returns the zero-based index of the first occurrence /// </summary> /// <param name="item"></param> /// <returns></returns> public int IndexOf(IMetricValue item) { lock (m_Lock) { return(m_ValueList.IndexOfKey(item)); } }
/// <summary> /// Determines whether an element is in the collection. /// </summary> /// <remarks>This method determines equality using the default equality comparer for the type of values in the list. It performs /// a linear search and therefore is an O(n) operation.</remarks> /// <param name="item">The object to locate in the collection.</param> /// <returns>true if the item is found in the collection; otherwise false.</returns> public bool Contains(IMetricValue item) { lock (m_Lock) { //here we are relying on the fact that the MetricValue object implements IComparable sufficiently to guarantee uniqueness return(m_ValueList.ContainsKey(item)); } }
public bool IsSame(IMetricValue obj) { if (obj is NativeObjectMetric) { var o = (NativeObjectMetric)obj; return(o.m_ObjectIndex == m_ObjectIndex); } return(false); }
public bool IsSame(IMetricValue obj) { if (obj is ManagedObjectMetric) { var o = (ManagedObjectMetric)obj; return(o.m_Object == m_Object); } return(false); }
/// <summary> /// Determines if the provided MetricValue object is identical to this object. /// </summary> /// <param name="other">The MetricValue object to compare this object to.</param> /// <returns>True if the Metric Value objects represent the same data.</returns> public bool Equals(IMetricValue other) { // Careful, it could be null; check it without recursion if (object.ReferenceEquals(other, null)) { return(false); // Since we're a live object we can't be equal to a null instance. } //they are equal if they have the same sequence and value return((Value == other.Value) && (Sequence == other.Sequence)); }
/// <summary> /// Adds the supplied MetricValue item to this collection. /// </summary> /// <remarks>The MetricValue item must refer to this metric value set, and have a unique timestamp.</remarks> /// <param name="item">The new MetricValue item to add.</param> public void Add(IMetricValue item) { if (item == null) { throw new ArgumentNullException(nameof(item), "No metric value item was provided to add to the collection"); } if (item.ValueCollection != this) { throw new ArgumentException("The provided metric value item was not created for this metric value set.", nameof(item)); } lock (m_Lock) { //OK, now add it to our sorted list. m_ValueList.Add(item, item); MetricValue nativeValue = (MetricValue)item; //since we were successful, now compare it with our min & max values, etc. to make sure that they are up to date. if (m_MinValueMetricValue == null) { //we are automatically the new minimum value m_MinValueMetricValue = nativeValue; } else if (m_MinValueMetricValue.Value > nativeValue.Value) { //we are less than the previous minimum value, making us the new minimum value m_MinValueMetricValue = nativeValue; } if (m_MaxValueMetricValue == null) { //we are automatically the new maximum value m_MaxValueMetricValue = nativeValue; } else if (m_MaxValueMetricValue.Value < nativeValue.Value) { //we are greater than the old maximum value, making us the new maximum value m_MaxValueMetricValue = nativeValue; } //to avoid overflow we have to calculate our average incrementally, otherwise it could go bad.... m_AverageValue = ((nativeValue.Value - m_AverageValue) / (m_ValueList.Count)) + m_AverageValue; m_StatsCurrent = false; //even if they were, they aren't now. } }
public void AddMetric(IMetricValue metric) { var groupName = metric.GetGroupName(); if (!_groups.ContainsKey(groupName)) { Group newGroup = new Group(); newGroup._name = groupName; newGroup._items = new List <Item>(); _groups.Add(groupName, newGroup); } Item item = new Item(metric, _groups[groupName]); _items.Add(item); _groups[groupName]._items.Add(item); }
public Item(IMetricValue metric, Group group) { _metric = metric; _group = group; }
/// <summary> /// Removing objects is not supported. /// </summary> /// <remarks>This method is implemented only for ICollection interface support and will throw an exception if called.</remarks> /// <param name="item">The MetricValue item to remove.</param> public bool Remove(IMetricValue item) { throw new NotSupportedException(); }
/// <summary> /// Not Supported. /// </summary> /// <param name="index"></param> /// <param name="item"></param> public void Insert(int index, IMetricValue item) { //we don't support setting an object by index; we are sorted. throw new NotSupportedException(); }
/// <summary> /// Compare this metric value to another for the purpose of sorting them in time. /// </summary> /// <remarks>MetricValue instances are sorted by their Sequence number property.</remarks> /// <param name="other">The MetricValue object to compare this object to.</param> /// <returns>An int which is less than zero, equal to zero, or greater than zero to reflect whether /// this MetricValue should sort as being less-than, equal to, or greater-than the other /// MetricValue, respectively.</returns> public int CompareTo(IMetricValue other) { //we are all about the sequence number baby! return(m_Sequence.CompareTo(other.Sequence)); }
public CloudWatchMetric(string name, IMetricValue metric, params IMetricDimension[] dimensions) { Dimensions = dimensions ?? throw new System.ArgumentNullException(nameof(dimensions)); Name = name ?? throw new System.ArgumentNullException(nameof(name)); Metric = metric ?? throw new System.ArgumentNullException(nameof(metric)); }
public string GetGroupName(IMetricValue thing) { return("MissingGroupName"); }
public bool HasMetric(IMetricValue metric) { var i = _items.FindIndex(x => x._metric == metric); return(i >= 0); }
public void SelectThing(IMetricValue thing) { var item = _items.First(i => i._metric == thing); SelectItem(item); }