//******************************************************************************************************* // Volume.cs - Gbtc // // Tennessee Valley Authority, 2009 // No copyright is claimed pursuant to 17 USC § 105. All Other Rights Reserved. // // This software is made freely available under the TVA Open Source Agreement (see below). // Code in this file licensed to GSF under one or more contributor license agreements listed below. // // Code Modification History: // ----------------------------------------------------------------------------------------------------- // 01/25/2008 - J. Ritchie Carroll // Initial version of source generated. // 09/11/2008 - J. Ritchie Carroll // Converted to C#. // 08/10/2009 - Josh L. Patterson // Edited Comments. // 09/14/2009 - Stephen C. Wills // Added new header and license agreement. // //******************************************************************************************************* #region [ TVA Open Source Agreement ] /* THIS OPEN SOURCE AGREEMENT ("AGREEMENT") DEFINES THE RIGHTS OF USE,REPRODUCTION, DISTRIBUTION, MODIFICATION AND REDISTRIBUTION OF CERTAIN COMPUTER SOFTWARE ORIGINALLY RELEASED BY THE TENNESSEE VALLEY AUTHORITY, A CORPORATE AGENCY AND INSTRUMENTALITY OF THE UNITED STATES GOVERNMENT ("GOVERNMENT AGENCY"). GOVERNMENT AGENCY IS AN INTENDED THIRD-PARTY BENEFICIARY OF ALL SUBSEQUENT DISTRIBUTIONS OR REDISTRIBUTIONS OF THE SUBJECT SOFTWARE. ANYONE WHO USES, REPRODUCES, DISTRIBUTES, MODIFIES OR REDISTRIBUTES THE SUBJECT SOFTWARE, AS DEFINED HEREIN, OR ANY PART THEREOF, IS, BY THAT ACTION, ACCEPTING IN FULL THE RESPONSIBILITIES AND OBLIGATIONS CONTAINED IN THIS AGREEMENT. Original Software Designation: openPDC Original Software Title: The GSF Open Source Phasor Data Concentrator User Registration Requested. Please Visit https://naspi.tva.com/Registration/ Point of Contact for Original Software: J. Ritchie Carroll 1. DEFINITIONS A. "Contributor" means Government Agency, as the developer of the Original Software, and any entity that makes a Modification. B. "Covered Patents" mean patent claims licensable by a Contributor that are necessarily infringed by the use or sale of its Modification alone or when combined with the Subject Software. C. "Display" means the showing of a copy of the Subject Software, either directly or by means of an image, or any other device. D. "Distribution" means conveyance or transfer of the Subject Software, regardless of means, to another. E. "Larger Work" means computer software that combines Subject Software, or portions thereof, with software separate from the Subject Software that is not governed by the terms of this Agreement. F. "Modification" means any alteration of, including addition to or deletion from, the substance or structure of either the Original Software or Subject Software, and includes derivative works, as that term is defined in the Copyright Statute, 17 USC § 101. However, the act of including Subject Software as part of a Larger Work does not in and of itself constitute a Modification. G. "Original Software" means the computer software first released under this Agreement by Government Agency entitled openPDC, including source code, object code and accompanying documentation, if any. H. "Recipient" means anyone who acquires the Subject Software under this Agreement, including all Contributors. I. "Redistribution" means Distribution of the Subject Software after a Modification has been made. J. "Reproduction" means the making of a counterpart, image or copy of the Subject Software. K. "Sale" means the exchange of the Subject Software for money or equivalent value. L. "Subject Software" means the Original Software, Modifications, or any respective parts thereof. M. "Use" means the application or employment of the Subject Software for any purpose. 2. GRANT OF RIGHTS A. Under Non-Patent Rights: Subject to the terms and conditions of this Agreement, each Contributor, with respect to its own contribution to the Subject Software, hereby grants to each Recipient a non-exclusive, world-wide, royalty-free license to engage in the following activities pertaining to the Subject Software: 1. Use 2. Distribution 3. Reproduction 4. Modification 5. Redistribution 6. Display B. Under Patent Rights: Subject to the terms and conditions of this Agreement, each Contributor, with respect to its own contribution to the Subject Software, hereby grants to each Recipient under Covered Patents a non-exclusive, world-wide, royalty-free license to engage in the following activities pertaining to the Subject Software: 1. Use 2. Distribution 3. Reproduction 4. Sale 5. Offer for Sale C. The rights granted under Paragraph B. also apply to the combination of a Contributor's Modification and the Subject Software if, at the time the Modification is added by the Contributor, the addition of such Modification causes the combination to be covered by the Covered Patents. It does not apply to any other combinations that include a Modification. D. The rights granted in Paragraphs A. and B. allow the Recipient to sublicense those same rights. Such sublicense must be under the same terms and conditions of this Agreement. 3. OBLIGATIONS OF RECIPIENT A. Distribution or Redistribution of the Subject Software must be made under this Agreement except for additions covered under paragraph 3H. 1. Whenever a Recipient distributes or redistributes the Subject Software, a copy of this Agreement must be included with each copy of the Subject Software; and 2. If Recipient distributes or redistributes the Subject Software in any form other than source code, Recipient must also make the source code freely available, and must provide with each copy of the Subject Software information on how to obtain the source code in a reasonable manner on or through a medium customarily used for software exchange. B. Each Recipient must ensure that the following copyright notice appears prominently in the Subject Software: No copyright is claimed pursuant to 17 USC § 105. All Other Rights Reserved. C. Each Contributor must characterize its alteration of the Subject Software as a Modification and must identify itself as the originator of its Modification in a manner that reasonably allows subsequent Recipients to identify the originator of the Modification. In fulfillment of these requirements, Contributor must include a file (e.g., a change log file) that describes the alterations made and the date of the alterations, identifies Contributor as originator of the alterations, and consents to characterization of the alterations as a Modification, for example, by including a statement that the Modification is derived, directly or indirectly, from Original Software provided by Government Agency. Once consent is granted, it may not thereafter be revoked. D. A Contributor may add its own copyright notice to the Subject Software. Once a copyright notice has been added to the Subject Software, a Recipient may not remove it without the express permission of the Contributor who added the notice. E. A Recipient may not make any representation in the Subject Software or in any promotional, advertising or other material that may be construed as an endorsement by Government Agency or by any prior Recipient of any product or service provided by Recipient, or that may seek to obtain commercial advantage by the fact of Government Agency's or a prior Recipient's participation in this Agreement. F. In an effort to track usage and maintain accurate records of the Subject Software, each Recipient, upon receipt of the Subject Software, is requested to register with Government Agency by visiting the following website: https://naspi.tva.com/Registration/. Recipient's name and personal information shall be used for statistical purposes only. Once a Recipient makes a Modification available, it is requested that the Recipient inform Government Agency at the web site provided above how to access the Modification. G. Each Contributor represents that that its Modification does not violate any existing agreements, regulations, statutes or rules, and further that Contributor has sufficient rights to grant the rights conveyed by this Agreement. H. A Recipient may choose to offer, and to charge a fee for, warranty, support, indemnity and/or liability obligations to one or more other Recipients of the Subject Software. A Recipient may do so, however, only on its own behalf and not on behalf of Government Agency or any other Recipient. Such a Recipient must make it absolutely clear that any such warranty, support, indemnity and/or liability obligation is offered by that Recipient alone. Further, such Recipient agrees to indemnify Government Agency and every other Recipient for any liability incurred by them as a result of warranty, support, indemnity and/or liability offered by such Recipient. I. A Recipient may create a Larger Work by combining Subject Software with separate software not governed by the terms of this agreement and distribute the Larger Work as a single product. In such case, the Recipient must make sure Subject Software, or portions thereof, included in the Larger Work is subject to this Agreement. J. Notwithstanding any provisions contained herein, Recipient is hereby put on notice that export of any goods or technical data from the United States may require some form of export license from the U.S. Government. Failure to obtain necessary export licenses may result in criminal liability under U.S. laws. Government Agency neither represents that a license shall not be required nor that, if required, it shall be issued. Nothing granted herein provides any such export license. 4. DISCLAIMER OF WARRANTIES AND LIABILITIES; WAIVER AND INDEMNIFICATION A. No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE. FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS." B. Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST GOVERNMENT AGENCY, ITS AGENTS, EMPLOYEES, CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT. IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS GOVERNMENT AGENCY, ITS AGENTS, EMPLOYEES, CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW. THE FOREGOING RELEASE AND INDEMNIFICATION SHALL APPLY EVEN IF THE LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARE CAUSED, OCCASIONED, OR CONTRIBUTED TO BY THE NEGLIGENCE, SOLE OR CONCURRENT, OF GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT. RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT. 5. GENERAL TERMS A. Termination: This Agreement and the rights granted hereunder will terminate automatically if a Recipient fails to comply with these terms and conditions, and fails to cure such noncompliance within thirty (30) days of becoming aware of such noncompliance. Upon termination, a Recipient agrees to immediately cease use and distribution of the Subject Software. All sublicenses to the Subject Software properly granted by the breaching Recipient shall survive any such termination of this Agreement. B. Severability: If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement. C. Applicable Law: This Agreement shall be subject to United States federal law only for all purposes, including, but not limited to, determining the validity of this Agreement, the meaning of its provisions and the rights, obligations and remedies of the parties. D. Entire Understanding: This Agreement constitutes the entire understanding and agreement of the parties relating to release of the Subject Software and may not be superseded, modified or amended except by further written agreement duly executed by the parties. E. Binding Authority: By accepting and using the Subject Software under this Agreement, a Recipient affirms its authority to bind the Recipient to all terms and conditions of this Agreement and that Recipient hereby agrees to all terms and conditions herein. F. Point of Contact: Any Recipient contact with Government Agency is to be directed to the designated representative as follows: J. Ritchie Carroll . */ #endregion #region [ Contributor License Agreements ] /**************************************************************************\ Copyright © 2009 - J. Ritchie Carroll All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \**************************************************************************/ #endregion using System; using System.ComponentModel; using System.Globalization; using System.Runtime.CompilerServices; namespace GSF.Units { /// Represents a volume measurement, in cubic meters, as a double-precision floating-point number. /// /// This class behaves just like a representing a volume in cubic meters; it is implictly /// castable to and from a and therefore can be generally used "as" a double, but it /// has the advantage of handling conversions to and from other volume representations, specifically /// liters, teaspoons, tablespoons, cubic inches, fluid ounces, cups, pints, quarts, gallons and cubic feet. /// Metric conversions are handled simply by applying the needed conversion factor, for example: /// /// Convert volume, in cubic meters, to cubic kilometers: /// /// public double GetCubicKilometers(Volume cubicmeters) /// { /// return cubicmeters / SI.Kilo; /// } /// /// This example converts teaspoons to cups: /// /// public double GetCups(double teaspoons) /// { /// return Volume.FromTeaspoons(teaspoons).ToCups(); /// } /// /// This example converts liters to fluid ounces: /// /// public double GetFluidOunces(double liters) /// { /// return Volume.FromLiters(liters).ToFluidOunces(); /// } /// /// /// [Serializable()] public struct Volume : IComparable, IFormattable, IConvertible, IComparable, IComparable, IEquatable, IEquatable { #region [ Members ] // Constants private const double LitersFactor = 0.001D; private const double TeaspoonsFactor = 4.928921595e-6D; private const double MetricTeaspoonsFactor = 5.0e-6D; private const double TablespoonsFactor = 14.7867647825e-6D; private const double MetricTablespoonsFactor = 15.0e-6D; private const double CupsFactor = 236.5882365e-6D; private const double MetricCupsFactor = 250.0e-6D; private const double FluidOuncesFactor = 29.5735295625e-6D; private const double PintsFactor = 473.176473e-6D; private const double QuartsFactor = 946.352946e-6D; private const double GallonsFactor = 3.785411784e-3D; private const double CubicInchesFactor = 16.387064e-6D; private const double CubicFeetFactor = 0.028316846592D; // Fields private double m_value; // Volume value stored in cubic meters #endregion #region [ Constructors ] /// /// Creates a new . /// /// New volume value in cubic meters. public Volume(double value) { m_value = value; } #endregion #region [ Methods ] /// /// Gets the value in liters. /// /// Value of in liters. public double ToLiters() { return m_value / LitersFactor; } /// /// Gets the value in US teaspoons. /// /// Value of in US teaspoons. public double ToTeaspoons() { return m_value / TeaspoonsFactor; } /// /// Gets the value in metric teaspoons. /// /// Value of in metric teaspoons. public double ToMetricTeaspoons() { return m_value / MetricTeaspoonsFactor; } /// /// Gets the value in US tablespoons. /// /// Value of in US tablespoons. public double ToTablespoons() { return m_value / TablespoonsFactor; } /// /// Gets the value in metric tablespoons. /// /// Value of in metric tablespoons. public double ToMetricTablespoons() { return m_value / MetricTablespoonsFactor; } /// /// Gets the value in US cups. /// /// Value of in US cups. public double ToCups() { return m_value / CupsFactor; } /// /// Gets the value in metric cups. /// /// Value of in metric cups. public double ToMetricCups() { return m_value / MetricCupsFactor; } /// /// Gets the value in US fluid ounces. /// /// Value of in US fluid ounces. public double ToFluidOunces() { return m_value / FluidOuncesFactor; } /// /// Gets the value in US fluid pints. /// /// Value of in US fluid pints. public double ToPints() { return m_value / PintsFactor; } /// /// Gets the value in US fluid quarts. /// /// Value of in US fluid quarts. public double ToQuarts() { return m_value / QuartsFactor; } /// /// Gets the value in US fluid gallons. /// /// Value of in US fluid gallons. public double ToGallons() { return m_value / GallonsFactor; } /// /// Gets the value in cubic inches. /// /// Value of in cubic inches. public double ToCubicInches() { return m_value / CubicInchesFactor; } /// /// Gets the value in cubic feet. /// /// Value of in cubic feet. public double ToCubicFeet() { return m_value / CubicFeetFactor; } #region [ Numeric Interface Implementations ] /// /// Compares this instance to a specified object and returns an indication of their relative values. /// /// An object to compare, or null. /// /// A signed number indicating the relative values of this instance and value. Returns less than zero /// if this instance is less than value, zero if this instance is equal to value, or greater than zero /// if this instance is greater than value. /// /// value is not a or . public int CompareTo(object value) { if ((object)value == null) return 1; if (!(value is double) && !(value is Volume)) throw new ArgumentException("Argument must be a Double or a Volume"); double num = (double)value; return (m_value < num ? -1 : (m_value > num ? 1 : 0)); } /// /// Compares this instance to a specified and returns an indication of their /// relative values. /// /// A to compare. /// /// A signed number indicating the relative values of this instance and value. Returns less than zero /// if this instance is less than value, zero if this instance is equal to value, or greater than zero /// if this instance is greater than value. /// public int CompareTo(Volume value) { return CompareTo((double)value); } /// /// Compares this instance to a specified and returns an indication of their /// relative values. /// /// A to compare. /// /// A signed number indicating the relative values of this instance and value. Returns less than zero /// if this instance is less than value, zero if this instance is equal to value, or greater than zero /// if this instance is greater than value. /// public int CompareTo(double value) { return (m_value < value ? -1 : (m_value > value ? 1 : 0)); } /// /// Returns a value indicating whether this instance is equal to a specified object. /// /// An object to compare, or null. /// /// True if obj is an instance of or and equals the value of this instance; /// otherwise, False. /// public override bool Equals(object obj) { if (obj is double || obj is Volume) return Equals((double)obj); return false; } /// /// Returns a value indicating whether this instance is equal to a specified value. /// /// A value to compare to this instance. /// /// True if obj has the same value as this instance; otherwise, False. /// public bool Equals(Volume obj) { return Equals((double)obj); } /// /// Returns a value indicating whether this instance is equal to a specified value. /// /// A value to compare to this instance. /// /// True if obj has the same value as this instance; otherwise, False. /// public bool Equals(double obj) { return (m_value == obj); } /// /// Returns the hash code for this instance. /// /// /// A 32-bit signed integer hash code. /// public override int GetHashCode() { return m_value.GetHashCode(); } /// /// Converts the numeric value of this instance to its equivalent string representation. /// /// /// The string representation of the value of this instance, consisting of a minus sign if /// the value is negative, and a sequence of digits ranging from 0 to 9 with no leading zeroes. /// public override string ToString() { return m_value.ToString(); } /// /// Converts the numeric value of this instance to its equivalent string representation, using /// the specified format. /// /// A format string. /// /// The string representation of the value of this instance as specified by format. /// public string ToString(string format) { return m_value.ToString(format); } /// /// Converts the numeric value of this instance to its equivalent string representation using the /// specified culture-specific format information. /// /// /// A that supplies culture-specific formatting information. /// /// /// The string representation of the value of this instance as specified by provider. /// public string ToString(IFormatProvider provider) { return m_value.ToString(provider); } /// /// Converts the numeric value of this instance to its equivalent string representation using the /// specified format and culture-specific format information. /// /// A format specification. /// /// A that supplies culture-specific formatting information. /// /// /// The string representation of the value of this instance as specified by format and provider. /// public string ToString(string format, IFormatProvider provider) { return m_value.ToString(format, provider); } /// /// Converts the string representation of a number to its equivalent. /// /// A string containing a number to convert. /// /// A equivalent to the number contained in s. /// /// s is null. /// /// s represents a number less than or greater than . /// /// s is not in the correct format. public static Volume Parse(string s) { return (Volume)double.Parse(s); } /// /// Converts the string representation of a number in a specified style to its equivalent. /// /// A string containing a number to convert. /// /// A bitwise combination of System.Globalization.NumberStyles values that indicates the permitted format of s. /// /// /// A equivalent to the number contained in s. /// /// /// style is not a System.Globalization.NumberStyles value. -or- style is not a combination of /// System.Globalization.NumberStyles.AllowHexSpecifier and System.Globalization.NumberStyles.HexNumber values. /// /// s is null. /// /// s represents a number less than or greater than . /// /// s is not in a format compliant with style. public static Volume Parse(string s, NumberStyles style) { return (Volume)double.Parse(s, style); } /// /// Converts the string representation of a number in a specified culture-specific format to its equivalent. /// /// A string containing a number to convert. /// /// A that supplies culture-specific formatting information about s. /// /// /// A equivalent to the number contained in s. /// /// s is null. /// /// s represents a number less than or greater than . /// /// s is not in the correct format. public static Volume Parse(string s, IFormatProvider provider) { return (Volume)double.Parse(s, provider); } /// /// Converts the string representation of a number in a specified style and culture-specific format to its equivalent. /// /// A string containing a number to convert. /// /// A bitwise combination of System.Globalization.NumberStyles values that indicates the permitted format of s. /// /// /// A that supplies culture-specific formatting information about s. /// /// /// A equivalent to the number contained in s. /// /// /// style is not a System.Globalization.NumberStyles value. -or- style is not a combination of /// System.Globalization.NumberStyles.AllowHexSpecifier and System.Globalization.NumberStyles.HexNumber values. /// /// s is null. /// /// s represents a number less than or greater than . /// /// s is not in a format compliant with style. public static Volume Parse(string s, NumberStyles style, IFormatProvider provider) { return (Volume)double.Parse(s, style, provider); } /// /// Converts the string representation of a number to its equivalent. A return value /// indicates whether the conversion succeeded or failed. /// /// A string containing a number to convert. /// /// When this method returns, contains the value equivalent to the number contained in s, /// if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s paraampere is null, /// is not of the correct format, or represents a number less than or greater than . /// This paraampere is passed uninitialized. /// /// true if s was converted successfully; otherwise, false. public static bool TryParse(string s, out Volume result) { double parseResult; bool parseResponse; parseResponse = double.TryParse(s, out parseResult); result = parseResult; return parseResponse; } /// /// Converts the string representation of a number in a specified style and culture-specific format to its /// equivalent. A return value indicates whether the conversion succeeded or failed. /// /// A string containing a number to convert. /// /// A bitwise combination of System.Globalization.NumberStyles values that indicates the permitted format of s. /// /// /// When this method returns, contains the value equivalent to the number contained in s, /// if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s paraampere is null, /// is not in a format compliant with style, or represents a number less than or /// greater than . This paraampere is passed uninitialized. /// /// /// A object that supplies culture-specific formatting information about s. /// /// true if s was converted successfully; otherwise, false. /// /// style is not a System.Globalization.NumberStyles value. -or- style is not a combination of /// System.Globalization.NumberStyles.AllowHexSpecifier and System.Globalization.NumberStyles.HexNumber values. /// public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out Volume result) { double parseResult; bool parseResponse; parseResponse = double.TryParse(s, style, provider, out parseResult); result = parseResult; return parseResponse; } /// /// Returns the for value type . /// /// The enumerated constant, . public TypeCode GetTypeCode() { return TypeCode.Double; } #region [ Explicit IConvertible Implementation ] // These are explicitly implemented on the native System.Double implementations, so we do the same... bool IConvertible.ToBoolean(IFormatProvider provider) { return Convert.ToBoolean(m_value, provider); } char IConvertible.ToChar(IFormatProvider provider) { return Convert.ToChar(m_value, provider); } sbyte IConvertible.ToSByte(IFormatProvider provider) { return Convert.ToSByte(m_value, provider); } byte IConvertible.ToByte(IFormatProvider provider) { return Convert.ToByte(m_value, provider); } short IConvertible.ToInt16(IFormatProvider provider) { return Convert.ToInt16(m_value, provider); } ushort IConvertible.ToUInt16(IFormatProvider provider) { return Convert.ToUInt16(m_value, provider); } int IConvertible.ToInt32(IFormatProvider provider) { return Convert.ToInt32(m_value, provider); } uint IConvertible.ToUInt32(IFormatProvider provider) { return Convert.ToUInt32(m_value, provider); } long IConvertible.ToInt64(IFormatProvider provider) { return Convert.ToInt64(m_value, provider); } ulong IConvertible.ToUInt64(IFormatProvider provider) { return Convert.ToUInt64(m_value, provider); } float IConvertible.ToSingle(IFormatProvider provider) { return Convert.ToSingle(m_value, provider); } double IConvertible.ToDouble(IFormatProvider provider) { return m_value; } decimal IConvertible.ToDecimal(IFormatProvider provider) { return Convert.ToDecimal(m_value, provider); } DateTime IConvertible.ToDateTime(IFormatProvider provider) { return Convert.ToDateTime(m_value, provider); } object IConvertible.ToType(Type type, IFormatProvider provider) { return Convert.ChangeType(m_value, type, provider); } #endregion #endregion #endregion #region [ Operators ] #region [ Comparison Operators ] /// /// Compares the two values for equality. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A value as the result. public static bool operator ==(Volume value1, Volume value2) { return value1.Equals(value2); } /// /// Compares the two values for inequality. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A value as the result. public static bool operator !=(Volume value1, Volume value2) { return !value1.Equals(value2); } /// /// Returns true if left value is less than right value. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A value as the result. public static bool operator <(Volume value1, Volume value2) { return (value1.CompareTo(value2) < 0); } /// /// Returns true if left value is less or equal to than right value. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A value as the result. public static bool operator <=(Volume value1, Volume value2) { return (value1.CompareTo(value2) <= 0); } /// /// Returns true if left value is greater than right value. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A value as the result. public static bool operator >(Volume value1, Volume value2) { return (value1.CompareTo(value2) > 0); } /// /// Returns true if left value is greater than or equal to right value. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A value as the result. public static bool operator >=(Volume value1, Volume value2) { return (value1.CompareTo(value2) >= 0); } #endregion #region [ Type Conversion Operators ] /// /// Implicitly converts value, represented in cubic meters, to a . /// /// A value. /// A object. public static implicit operator Volume(Double value) { return new Volume(value); } /// /// Implicitly converts , represented in cubic meters, to a . /// /// A object. /// A value. public static implicit operator Double(Volume value) { return value.m_value; } #endregion #region [ Arithmetic Operators ] /// /// Returns computed remainder after dividing first value by the second. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A object as the result. public static Volume operator %(Volume value1, Volume value2) { return value1.m_value % value2.m_value; } /// /// Returns computed sum of values. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A object as the result. public static Volume operator +(Volume value1, Volume value2) { return value1.m_value + value2.m_value; } /// /// Returns computed difference of values. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A object as the result. public static Volume operator -(Volume value1, Volume value2) { return value1.m_value - value2.m_value; } /// /// Returns computed product of values. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A object as the result. public static Volume operator *(Volume value1, Volume value2) { return value1.m_value * value2.m_value; } /// /// Returns computed division of values. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A object as the result. public static Volume operator /(Volume value1, Volume value2) { return value1.m_value / value2.m_value; } // C# doesn't expose an exponent operator but some other .NET languages do, // so we expose the operator via its native special IL function name /// /// Returns result of first value raised to volume of second value. /// /// A object as the left hand operand. /// A object as the right hand operand. /// A value as the result. [EditorBrowsable(EditorBrowsableState.Advanced), SpecialName()] public static double op_Exponent(Volume value1, Volume value2) { return Math.Pow((double)value1.m_value, (double)value2.m_value); } #endregion #endregion #region [ Static ] // Static Fields /// Represents the largest possible value of an . This field is constant. public static readonly Volume MaxValue = (Volume)double.MaxValue; /// Represents the smallest possible value of an . This field is constant. public static readonly Volume MinValue = (Volume)double.MinValue; // Static Methods /// /// Creates a new value from the specified in liters. /// /// New value in liters. /// New object from the specified in liters. public static Volume FromLiters(double value) { return new Volume(value * LitersFactor); } /// /// Creates a new value from the specified in US teaspoons. /// /// New value in US teaspoons. /// New object from the specified in US teaspoons. public static Volume FromTeaspoons(double value) { return new Volume(value * TeaspoonsFactor); } /// /// Creates a new value from the specified in metric teaspoons. /// /// New value in metric teaspoons. /// New object from the specified in metric teaspoons. public static Volume FromMetricTeaspoons(double value) { return new Volume(value * MetricTeaspoonsFactor); } /// /// Creates a new value from the specified in US tablespoons. /// /// New value in US tablespoons. /// New object from the specified in US tablespoons. public static Volume FromTablespoons(double value) { return new Volume(value * TablespoonsFactor); } /// /// Creates a new value from the specified in metric tablespoons. /// /// New value in metric tablespoons. /// New object from the specified in metric tablespoons. public static Volume FromMetricTablespoons(double value) { return new Volume(value * MetricTablespoonsFactor); } /// /// Creates a new value from the specified in US cups. /// /// New value in US cups. /// New object from the specified in US cups. public static Volume FromCups(double value) { return new Volume(value * CupsFactor); } /// /// Creates a new value from the specified in metric cups. /// /// New value in metric cups. /// New object from the specified in metric cups. public static Volume FromMetricCups(double value) { return new Volume(value * MetricCupsFactor); } /// /// Creates a new value from the specified in US fluid ounces. /// /// New value in US fluid ounces. /// New object from the specified in US fluid ounces. public static Volume FromFluidOunces(double value) { return new Volume(value * FluidOuncesFactor); } /// /// Creates a new value from the specified in US fluid pints. /// /// New value in US fluid pints. /// New object from the specified in US fluid pints. public static Volume FromPints(double value) { return new Volume(value * PintsFactor); } /// /// Creates a new value from the specified in US fluid quarts. /// /// New value in US fluid quarts. /// New object from the specified in US fluid quarts. public static Volume FromQuarts(double value) { return new Volume(value * QuartsFactor); } /// /// Creates a new value from the specified in US fluid gallons. /// /// New value in US fluid gallons. /// New object from the specified in US fluid gallons. public static Volume FromGallons(double value) { return new Volume(value * GallonsFactor); } /// /// Creates a new value from the specified in cubic inches. /// /// New value in cubic inches. /// New object from the specified in cubic inches. public static Volume FromCubicInches(double value) { return new Volume(value * CubicInchesFactor); } /// /// Creates a new value from the specified in cubic feet. /// /// New value in cubic feet. /// New object from the specified in cubic feet. public static Volume FromCubicFeet(double value) { return new Volume(value * CubicFeetFactor); } #endregion } }