/// <summary> /// Converts provided value into its string representation. /// </summary> /// <remarks> /// This method converts provided value into its string representation /// by finding the best fitting capacity entity and using it to format /// provided value afterwards. /// </remarks> /// <param name="value"> /// The value to be converted. /// </param> /// <param name="unit"> /// The unit to get a capacity entity for. /// </param> /// <param name="decimals"> /// The number of decimal digits used for calculation. /// </param> /// <param name="calculate"> /// True to force a result calculation, otherwise false. /// </param> /// <param name="intercept"> /// True to force intercept mode, otherwise false. /// </param> /// <param name="culture"> /// The culture to be used for conversion. /// </param> /// <returns> /// The string representation of converted value. /// </returns> /// <seealso cref="Find(String)"/> /// <seealso cref="Find(Decimal)"/> /// <seealso cref="CapacityEntity.Format(Decimal, Boolean, Boolean, CultureInfo)"/> /// <seealso cref="CapacityEntity.Format(Decimal, Int32, Boolean, Boolean, CultureInfo)"/> /// <seealso cref="CapacityEntity.Format(Decimal, String, Int32, Boolean, Boolean, CultureInfo)"/> public static String Convert(Decimal value, String unit, Int32 decimals, Boolean calculate, Boolean intercept, CultureInfo culture) { if (!String.IsNullOrWhiteSpace(unit)) { // Special case: Prefere unit one. if (unit.Equals("one", StringComparison.InvariantCultureIgnoreCase)) { CapacityEntity entity = CapacityConverter.Find(value); return(entity.Format(value, entity.Unit1, decimals, calculate, intercept, culture)); } // Special case: Prefere unit two. if (unit.Equals("two", StringComparison.InvariantCultureIgnoreCase)) { CapacityEntity entity = CapacityConverter.Find(value); return(entity.Format(value, entity.Unit2, decimals, calculate, intercept, culture)); } return(CapacityConverter.Find(unit).Format(value, unit, decimals, calculate, intercept, culture)); } if (decimals > 0) { return(CapacityConverter.Find(value).Format(value, decimals, calculate, intercept, culture)); } return(CapacityConverter.Find(value).Format(value, calculate, intercept, culture)); }
public void CapacityEntity_UnitsWithSpaces_UnitsAreTrimmed(String unitOne, String unitTwo) { CapacityEntity instance = new CapacityEntity(42, unitOne, unitTwo); Assert.That(instance.Unit1, Is.EqualTo(unitOne.Trim())); Assert.That(instance.Unit2, Is.EqualTo(unitTwo.Trim())); }
private static string GetCapacityUsed(string authToken, string accountName) { string capacityUsed = string.Empty; CloudStorageAccount storageAccount = GetUserAccount(authToken, accountName); if (storageAccount != null) { CloudAnalyticsClient storageAnalytics = storageAccount.CreateCloudAnalyticsClient(); TableQuery <CapacityEntity> tableQuery = storageAnalytics.CreateCapacityQuery(); IQueryable <CapacityEntity> capacityQuery = tableQuery.Where(x => x.RowKey == "data"); try { List <CapacityEntity> capacityEntities = capacityQuery.ToList(); if (capacityEntities.Count == 0) { capacityUsed = Storage.MapByteCount(0); } else { capacityEntities.Sort(OrderByLatest); CapacityEntity latestAnalytics = capacityEntities.First(); capacityUsed = Storage.MapByteCount(latestAnalytics.Capacity); } } catch { capacityUsed = Constants.NotAvailable; } } return(capacityUsed); }
/// <summary> /// Finds a capacity entity by value. /// </summary> /// <remarks> /// This method finds the best fitting capacity entity by value. Best fitting /// means the capacity entity where the <paramref name="value"/> divided by a /// capacity entity's value is greater than or equal to one. /// </remarks> /// <param name="value"> /// The value to get a capacity entity for. /// </param> /// <returns> /// One of the items in the list of used capacity entities or the default /// capacity entity. /// </returns> /// <seealso cref="Default"/> /// <seealso cref="Capacities"/> public static CapacityEntity Find(Decimal value) { CapacityEntity result = null; if (value != 0) { result = CapacityConverter.Capacities.FirstOrDefault(x => value / x.Value >= 1); } return(result ?? CapacityConverter.Default); }
private static int OrderByLatest(CapacityEntity leftItem, CapacityEntity rightItem) { return(DateTimeOffset.Compare(rightItem.Time, leftItem.Time)); }
/// <summary> /// Finds a capacity entity by unit. /// </summary> /// <remarks> /// This method finds the first capacity entity for provided <paramref name="unit"/>. /// The last capacity entity is returned if none of the supported capacity entities /// fits. /// </remarks> /// <param name="unit"> /// The unit to get a capacity entity for. /// </param> /// <returns> /// One of the items in the list of used capacity entities. /// </returns> /// <seealso cref="Capacities"/> public static CapacityEntity Find(String unit) { CapacityEntity result = CapacityConverter.Capacities.FirstOrDefault(x => x.IsEqual(unit)); return(result ?? CapacityConverter.Default); }
private static int OrderByLatest(CapacityEntity leftSide, CapacityEntity rightSide) { return(DateTimeOffset.Compare(rightSide.Time, leftSide.Time)); }