protected override IEnumerable <string> GetImplementedInterfaces()
{
var name = new CsArguments(Cfg.CounterUnit.Unit.GetTypename(), Cfg.DenominatorUnit.Unit.GetTypename())
.MakeGenericType(nameof(IFractionalUnit));
return(new[] { name });
}
private void Add_StaticFields()
{
foreach (var i in _relatedUnit.Units)
{
var unitTypeName = Cfg.TargetUnitTypename;
var f1Name = i.FieldName + unitTypeName;
var f1Type = unitTypeName;
var v = Cfg.Source.Container.GetTypename() + "." + i.FieldName + Cfg.Source.Unit.GetTypename();
v = new CsArguments(v).Create(f1Type);
var field = Target.AddField(f1Name, f1Type)
.WithStatic()
.WithIsReadOnly()
.WithVisibility(Visibilities.Internal)
.WithConstValue(v)
.Description = $"unit 1/{i.UnitShortCode.EffectiveValue}";
var unitDefinitionType = new CsArguments(unitTypeName)
.MakeGenericType("UnitDefinition");
var value = new CsArguments(f1Name, Inverse(i.ScaleFactor)).Create(unitDefinitionType);
field = Target.AddField(i.FieldName, unitDefinitionType)
.WithIsReadOnly()
.WithStatic()
.WithConstValue(value)
.Description = $"unit 1/{i.UnitShortCode.EffectiveValue} with factor";
}
}
public void AddVariable <T>(string name, params string[] a)
{
a = a.Select(Replace).ToArray();
var code = new CsArguments(a).Create <T>();
AddVariable(name, code);
}
public string MakeGenericTypeMethodCall(string methodName, params string [] args)
{
var call1 = MakeGenericType(methodName);
var a = new CsArguments(args);
return(a.CallMethod(call1));
}
public static void Throw <T>(this CsCodeWriter cs, params string[] arguments)
{
var exception = new CsArguments(arguments).Create <T>();
var code = $"throw {exception};";
cs.WriteLine(code);
}
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);
}
}
private void Add_ConvertOtherPower()
{
var infos = RelatedUnitGeneratorDefs.All;
var tmp = infos.GetPowers(Cfg);
if (tmp?.MyInfo is null || tmp.Other.Count == 0)
{
return;
}
foreach (var i in tmp.Other.Values)
{
var targetUnit = new TypesGroup(i.Name);
if (Cfg == targetUnit.Unit)
{
continue;
}
var cw = Ext.Create <BasicUnitGenerator>();
var code = new CsArguments(Target.Name, targetUnit.Unit.GetTypename())
.MakeGenericTypeMethodCall("GlobalUnitRegistry.Relations.GetOrThrow", "this");
cw.WriteReturn(code);
var m = Target.AddMethod("Get" + targetUnit.Unit.TypeName, targetUnit.Unit.GetTypename()).WithBody(cw);
m.WithAggressiveInlining(Target);
m.AddRelatedUnitSourceAttribute(Target, RelatedUnitSourceUsage.ProvidesRelatedUnit, 10);
}
}
public static CsMethod AddOperator(this CsClass cl, string operatorName, CsArguments csArgument, string resultType = null)
{
resultType = resultType.CoalesceNullOrWhiteSpace(cl.Name);
var code = csArgument.Create(resultType);
return(cl.AddMethod(operatorName, resultType, "implements " + operatorName + " operator")
.WithBodyFromExpression(code));
}
public override string ToString()
{
var l = Left.Value + " " + LeftMethodArgumentName;
var r = Right.Value + " " + RightMethodArgumentName;
var args = new CsArguments(l, r);
var methodName = $"{Result.Value} operator {Oper}";
return(args.CallMethod(methodName));
}
private void Add_WithSecond()
{
var cw = Ext.Create(GetType());
var e = new CsArguments("newUnit", _info.SecondPropertyName).Create(Target.Name);
cw.WriteLine($"return {e};");
Target.AddMethod($"With{_info.FirstPropertyName}", Cfg.UnitTypes.Unit.TypeName)
.WithBody(cw)
.AddParam("newUnit", _info.First.Unit.TypeName);
}
private void Add_Properties()
{
foreach (var i in Cfg.Units)
{
var unitTypeName = Cfg.Name.ToUnitTypeName().GetTypename();
var n2 = i.FieldName + unitTypeName;
{
var constValue = i.UnitConstructor;
if (string.IsNullOrEmpty(constValue))
{
var args = i.UnitShortCode.GetCreationArgs(Related);
constValue = args.Create(unitTypeName);
}
Target.AddField(n2, unitTypeName)
.WithIsReadOnly()
.WithVisibility(Visibilities.Internal)
.WithConstValue(constValue)
.WithStatic();
}
{
var args = new[]
{
n2,
i.ScaleFactor
};
if (i.Aliases != null)
{
args = i.Aliases.Plus(args);
}
var unitDefinitionType = new CsArguments(unitTypeName)
.MakeGenericType("UnitDefinition");
// public static readonly UnitDefinition<LengthUnit> Km
// = new UnitDefinition<LengthUnit>("km", 1000m);
var value = new CsArguments(args).Create(unitDefinitionType);
Target.AddField(i.FieldName, unitDefinitionType)
.WithIsReadOnly()
.WithStatic()
.WithConstValue(value);
}
if (i.AddFromMethod)
{
var c = Get(Cfg.Name.ValueTypeName, out var file);
CsFilesManager.AddGeneratorName(file, GetType().Name);
var value = new CsArguments("value", Target.Name + "." + i.FieldName + ".Unit").Create(c.Name);
c.AddMethod("From" + i.FieldName, c.Name).WithBody($"return {value};")
.WithParameter(new CsMethodParameter("value", "decimal"));
}
}
}
private void Add_StaticConstructor()
{
var cw = Ext.Create(GetType());
var array = new CsArguments(_relatedUnit.Units.Select(q => q.FieldName).ToArray());
array.CreateArray(cw, "All = ");
var c = Target.AddConstructor().WithStatic().WithBody(cw);
Target.AddField("All", AllPropertyTypeName).WithStatic().WithIsReadOnly()
.Description = $"All known {Cfg.TargetUnitTypename.FirstLower()} units";
}
private void Add_AllProperty()
{
var cw = new CsCodeWriter();
var array = new CsArguments(Cfg.Units.Select(q => q.FieldName).ToArray());
array.CreateArray(cw, "return ");
Target.AddProperty("All", "IReadOnlyList<UnitDefinition<" + Cfg.Name + "Unit>>")
.WithIsPropertyReadOnly()
.WithNoEmitField()
.WithStatic()
.WithOwnGetter(cw.Code)
.Description = $"All known {Cfg.Name.FirstLower()} units";
}
public void WriteCode(CsCodeWriter cw)
{
if (!string.IsNullOrEmpty(_input.Comment))
{
var lines = _input.Comment.Split('\r', '\n').Where(a => !string.IsNullOrWhiteSpace(a));
foreach (var i in lines)
{
cw.WriteLine("// " + i);
}
}
if (_input.Throw)
{
cw.WriteLine("// " + _input.OperatorParameters.DebugIs);
cw.WriteLine("throw new " + nameof(NotImplementedException) + "();");
return;
}
var right = OperatorParameters.RightMethodArgumentName;
var left = OperatorParameters.LeftMethodArgumentName;
foreach (var i in _input.Vars)
{
cw.WriteAssign(i.Name, i.Code, true);
}
if (!string.IsNullOrEmpty(RightValue))
{
right += "Converted";
cw.WriteAssign(right, RightValue, true);
}
if (string.IsNullOrEmpty(_input.UseReturnExpression))
{
var value = string.IsNullOrEmpty(_input.UseValueExpression)
? $"{left}.Value {OperatorParameters.Oper} {right}.Value"
: _input.UseValueExpression;
if (!string.IsNullOrEmpty(_input.ResultMultiplication))
{
value += " * " + _input.ResultMultiplication;
}
cw.WriteAssign("value", value, true);
var code = new CsArguments("value", ResultUnit).Create(OperatorParameters.Result.Value.ValueTypeName);
cw.WriteReturn(code);
}
else
{
cw.WriteReturn(_input.UseReturnExpression);
}
}
private void Add_AlternateConstructor()
{
var f = GenInfo.FirstPropertyName.FirstLower();
var s = GenInfo.SecondPropertyName.FirstLower();
var cw = new CsCodeWriter();
var code = new CsArguments(f, s).Create(GenInfo.Result.Unit);
cw.WriteLine("{0} = {1};", ValuePropName, ValuePropName.FirstLower());
cw.WriteLine("{0} = {1};", UnitPropName, code);
var m = Target.AddConstructor()
.WithBody(cw);
m.AddParam(ValuePropName.FirstLower(), ValuePropertyType);
m.AddParam(f, GenInfo.First.Unit.GetTypename());
m.AddParam(s, GenInfo.Second.Unit.GetTypename());
}
private static CsCodeWriter CreateCodeForFractionalResult(OperatorParams p)
{
var cw = Ext.Create <MultiplyAlgebraGenerator>();
cw.WriteLine("// scenario E");
var args = new CsArguments(
$"{p.LeftMethodArgumentName}.Value {p.Oper} {p.RightMethodArgumentName}.Value",
$"{p.LeftMethodArgumentName}.Unit",
$"{p.RightMethodArgumentName}.Unit"
);
var tResult = p.Result.Value;
var expression = args.Create(tResult.ValueTypeName);
cw.WriteLine($"return {expression};");
return(cw);
}
private void Add_Decompose()
{
var basicUnit = Cfg.Source.Unit;
var resultType = Target.GetTypeName <DecomposableUnitItem>();
var cs = Ext.Create(GetType());
cs.WriteAssign("tmp", "Get" + basicUnit.TypeName + "()", true);
var args = new CsArguments("tmp", "-1").Create(resultType);
cs.WriteReturn(args);
var m = Target.AddMethod(nameof(IDerivedDecomposableUnit.GetBasicUnit), resultType);
m.WithBody(cs);
Target.ImplementedInterfaces.Add(nameof(IDerivedDecomposableUnit));
}
private void Add_Decompose()
{
if (Related is null || !Related.IsPower2OrHigher)
{
return;
}
var basicUnit = BaseUnit;
{
var type = new CsArguments(Target.GetTypeName <DecomposableUnitItem>())
.MakeGenericType(Target.GetTypeName <IReadOnlyList <int> >(), true);
var cs = Ext.Create(GetType());
if (basicUnit is null)
{
throw new NotSupportedException();
/*cs.WriteLine("var decomposer = new UnitDecomposer();");
* cs.WriteLine("decomposer.Add(this, 1);");
* cs.WriteReturn("decomposer.Items");*/
}
else
{
cs.WriteReturn("new[] { " + nameof(IDerivedDecomposableUnit.GetBasicUnit) + "() }");
}
var m = Target.AddMethod(nameof(IDecomposableUnit.Decompose), type);
m.WithBody(cs);
Target.ImplementedInterfaces.Add(nameof(IDecomposableUnit));
}
// if (basicUnit != null)
{
var resultType = Target.GetTypeName <DecomposableUnitItem>();
var cs = Ext.Create(GetType());
cs.WriteAssign("tmp", "Get" + basicUnit.Name + "Unit()", true);
var args = new CsArguments("tmp", Related.MyInfo.Power.CsEncode()).Create(resultType);
cs.WriteReturn(args);
var m = Target.AddMethod(nameof(IDerivedDecomposableUnit.GetBasicUnit), resultType);
m.WithBody(cs);
Target.ImplementedInterfaces.Add(nameof(IDerivedDecomposableUnit));
}
}
private void Add_Decompose()
{
var items = _info2?.Items;
if (items is null || items.Length == 0)
{
return;
}
var type = new CsArguments(Target.GetTypeName <DecomposableUnitItem>())
.MakeGenericType(Target.GetTypeName <IReadOnlyList <int> >(), true);
var cs = Ext.Create(GetType());
{
// creates code
var codeItems = new DecomposeExpressionFinder(typeof(Length).Assembly).GetCodeItems(items, Target.Name);
if (codeItems != null)
{
var initCodes = codeItems.Select(a => a.Init).Where(a => !string.IsNullOrWhiteSpace(a));
foreach (var i in initCodes)
{
cs.WriteLine(i);
}
cs.WriteLine(new CsArguments(codeItems.Select(a => a.Expression).ToArray()).ReturnArray().Code);
cs.WriteLine("/*");
}
cs.WriteLine("var decomposer = new UnitDecomposer();");
foreach (var item in items)
{
cs.WriteLine("decomposer.Add({0}, {1});", item.Propertyname, item.Power.CsEncode());
}
cs.WriteReturn("decomposer.Items");
if (codeItems != null)
{
cs.WriteLine("*/");
}
var m = Target.AddMethod(nameof(IDecomposableUnit.Decompose), type);
m.WithBody(cs);
}
Target.ImplementedInterfaces.Add(nameof(IDecomposableUnit));
}
protected override void GenerateOne()
{
_info = GetInfo();
_info2 = GetInfo2();
Target.Kind = CsNamespaceMemberKind.Class;
Target.IsSealed = true;
foreach (var i in GetImplementedInterfaces())
{
Target.ImplementedInterfaces.Add(i);
}
var name = new CsArguments(Cfg.UnitTypes.Unit.TypeName).MakeGenericType("IEquatable");
Target.ImplementedInterfaces.Add(name);
var pi = new[]
{
new ConstructorParameterInfo(_info.FirstPropertyName, _info.First.Unit.TypeName, null,
_info.FirstPropertyName.Decamelize().ToLower()),
new ConstructorParameterInfo(_info.SecondPropertyName, _info.Second.Unit.TypeName, null,
_info.SecondPropertyName.Decamelize().ToLower())
};
var col1 = new Col1(pi);
Add_Constructor(col1);
Add_Properties(col1);
Add_UnitNameProperty();
Add_Equals();
Add_GetHashCode(
$"({_info.FirstPropertyName}.GetHashCode() * 397) ^ {_info.SecondPropertyName}.GetHashCode()");
AddCommon_EqualityOperators();
Add_ToString(PropertyName);
Add_WithFirst();
Add_WithSecond();
Add_Decompose();
}
public void Generate(CommonFractionalUnitsCollection collection)
{
foreach (var item in collection.Items)
{
var cl = GetClass(item.Type.Container.GetTypename());
cl.AddComment(item.ToString());
FractionUnit fuDefinition = null;
var description = string.Format("represents {0} unit '{1}'",
item.Type.Value.FirstLower(), item.GetUnitName(ref fuDefinition));
var p1 = fuDefinition.CounterUnit.Container + "." + item.CounterUnit;
var p2 = fuDefinition.DenominatorUnit.Container + "." + item.DenominatorUnit;
var x = new CsArguments(p1, p2).Create(item.Type.Unit);
var f = cl.AddField(item.TargetPropertyName, item.Type.Unit.GetTypename())
.WithStatic()
.WithIsReadOnly()
.WithConstValue(x);
f.Description = description;
}
}
public void ConvertRight <T>(params string[] a)
{
var type = new CsArguments(a).Create <T>();
ConvertRight(type);
}
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);
}
}
protected void Add_Parse(string splitMethodName)
{
string ArrayItemCode(ref int columnIndex)
{
return($"units[{(columnIndex++).CsEncode()}]");
}
CsArguments GetConstructorArguments(TypesGroup tg, ref int columnIndex)
{
var aa = ProductUnitDefs.All;
var a4 = aa.ByValueTypeName(tg.Value);
var arguments = ArrayItemCode(ref columnIndex);
if (a4 is null)
{
return(new CsArguments(arguments));
}
return(new CsArguments(
new CsArguments(arguments).Create(a4.CounterUnit.Unit.TypeName),
new CsArguments(ArrayItemCode(ref columnIndex)).Create(a4.DenominatorUnit.Unit.TypeName)
));
}
CsArguments licznik, mianownik;
{
var columnIndex = 0;
if (Cfg is FractionUnit fu)
{
licznik = GetConstructorArguments(fu.CounterUnit, ref columnIndex);
mianownik = GetConstructorArguments(fu.DenominatorUnit, ref columnIndex);
}
else
{
licznik = new CsArguments(ArrayItemCode(ref columnIndex));
mianownik = new CsArguments(ArrayItemCode(ref columnIndex));
}
}
var cw = Ext.Create(GetType());
if (string.IsNullOrEmpty(splitMethodName))
{
cw.WithThrowNotImplementedException("Not implemented due to unknown split method name.");
}
else
{
cw.SingleLineIf("string.IsNullOrEmpty(value)",
"throw new ArgumentNullException(nameof(value));");
cw.WriteLine("var r = CommonParse.Parse(value, typeof(" + Target.Name + "));");
cw.WriteLine("var units = " + splitMethodName + "(r.UnitName);");
var sum = mianownik.Arguments.Length + licznik.Arguments.Length;
cw.SingleLineIf("units.Length != " + sum.CsEncode(),
"throw new Exception($\"{r.UnitName} is not valid " + Target.Name + " unit\");");
cw.WriteAssign("counterUnit", new CsArguments("units[0]").Create(GenInfo.First.Unit), true);
//cw.WriteLine("var counterUnit = new " + GenInfo.First.Unit + "(units[0]);");
cw.WriteAssign("denominatorUnit", mianownik.Create(GenInfo.Second.Unit), true);
// cw.WriteLine("var denominatorUnit = new " + GenInfo.Second.Unit + "(units[1]);");
cw.WriteLine(ReturnValue($"new {Target.Name}(r.Value, counterUnit, denominatorUnit)"));
}
var m = Target.AddMethod("Parse", GenInfo.Result.Value.ValueTypeName)
.WithStatic()
.WithBody(cw);
m.AddParam("value", "string");
}
public static void CheckArgument(this CsCodeWriter code, string argName, ArgChecking flags,
ITypeNameResolver resolver)
{
if (flags == ArgChecking.None)
{
return;
}
var canBeNull = true;
var argNameToRead = argName + "?";
if ((flags & ArgChecking.NotNull) != 0)
{
var throwCode = new CsArguments($"nameof({argName})")
.Throw <NullReferenceException>(resolver);
code.SingleLineIf($"{argName} is null", throwCode);
canBeNull = false;
argNameToRead = argName;
}
if ((flags & ArgChecking.TrimValue) != 0)
{
code.WriteLine("{0} = {1}.Trim();", argName, argNameToRead);
flags &= ~ArgChecking.TrimValue;
if ((flags & ArgChecking.NotWhitespace) != 0)
{
flags &= ~ArgChecking.NotWhitespace;
flags |= ArgChecking.NotEmpty;
}
}
if ((flags & ArgChecking.NotNull) != 0 && canBeNull)
{
flags &= ~ArgChecking.NotNull;
//p.Attributes.Add(CsAttribute.Make<NotNullAttribute>(target));
var throwCode = new CsArguments($"nameof({argName})")
.Throw <NullReferenceException>(resolver);
code.SingleLineIf($"{argName} is null", throwCode);
}
if ((flags & ArgChecking.NotWhitespace) != 0)
{
flags &= ~(ArgChecking.NotEmpty | ArgChecking.NotWhitespace);
// var m = nameof(string.IsNullOrWhiteSpace);
var throwCode = new CsArguments($"nameof({argName})")
.Throw <ArgumentException>(resolver);
code.SingleLineIf($"string.IsNullOrWhiteSpace({argName})", throwCode);
flags &= ~(ArgChecking.NotNullOrWhitespace | ArgChecking.NotNullOrEmpty);
}
if ((flags & ArgChecking.NotEmpty) != 0)
{
flags &= ~ArgChecking.NotEmpty;
var throwCode = new CsArguments($"nameof({argName})")
.Throw <ArgumentException>(resolver);
var condition =
canBeNull
? $"string.IsNullOrEmpty({argName})"
: $"{argName}.Length == 0";
code.SingleLineIf(condition, throwCode);
}
}
public void WithResultUnit <T>(params string[] a)
{
a = a.Select(Replace).ToArray();
ResultUnit = new CsArguments(a).Create <T>();
}