public static void Add_FromMethods(Type t, XValueTypeName valueTypeName,
TypesGroup types, CsClass target, IRelatedUnitDefinition u)
{
#if DEBUG
if (target.Name == "Power")
{
System.Diagnostics.Debug.Write("");
}
#endif
foreach (var inputType in "decimal,double,int,long".Split(','))
{
var arg = "value";
if (inputType == OtherValuePropertyType)
{
arg = $"({ValuePropertyType}){arg}";
}
var args = new CsArguments(arg, types.Container + "." + u.FieldName)
.Create(target.Name);
var valueIn = $" value in {u.UnitShortCode.EffectiveValue}";
var methodName = "From" + u.FromMethodNameSufix.CoalesceNullOrWhiteSpace(u.FieldName);
var methodDescription = $"creates {types.Value.FirstLower()} from{valueIn}";
var cw = Ext.Create(t);
cw.WriteReturn(args);
var m = target.AddMethod(methodName, target.Name, methodDescription)
.WithStatic()
.WithBody(cw);
m.AddParam("value", inputType).Description = string.Format("{0}{1}", valueTypeName, valueIn);
}
}
/// <summary>
/// Creates instance
/// </summary>
/// <param name="value">Name of type that contains value and unit i.e. Length</param>
/// <param name="unit">Name of type that represents unit i.e. LengthUnit</param>
/// <param name="container">Name of static type that contains fields with known unit names i.e. LengthUnits</param>
public TypesGroup(XValueTypeName value, XUnitTypeName unit = null, XUnitContainerTypeName container = null)
{
Value = value ?? throw new ArgumentException(nameof(value));
ValueKind = Value.Kind;
Unit = unit ?? value.ToUnitTypeName();
Container = container ?? Unit.ToUnitContainerTypeName();
}
public RelatedUnit ByName(XValueTypeName name)
{
if (_dictionary.TryGetValue(name, out var x))
{
return(x);
}
return(null);
}
private static CommonFractionalUnit Make <T>(string counterUnit, string denominatorUnit,
string targetPropertyName = null)
{
if (targetPropertyName is null)
{
targetPropertyName = $"{counterUnit}sPer{denominatorUnit}s";
}
var typeName = new XValueTypeName(typeof(T).Name);
return(new CommonFractionalUnit(new TypesGroup(typeName), counterUnit, denominatorUnit,
targetPropertyName));
}
public RelatedUnit WithTime(int power)
{
var g = new[]
{
new PrefixedUnitInfo("MiliSecond", "ms", 0.001m),
new PrefixedUnitInfo("Second", "s", 1m),
new PrefixedUnitInfo("Minute", "min", 60, "Minutes"),
new PrefixedUnitInfo("Hour", "h", 3600, "Hours"),
new PrefixedUnitInfo("Year", "y", Time.SecondsPerYear, "Years")
};
var values = XValueTypeName.FromSplit(',', "Time,SquareTime");
return(WithPowerDerivedUnits(power, g, values));
}
public RelatedUnit WithLengths(int power)
{
var g = new[]
{
new PrefixedUnitInfo("Meter", "m", 1m),
new PrefixedUnitInfo("Km", "km", 1000m, "Kilometers"),
new PrefixedUnitInfo("Dm", "dm", 0.1m, "Decimeters"),
new PrefixedUnitInfo("Cm", "cm", 0.01m, "Centimeters"),
new PrefixedUnitInfo("Mm", "mm", 0.001m, "Milimeters"),
new PrefixedUnitInfo("Inch", "inch", 0.0254m, "Inches"),
new PrefixedUnitInfo("Feet", "ft", 0.3048m, "Foot"),
new PrefixedUnitInfo("Yard", "yd", 0.9144m, "Yards"),
new PrefixedUnitInfo("Furlong", "fg", 201.1680m, "Furlongs"),
new PrefixedUnitInfo("Fathom", "fh", 1.8288m),
new PrefixedUnitInfo("Mile", "mil", 1609.344m, "Miles"),
new PrefixedUnitInfo("NauticalMile", "nm", 1852m, "NauticalMiles")
};
return(WithPowerDerivedUnits(power, g, XValueTypeName.FromSplit(',', "Length,Area,Volume")));
}
private static void Scenario_Mul_Basic_Fract <THigh, TResult>(
OperatorCodeBuilderInput input,
string rightDenominator,
[CanBeNull] XValueTypeName resultDenominator)
{
var v1 = resultDenominator?.FirstLower() + "Unit";
var v2 = rightDenominator.FirstLower() + "Unit";
input.AddVariable("rightArgumentUnit", "$(right).Unit");
if (resultDenominator == input.OperatorParameters.Left.Value)
{
v1 = input.Replace("$(left).Unit");
}
else
{
input.AddVariable(v1, "$(left).Unit.Get" + resultDenominator + "Unit()");
}
input.AddVariable(v2, "$(left).Unit.Get" + rightDenominator + "Unit()");
input.AddVariable <THigh>("x3", "rightArgumentUnit.CounterUnit", v2);
input.ConvertRight("x3");
input.WithResultUnit <TResult>("rightArgumentUnit.CounterUnit", v1);
}
private void Add_Algebra_PlusMinus()
{
const string right = "right";
const string left = "left";
var delta = BasicUnitDefs.All.GetDeltaByUnit(Cfg.UnitTypes.Unit);
if (delta != null)
{
if (delta.UnitTypes.Value == Cfg.UnitTypes.Value)
{
delta = null;
}
}
void AddPlusOrMinus(string op, XValueTypeName lt, XValueTypeName rt)
{
var resultType = Cfg.UnitTypes.Value;
if (delta != null && op == "-")
{
resultType = delta.UnitTypes.Value;
}
string CreateResultFromVariable(string varName, XValueTypeName srcType, bool addMinus = false)
{
var result = addMinus ? "-" + varName : varName;
if (delta is null || srcType == resultType)
{
return(result);
}
var unitSource = varName;
if (lt != rt)
{
if (lt == resultType)
{
unitSource = left;
}
else if (rt == resultType)
{
unitSource = right;
}
else
{
throw new NotSupportedException();
}
}
result = new CsArguments(result + ".Value", unitSource + ".Unit").Create(resultType.ValueTypeName);
return(result);
}
var cw = Ext.Create <BasicUnitValuesGenerator>();
var result1 = CreateResultFromVariable(right, rt, op == "-");
var condition =
$"{left}.Value.Equals({ValuePropertyType}.Zero) && string.IsNullOrEmpty({left}.Unit?.UnitName)";
cw.SingleLineIf(condition, ReturnValue(result1));
result1 = CreateResultFromVariable(left, lt);
condition =
$"{right}.Value.Equals({ValuePropertyType}.Zero) && string.IsNullOrEmpty({right}.Unit?.UnitName)";
cw.SingleLineIf(condition, ReturnValue(result1));
cw.WriteLine($"{right} = {right}.ConvertTo({left}.Unit);");
var returnExpression = new CsArguments($"{left}.Value {op} {right}.Value", $"{left}.Unit")
.Create(resultType.ValueTypeName);
cw.WriteLine(ReturnValue(returnExpression));
Target.AddMethod(op, resultType.ValueTypeName)
.WithLeftRightArguments(lt.ValueTypeName, rt.ValueTypeName)
.WithBody(cw);
}
var targetName = new XValueTypeName(Target.Name);
AddPlusOrMinus("-", targetName, targetName);
if (delta != null)
{
AddPlusOrMinus("+", targetName, delta.UnitTypes.Value);
AddPlusOrMinus("+", delta.UnitTypes.Value, targetName);
}
else
{
AddPlusOrMinus("+", targetName, targetName);
}
}
public ProductUnit ByValueTypeName(XValueTypeName valueTypeName)
{
_d.TryGetValue(valueTypeName, out var tmp);
return(tmp);
}
public bool Equals(XValueTypeName other)
{
return(ValueTypeName.Equals(other.ValueTypeName));
}
public RelatedUnit(string name)
{
Name = new XValueTypeName(name);
}
public RelatedUnit(XValueTypeName name)
{
Name = name;
}
public FractionUnit ByValueTypeName(XValueTypeName valueTypeName)
{
_d.TryGetValue(valueTypeName, out var tmp);
return(tmp);
}