private string Translate(UnitsOfMeasurement unit)
        {
            // First check for string returned if they are handled lower
            string value = unit.ToStr();

            if (value.Length > 0)
            {
                return(value);
            }

            // Others which do not return cross language string either because there
            // it has not been implemented or a cross language string impractical
            switch (unit)
            {
            // Special case where user sets at zero. Non in spec
            case UnitsOfMeasurement.Unknown:
            case UnitsOfMeasurement.Unitless:
                return(this.GetText(MsgCode.None));

            case UnitsOfMeasurement.NOT_HANDLED:
                return(this.GetText(MsgCode.NotFound));

            default:
                return(unit.ToString().CamelCaseToSpaces());
            }
        }
示例#2
0
 public TouchText(string text)
 {
     this.text         = text;
     font              = new MyFont();
     alignment         = TouchAlignment.Left;
     orientation       = TouchOrientation.Horizontal;
     textWrap          = TouchTextWrap.WordWrap;
     unitOfMeasurement = UnitsOfMeasurement.None;
 }
示例#3
0
        public UnitsOfMeasurement Get(Int64 ixUnitOfMeasurement)
        {
            UnitsOfMeasurement unitsofmeasurement = _context.UnitsOfMeasurement.AsNoTracking().Where(x => x.ixUnitOfMeasurement == ixUnitOfMeasurement).First();

            unitsofmeasurement.MeasurementSystems = _context.MeasurementSystems.Find(unitsofmeasurement.ixMeasurementSystem);
            unitsofmeasurement.MeasurementUnitsOf = _context.MeasurementUnitsOf.Find(unitsofmeasurement.ixMeasurementUnitOf);

            return(unitsofmeasurement);
        }
        //convert one UnitsOfMeasurement to UnitsOfMeasurementDto
        public static UnitsOfMeasurementDto convert(UnitsOfMeasurement unitsOfMeasurement)
        {
            UnitsOfMeasurementDto NewUnitsOfMeasurement = new UnitsOfMeasurementDto();

            NewUnitsOfMeasurement.id          = unitsOfMeasurement.id;
            NewUnitsOfMeasurement.unitName    = unitsOfMeasurement.unitName;
            NewUnitsOfMeasurement.ratioToGram = unitsOfMeasurement.ratioToGram;
            return(NewUnitsOfMeasurement);
        }
示例#5
0
        public static byte[] GetBlock(DataFormatEnum formatEnum, UnitsOfMeasurement units, sbyte exponent, byte nameSpace, ushort description)
        {
            byte[] data = new byte[7];
            int    pos  = 0;

            formatEnum.ToByte().WriteToBuffer(data, ref pos); // 0
            exponent.WriteToBuffer(data, ref pos);            // 1
            units.ToUint16().WriteToBuffer(data, ref pos);    // 2
            nameSpace.WriteToBuffer(data, ref pos);           // namespace    4
            description.WriteToBuffer(data, ref pos);         // 5
            return(data);
        }
 //remove UnitsOfMeasurement from database
 public UnitsOfMeasurementDto RemoveUnitsOfMeasurement(UnitsOfMeasurementDto unitsOfMeasurementDto)
 {
     using (HealthyMenuEntities db = new HealthyMenuEntities())
     {
         try
         {
             UnitsOfMeasurement unitsOfMeasurement = db.UnitsOfMeasurements.Remove(Convertion.UnitsOfMeasurementConvertion.convert(unitsOfMeasurementDto));
             db.SaveChanges();
             return(Convertion.UnitsOfMeasurementConvertion.convert(unitsOfMeasurement));
         }
         catch
         {
             return(null);
         }
     }
 }
 //get UnitsOfMeasurement by id from database
 public UnitsOfMeasurementDto GetUnitsOfMeasurement(int id)
 {
     using (HealthyMenuEntities db = new HealthyMenuEntities())
     {
         try
         {
             UnitsOfMeasurement unitsOfMeasurement = db.UnitsOfMeasurements.FirstOrDefault(x => x.id == id);
             if (unitsOfMeasurement == null)
             {
                 return(null);
             }
             return(Convertion.UnitsOfMeasurementConvertion.convert(unitsOfMeasurement));
         }
         catch
         {
             return(null);
         }
     }
 }
        public UnitsOfMeasurement AddUomCode(UnitsOfMeasurement uom)
        {
            try
            {
                using (var db = new ShopKeeperStoreEntities(_connectionString))
                {
                    UnitsOfMeasurement uomInfo;
                    var uoms = db.UnitsOfMeasurements.Where(u => u.UoMCode.ToLower() == uom.UoMCode.ToLower()).ToList();
                    if (uoms.Any())
                    {
                        uomInfo = uoms[0];
                    }
                    else
                    {
                        var processeduom = db.UnitsOfMeasurements.Add(uom);
                        db.SaveChanges();
                        uomInfo = processeduom;
                    }

                    return(uomInfo);
                }
            }
            catch (DbEntityValidationException e)
            {
                var str = "";
                foreach (var eve in e.EntityValidationErrors)
                {
                    str += string.Format("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                                         eve.Entry.Entity.GetType().Name, eve.Entry.State) + "\n";
                    foreach (var ve in eve.ValidationErrors)
                    {
                        str += string.Format("- Property: \"{0}\", Error: \"{1}\"",
                                             ve.PropertyName, ve.ErrorMessage) + " \n";
                    }
                }

                ErrorLogger.LogError(e.StackTrace, e.Source, str);
                return(new UnitsOfMeasurement());
            }
        }
 //update UnitsOfMeasurement in database
 public UnitsOfMeasurementDto PutUnitsOfMeasurement(UnitsOfMeasurementDto unitsOfMeasurementDto)
 {
     using (HealthyMenuEntities db = new HealthyMenuEntities())
     {
         try
         {
             UnitsOfMeasurement unitsOfMeasurement = db.UnitsOfMeasurements.FirstOrDefault(x => x.id == unitsOfMeasurementDto.id);
             if (unitsOfMeasurement == null)
             {
                 return(null);
             }
             unitsOfMeasurement.id          = unitsOfMeasurementDto.id;
             unitsOfMeasurement.unitName    = unitsOfMeasurementDto.unitName;
             unitsOfMeasurement.ratioToGram = unitsOfMeasurementDto.ratioToGram;
             return(Convertion.UnitsOfMeasurementConvertion.convert(unitsOfMeasurement));
         }
         catch
         {
             return(null);
         }
     }
 }
示例#10
0
        /// <summary>
        /// Computes the azimuth unit.
        /// </summary>
        /// <returns>The azimuth unit of measurement.</returns>
        /// <exception cref="System.IO.InvalidDataException">Azimuth unit code is invalid.</exception>
        private UnitOfMeasurement ComputeAzimuthUnit()
        {
            if (!_currentGeoKeys.ContainsKey(GeoKey.GeodeticAzimuthUnits))
            {
                return(UnitsOfMeasurement.Degree);
            }

            Int32 code = Convert.ToInt32(_currentGeoKeys[GeoKey.GeodeticAzimuthUnits]);

            // EPSG unit of measurement codes
            if (code >= 9100 && code <= 9199)
            {
                return(UnitsOfMeasurement.FromIdentifier("EPSG::" + code).FirstOrDefault());
            }
            // user-defined unit of measurement
            if (code == Int16.MaxValue)
            {
                Double unitSize = Convert.ToDouble(_currentGeoKeys[GeoKey.GeodeticAngularUnitSize]);

                return(new UnitOfMeasurement(UnitOfMeasurement.UserDefinedIdentifier, UnitOfMeasurement.UserDefinedName, String.Empty, unitSize, UnitQuantityType.Angle));
            }

            throw new InvalidDataException("Azimuth unit code is invalid.");
        }
示例#11
0
 public WaveLength(double value, MetricPrefixes prefixes = MetricPrefixes.One, UnitsOfMeasurement unit = UnitsOfMeasurement.Meter) : base(value, prefixes, unit)
 {
 }
示例#12
0
 public Height(double value, MetricPrefixes metricPrefixes = MetricPrefixes.One, UnitsOfMeasurement uom = UnitsOfMeasurement.Meter) : base(value,
                                                                                                                                           metricPrefixes, uom)
 {
 }
示例#13
0
 public RelativeTraceLength(double value, MetricPrefixes prefixes = MetricPrefixes.Percents, UnitsOfMeasurement unit = UnitsOfMeasurement.Percents) : base(value,
                                                                                                                                                           prefixes, unit)
 {
 }
示例#14
0
 public Conductivity(double value, MetricPrefixes prefix = MetricPrefixes.One,
                     UnitsOfMeasurement uom = UnitsOfMeasurement.SiemensOnMeter) : base(value, prefix, uom)
 {
 }
示例#15
0
 public static byte[] GetBlock(DataFormatEnum formatEnum, UnitsOfMeasurement units, sbyte exponent, byte nameSpace)
 {
     return(GetBlock(formatEnum, units, exponent, nameSpace, 0x221A));
 }
示例#16
0
 public static byte[] GetBlock(DataFormatEnum formatEnum, UnitsOfMeasurement units)
 {
     return(GetBlock(formatEnum, units, 0));
 }
示例#17
0
 public ThetaDegrees(double value, MetricPrefixes prefixes = MetricPrefixes.One, UnitsOfMeasurement unit = UnitsOfMeasurement.Degree) : base(value, prefixes,
                                                                                                                                             unit)
 {
 }
        /// <summary>
        /// Save
        /// </summary>
        public void Save()
        {
            UnitsOfMeasurementNavigatorTDS unitOfMeasurementAddChanges = (UnitsOfMeasurementNavigatorTDS)Data.GetChanges();

            if (unitOfMeasurementAddChanges != null)
            {
                if (unitOfMeasurementAddChanges.UnitsOfMeasurementNavigator.Rows.Count > 0)
                {
                    UnitsOfMeasurementNavigatorGateway unitsOfMeasurementNavigatorGateway = new UnitsOfMeasurementNavigatorGateway(unitOfMeasurementAddChanges);

                    // Update unit of measurement
                    foreach (UnitsOfMeasurementNavigatorTDS.UnitsOfMeasurementNavigatorRow row in (UnitsOfMeasurementNavigatorTDS.UnitsOfMeasurementNavigatorDataTable)unitOfMeasurementAddChanges.UnitsOfMeasurementNavigator)
                    {
                        int companyId = row.COMPANY_ID;

                        // Insert new unit of measurement
                        if ((!row.Deleted) && (!row.InDataBase))
                        {
                            int unitOfMeasurementId = row.UnitOfMeasurementID;
                            string description = row.Description;
                            string abreviation = row.Abbreviation;
                            bool deleted = row.Deleted;

                            UnitsOfMeasurement unitsOfMeasurement = new UnitsOfMeasurement(null);
                            unitsOfMeasurement.InsertDirect(unitOfMeasurementId, description, abreviation, deleted, companyId);
                        }

                        // Update unit of measurement
                        if ((!row.Deleted) && (row.InDataBase))
                        {
                            int unitOfMeasurementId = row.UnitOfMeasurementID;
                            bool originalDeleted = false;
                            int originalCompanyId = companyId;

                            // Original values
                            string originalDescription = unitsOfMeasurementNavigatorGateway.GetDescriptionOriginal(unitOfMeasurementId);
                            string originalAbbreviation = unitsOfMeasurementNavigatorGateway.GetAbbreviationOriginal(unitOfMeasurementId);

                            // New values
                            string newDescription = unitsOfMeasurementNavigatorGateway.GetDescription(unitOfMeasurementId);
                            string newAbbreviation = unitsOfMeasurementNavigatorGateway.GetAbbreviation(unitOfMeasurementId);

                            UnitsOfMeasurement unitsOfMeasurement = new UnitsOfMeasurement(null);
                            unitsOfMeasurement.UpdateDirect(unitOfMeasurementId, originalDescription, originalAbbreviation, originalDeleted, originalCompanyId, unitOfMeasurementId, newDescription, newAbbreviation, originalDeleted, originalCompanyId);
                        }

                        // Delete unit of measurement
                        if ((row.Deleted) && (row.InDataBase))
                        {
                            UnitsOfMeasurement unitsOfMeasurement = new UnitsOfMeasurement(null);
                            unitsOfMeasurement.DeleteDirect(row.UnitOfMeasurementID, row.COMPANY_ID);
                        }

                    }
                }
            }
        }
示例#19
0
 public static UnitsOfMeasurement CreateUnitsOfMeasurement(short uOMID, string units, decimal multiplier)
 {
     UnitsOfMeasurement unitsOfMeasurement = new UnitsOfMeasurement();
     unitsOfMeasurement.UOMID = uOMID;
     unitsOfMeasurement.Units = units;
     unitsOfMeasurement.Multiplier = multiplier;
     return unitsOfMeasurement;
 }
示例#20
0
 public static void SetUnits(byte[] data, UnitsOfMeasurement units)
 {
     units.ToUint16().WriteToBuffer(data, 2);
 }
示例#21
0
 public static UInt16 ToUint16(this UnitsOfMeasurement value)
 {
     return((UInt16)value);
 }
示例#22
0
 public ElectricalPermeability(double value, MetricPrefixes prefix = MetricPrefixes.One,
                               UnitsOfMeasurement uom = UnitsOfMeasurement.Units) : base(value, prefix, uom)
 {
 }
示例#23
0
        public static string ToStr(this UnitsOfMeasurement units)
        {
#pragma warning disable IDE0066 // Convert switch statement to expression
            switch (units)
            {
#pragma warning restore IDE0066 // Convert switch statement to expression
            case UnitsOfMeasurement.LengthMetre:
                return("m");

                #region Mass
            case UnitsOfMeasurement.MassKilogram:
                return("kg");

            case UnitsOfMeasurement.MassConcentrationKilogramPerCubicMetre:
                return("");

            case UnitsOfMeasurement.MassTonne:
                return("t");

            case UnitsOfMeasurement.MassDensityMilligramPerDecilitre:
                return("");

            case UnitsOfMeasurement.MassDensityMillimolePerLitre:
                return("");

            case UnitsOfMeasurement.MassPound:
                return("lb");

            case UnitsOfMeasurement.MassFlowGramPerSecond:
                return("");

                #endregion
                #region Time
            case UnitsOfMeasurement.TimeSecond:
                return("s");

            case UnitsOfMeasurement.TimeMinute:
                return("m");

            case UnitsOfMeasurement.TimeHour:
                return("h");

            case UnitsOfMeasurement.TimeDay:
                return("d");

            case UnitsOfMeasurement.TimeYear:
                return("y");

            case UnitsOfMeasurement.TimeMmonth:
                return("");

                #endregion
                #region Speed
            case UnitsOfMeasurement.VelocityKnot:
                return("kn");

            case UnitsOfMeasurement.VelocityKilometrePerHour:
                return("kph");

            case UnitsOfMeasurement.VelocityMilePerHour:
                return("mph");

                #endregion
                #region Length
            case UnitsOfMeasurement.LengthYard:
                return("yd");

            case UnitsOfMeasurement.LengthParsec:
                return("");

            case UnitsOfMeasurement.LengthInch:
                return("in");

            case UnitsOfMeasurement.LengthFoot:
                return("ft");

            case UnitsOfMeasurement.LengthMile:
                return("");

                #endregion
                #region Velocity
            case UnitsOfMeasurement.VelocityMetresPerSecond:
                return("m/s");

            case UnitsOfMeasurement.AngularVelocityRradianPerSecond:
                return("rad/s");

            case UnitsOfMeasurement.AngularVelocityRevolutionPerMinute:
                return("rpm");

                #endregion

            case UnitsOfMeasurement.ElectricCurrentAampere:
                return("A");

            case UnitsOfMeasurement.ThermodynamicTemperatureKelvin:
                return("K");

            case UnitsOfMeasurement.AmountOfSubstanceMole:
                return("mol");

            case UnitsOfMeasurement.LuminousIntensityCandela:
                return("cd");

            case UnitsOfMeasurement.AreaSquareMetres:
                return("m2");

            case UnitsOfMeasurement.VolumeCubicMetres:
                return("m3");

            case UnitsOfMeasurement.AccelerationMetresPerSecondSquared:
                return("m/s2");

            case UnitsOfMeasurement.DensityKilogramPerCubicMetre:
                return("kg/m3");

            case UnitsOfMeasurement.SurfaceDensityKilogramPerSquareMetre:
                return("kg/m2");

            case UnitsOfMeasurement.SpecificVolumeCubicMetrePerKilogram:
                return("m3/kg");

            case UnitsOfMeasurement.AmountConcentrationMolePerCubicMetre:
                return("mol/m3");

            case UnitsOfMeasurement.LuminanceCandelaPerSquareMetre:
                return("cd/m2");

            case UnitsOfMeasurement.FrequencyHhertz:
                return("Hz");

            case UnitsOfMeasurement.ForceNewton:
                return("N");

            case UnitsOfMeasurement.PressurePascal:
                return("Pa");

            case UnitsOfMeasurement.EnergyJoule:
                return("J");

            case UnitsOfMeasurement.PowerWatt:
                return("W");

            case UnitsOfMeasurement.ElectricChargeCoulomb:
                return("C");

            case UnitsOfMeasurement.ElectricPotentialDifferenceVolt:
                return("V");

            case UnitsOfMeasurement.CapacitanceFarad:
                return("F");

            case UnitsOfMeasurement.ElectricResistanceOhm:
                // ALT-234 - not working. turn off mouse keys?
                return("Ω");

            case UnitsOfMeasurement.ElectricConductanceSiemens:
                return("S");

            case UnitsOfMeasurement.InductanceHenry:
                return("H");

            case UnitsOfMeasurement.IlluminanceLlux:
                return("lx");

            case UnitsOfMeasurement.ActivityReferredToARadionuclideBecquerel:
                return("Bq");

            case UnitsOfMeasurement.AbsorbedDoseGray:
                return("Gy");

            case UnitsOfMeasurement.DoseEquivalentSievert:
                return("Sv");

            case UnitsOfMeasurement.VolumeLitre:
                return("l");

            case UnitsOfMeasurement.EnergyKilowattHour:
                return("kWh");

            case UnitsOfMeasurement.ThermodynamicTemperatureDegreeFahrenheit:
                return("F");

            case UnitsOfMeasurement.Percentage:
                return("%");

            case UnitsOfMeasurement.PlaneAngleRadian:
                return("rad");

            case UnitsOfMeasurement.SolidAangleSteradian:
                return("sr");

            case UnitsOfMeasurement.MagneticFluxWeber:
                return("Wb");

            case UnitsOfMeasurement.MagneticFluxDensityTesla:
                return("T");

            case UnitsOfMeasurement.CatalyticActivityKatal:
                return("kat");

            case UnitsOfMeasurement.WavenumberReciprocalMetre:
                return("m−1");

            case UnitsOfMeasurement.MagneticFieldStrengthAmperePerMetre:
                return("A/m");

            case UnitsOfMeasurement.CurrentDensityAmperePerSquareMetre:
                return("A/m2");

            case UnitsOfMeasurement.DynamicViscosityPascalSecond:
                return("Pa-s");

            case UnitsOfMeasurement.MomentOfForceNewtonMetre:
                return("N-m");

            case UnitsOfMeasurement.SurfaceTensionNewtonPerMetre:
                return("N/m");

            case UnitsOfMeasurement.AngularAccelerationRradianPerSecondSquared:
                return("rad/s2");

            case UnitsOfMeasurement.HeatFluxDensityWattPerSquareMetre:
                return("W/m2");

            case UnitsOfMeasurement.HeatCapacityJoulePerKelvin:
                return("J/K");

            case UnitsOfMeasurement.SpecificHeatCapacityJoulePerKilogramKelvin:
                return("J/(kg⋅K)");

            case UnitsOfMeasurement.SpecificEnergyJoulePerKilogram:
                return("J/kg");

            case UnitsOfMeasurement.ThermalConductivityWattPerMetreKelvin:
                return("W/(m⋅K)");

            case UnitsOfMeasurement.EnergyDensityJoulePerCubicMetre:
                return("J/m3");

            case UnitsOfMeasurement.ElectricFieldStrengthVoltPerMetre:
                return("V/m");

            case UnitsOfMeasurement.ElectricChargeDensityCoulombPerCubicMetre:
                return("C/m3");

            case UnitsOfMeasurement.SurfaceChargeDensityCoulombPerSquareMetre:
                return("C/m2");

            case UnitsOfMeasurement.ElectricFluxDensityCoulombPerSquareMetre:
                return("C/m2");

            case UnitsOfMeasurement.PermittivityFaradPerMetre:
                return("F/m");

            case UnitsOfMeasurement.PermeabilityHenryPerMetre:
                return("H/m");

            case UnitsOfMeasurement.MolarEnergyJoulePerMole:
                return("J/mol");

            case UnitsOfMeasurement.MolarEntropyJoulePerMoleKelvin:
                return("J/(mol⋅K)");

            case UnitsOfMeasurement.ExposureCoulombPerKilogram:
                return("C/kg");

            case UnitsOfMeasurement.AbsorbedDoseRateGrayPerSecond:
                return("Gy/s");

            case UnitsOfMeasurement.RadiantIntensityWattPerSteradian:
                return("W/sr");

            case UnitsOfMeasurement.RadianceWattPerSquareMetreSteradian:
                return("W/(m2⋅sr)");

            case UnitsOfMeasurement.CatalyticActivityConcentrationKatalPerCubicMetre:
                return("kat/m3");

            case UnitsOfMeasurement.AreaHectare:
                return("ha");

            case UnitsOfMeasurement.PlaneAngleDegree:
                return("°");

            case UnitsOfMeasurement.PlaneAngleMinute:
                return("′");

            case UnitsOfMeasurement.PlaneAngleSecond:
                return("″");

            case UnitsOfMeasurement.LogarithmicRadioQuantityNneper:
                return("Np");

            case UnitsOfMeasurement.LogarithmicRadioQuantityBel:
                return("B");

            case UnitsOfMeasurement.SoundPressureDecibel:
                return("dB");

            case UnitsOfMeasurement.LuminousFluxLlumen:
                return("lm");

            case UnitsOfMeasurement.LuminousExposureLuxHour:
                return("lx/h");

            case UnitsOfMeasurement.IrradianceWwattPerSquareMetre:
                return("W/m2");


            case UnitsOfMeasurement.RefractiveIndex:
                return("");

            case UnitsOfMeasurement.RelativePermeability:
                return("");

            case UnitsOfMeasurement.CelsiusTemperatureDegreeCelsius:
                return("");

            case UnitsOfMeasurement.PressureBar:
                return("");

            case UnitsOfMeasurement.PressureMillimetreOfMercury:
                return("");

            case UnitsOfMeasurement.LengthÅngström:
                return("");

            case UnitsOfMeasurement.LengthNauticalMile:
                return("");

            case UnitsOfMeasurement.AreaBarn:
                return("");

            case UnitsOfMeasurement.PressurePoundForcePerSquareInch:
                return("");

            case UnitsOfMeasurement.EnergyGramCalorie:
                return("");

            case UnitsOfMeasurement.EnergyKilogramCalorie:
                return("");

            case UnitsOfMeasurement.PerMille:
                return("");

            case UnitsOfMeasurement.PeriodBeatsPerMinute:
                return("");

            case UnitsOfMeasurement.ElectricChargeAmpereHours:
                return("");

            case UnitsOfMeasurement.ConcentrationCountPerCubicMetre:
                return("");

            case UnitsOfMeasurement.MilliliterPerKilogramPerMinute:
                return("");

            case UnitsOfMeasurement.MetabolicEquivalent:
                return("");

            case UnitsOfMeasurement.StepPerMinute:
                return("");

            case UnitsOfMeasurement.StrokePerMinute:
                return("");

            case UnitsOfMeasurement.PaceKilometrePerMinute:
                return("");

            case UnitsOfMeasurement.LuminousEfficacyLlumenPerWatt:
                return("");

            case UnitsOfMeasurement.LuminousEnergyLumenHour:
                return("");

            case UnitsOfMeasurement.VolumeFlowLlitrePerSecond:
                return("");

            case UnitsOfMeasurement.ConcentrationPartsPerMillion:
                return("");

            case UnitsOfMeasurement.ConcentrationPartsPerBillion:
                return("");

            case UnitsOfMeasurement.Unitless:
            case UnitsOfMeasurement.NOT_HANDLED:
            default:
                return("");
            }
        }
示例#24
0
 public MathObject(double value, MetricPrefixes prefix = MetricPrefixes.One, UnitsOfMeasurement units = UnitsOfMeasurement.Other)
 {
     this.value  = value;
     this.prefix = prefix;
     this.units  = units;
 }
示例#25
0
        public void TransformToSystemInternational_Test(double value, MetricPrefixes prefix, UnitsOfMeasurement uom, double expectedValue)
        {
            MathObject mathObject = new MathObject(value, prefix, uom);
            var        rawValue   = mathObject.TransformToSystemInternational();

            Assert.AreEqual(expectedValue, rawValue);
        }
示例#26
0
 public void AddToUnitsOfMeasurements(UnitsOfMeasurement unitsOfMeasurement)
 {
     base.AddObject("UnitsOfMeasurements", unitsOfMeasurement);
 }
示例#27
0
 public DiafragmRadius(double value = 1, MetricPrefixes metricPrefix = MetricPrefixes.One, UnitsOfMeasurement uom = UnitsOfMeasurement.Meter) : base(value, metricPrefix, uom)
 {
 }