private void Add_Register()
{
if (Cfg.PrefixRelations.Count == 0)
{
return;
}
var cw = new CsCodeWriter();
foreach (var i in Cfg.PrefixRelations)
{
foreach (var u in Cfg.Units)
{
var o = u.FieldName.Substring(i.My.Length);
var p1 = u.FieldName;
var p2 = i.OtherUnitContainer + "s." + i.Other + o;
var q = $"dict.AddRelated<{i.MyUnitContainer}, {i.OtherUnitContainer}>({p1}, {p2});";
cw.WriteLine(q);
q = $"dict.AddRelated<{i.OtherUnitContainer}, {i.MyUnitContainer}>({p2}, {p1});";
cw.WriteLine(q);
}
}
Target.AddMethod("Register", "void")
.WithBody(cw)
.WithStatic()
.WithVisibility(Visibilities.Internal)
.AddParam <UnitRelationsDictionary>("dict", Target);
}
public static CsCodeWriter SingleLineForeach(this CsCodeWriter cs, string variable, string collection, string statement)
{
cs.WriteLine($"foreach (var {variable} in {collection})");
cs.IncIndent();
cs.WriteLine(statement);
cs.DecIndent();
return(cs);
}
private void Add_EqualsOverride()
{
// equals override
var cw = new CsCodeWriter();
cw.WriteLine("if (ReferenceEquals(null, obj)) return false;");
cw.WriteLine(ReturnValue("obj is " + Target.Name + " tmp && Equals(tmp)"));
var m = Target.AddMethod("Equals", "bool")
.WithOverride()
.WithBody(cw);
m.AddParam("obj", "object");
}
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);
}
}
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);
}
private void AddGetCodeItemsMethod()
{
if (!apps.Any())
{
return;
}
var target = MyStruct;
var optionsToStringCode = new CsCodeWriter();
for (var index = 0; index < apps.Count; index++)
{
if (index > 0)
{
optionsToStringCode.WriteLine();
}
var action = apps[index];
action(optionsToStringCode, target);
}
var m = target
.AddMethod("GetCodeItems", MyNamespace.GetTypeName <IEnumerable <string> >())
.WithBody(optionsToStringCode);
m.AddParam <OptionPreference>(preferLongNameVariable, ExtensionsClass).ConstValue =
ExtensionsClass.GetEnumValueCode(OptionPreference.Short);
}
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());
}
public void CreateArray(CsCodeWriter c, string prefix)
{
c.Open(prefix + "new []");
var lastIdx = Arguments.Length - 1;
for (var index = 0; index <= lastIdx; index++)
{
var i = Arguments[index];
if (index < lastIdx)
{
i += ",";
}
c.WriteLine(i);
}
c.DecIndent();
c.WriteLine("};");
}
public static void WriteDescriptionComment(this CsCodeWriter writer, OptionsCollectionValue option)
{
var description = option.FullDescription;
if (string.IsNullOrEmpty(description))
{
return;
}
writer.WriteLine("// " + description);
}
protected void Add_GetHashCode(string expression)
{
CodeWriter cw = new CsCodeWriter();
cw.Open("unchecked");
cw.WriteLine(ReturnValue(expression));
cw.Close();
Target.AddMethod("GetHashCode", "int")
.WithOverride()
.WithBody(cw);
}
public static CsCodeWriter WithThrowNotImplementedException(this CsCodeWriter cw, string message = null)
{
if (string.IsNullOrEmpty(message))
{
message = "Not implemented yet";
}
message = message.CsEncode();
var code = $"throw new NotImplementedException({message});";
cw.WriteLine(code);
return(cw);
}
private string Extensions_CheckConflictsCode(EnumsGeneratorItem item)
{
var conflicts = item.Options.IncompatibleValues.Where(a => a != null).ToArray();
if (conflicts.Length == 0)
{
return(null);
}
var code = new CsCodeWriter();
// check conflicts
var optionToItem = item.Options.GetMap();
var filter = new CodeVariable("flagsFilter");
var duplicates = new HashSet <string>();
foreach (var conflict in conflicts)
{
var first = optionToItem[conflict.Value1];
var second = optionToItem[conflict.Value2];
var argItemNames = new[] { first.GetCsName(), second.GetCsName() };
if (argItemNames[0] == argItemNames[1])
{
throw new Exception("Both options means the same");
}
if (!duplicates.Add(argItemNames[0] + "," + argItemNames[1]))
{
continue;
}
filter.Expression = GetMask(MyEnum, argItemNames);
var errorMessage = string.Format("options {0} can't be used together",
string.Join(" and ", first.AnyWithMinus, second.AnyWithMinus))
.CsEncode();
code.WriteLine(filter.GetCodeAndMarkAsDeclared());
code.SingleLineIf($"({valueVariable} & {filter.Name}) == {filter.Name}",
"throw new Exception(" + errorMessage + ");");
}
var m = ExtensionsClass
.AddMethod("CheckConflicts", "void")
.WithStatic()
.WithBody(code);
m.AddParam(valueVariable, MyEnum.Name).UseThis = true;
return(m.Name);
}
protected override void GenerateOne()
{
if (ClassicImpl)
{
Target.BaseClass = "JsonConverter";
Add_CanConvert();
Add_ReadJson();
Add_WriteJson();
}
else
{
var tt = Cfg.UnitTypes;
var valueTypeName = tt.Value.ValueTypeName;
Target.BaseClass = new CsArguments(valueTypeName, tt.Unit.TypeName).MakeGenericType("AbstractUnitJsonConverter");
{
var cw = new CsCodeWriter();
cw.WriteLine("unit = unit?.Trim();");
cw.WriteLine(
$"return new {tt.Value}(value, string.IsNullOrEmpty(unit) ? {tt.Value}.BaseUnit : new {tt.Unit}(unit));");
var m = Target.AddMethod("Make", valueTypeName)
.WithOverride()
.WithVisibility(Visibilities.Protected)
.WithBody(cw);
m.AddParam("value", BasicUnitValuesGenerator.ValuePropertyType);
m.AddParam("unit", "string");
}
{
var m = Target.AddMethod("Parse", valueTypeName)
.WithOverride()
.WithVisibility(Visibilities.Protected)
.WithBodyFromExpression(tt.Value + ".Parse(txt)");
m.AddParam("txt", "string");
}
}
}
protected void Add_EqualsUniversal(string compareType, bool nullable, OverridingType overridingType,
string compareCode)
{
var cw = new CsCodeWriter();
if (nullable)
{
cw.SingleLineIf("other is null", ReturnValue("false"));
}
cw.WriteLine(ReturnValue(compareCode));
var m = Target.AddMethod("Equals", "bool")
.WithBody(cw);
m.Overriding = overridingType;
m.AddParam("other", compareType);
}
public static CsCodeWriter Create(Type callerType, [CallerLineNumber] int lineNumber = 0,
[CallerMemberName] string memberName = null, [CallerFilePath] string filePath = null
)
{
var location = new SourceCodeLocation(lineNumber, memberName, filePath)
.WithGeneratorClass(callerType);
var code = new CsCodeWriter
{
Location = location
};
location = new SourceCodeLocation(0, memberName, filePath)
.WithGeneratorClass(callerType);
code.WriteLine("// generator : " + location);
return(code);
}
protected override void GenerateOne()
{
Target.IsStatic = true;
CsMethod Add1(string itemType, Action <CsCodeWriter> actions)
{
var cw = new CsCodeWriter();
cw.WriteLine();
cw.SingleLineIf("items is null", ReturnValue(Cfg.UnitTypes.Value + ".Zero"));
actions(cw);
var m = Target.AddMethod("Sum", Cfg.UnitTypes.Value.ValueTypeName)
.WithStatic()
.WithBody(cw);
m.AddParam("items", MakeGenericType <IEnumerable <int> >(Target, itemType)).UseThis = true;
return(m);
}
Add1(Cfg.UnitTypes.Value.ValueTypeName, cw =>
{
cw.WriteLine("var c = items.ToArray();");
cw.SingleLineIf("c.Length == 0", ReturnValue(Cfg.UnitTypes.Value + ".Zero"));
cw.SingleLineIf("c.Length == 1", ReturnValue("c[0]"));
cw.WriteLine("var unit = c[0].Unit;");
cw.WriteLine("var value = c.Aggregate(0m, (x, y) => x + y.ConvertTo(unit).Value);");
cw.WriteLine(ReturnValue($"new {Cfg.UnitTypes.Value}(value, unit)"));
});
Add1(Cfg.UnitTypes.Value + "?", cw =>
{
var c = "items.Where(a => a != null).Select(a => a.Value).Sum()";
cw.WriteLine(ReturnValue(c));
});
var mm = Add1("T", cw =>
{
var c = "items.Select(map).Sum()";
cw.WriteLine(ReturnValue(c));
});
mm.GenericArguments = new CsGenericArguments("T");
mm.AddParam("map", "Func<T, " + Cfg.UnitTypes.Value + ">");
}
private static bool TryHint(OperatorParams par, CsCodeWriter cw)
{
if (!(par.OperatorHints is null))
{
var builderInput = par.GetBuilder();
if (!(builderInput is null))
{
var builder = new OperatorCodeBuilder(builderInput);
cw.WriteLine("// scenario with hint");
builder.WriteCode(cw);
return(true);
}
}
// Console.WriteLine("args.Input" + par.DebugIs);
return(false);
}
private void Add_ReadJson()
{
var valueTypeName = Cfg.UnitTypes.Value;
var cw = new CsCodeWriter();
cw.Open("if (reader.ValueType == typeof(string))");
cw.SingleLineIf($"objectType == typeof({valueTypeName})",
ReturnValue($"{valueTypeName}.Parse((string)reader.Value)"));
cw.Close();
cw.WriteLine("throw new NotImplementedException();");
var m = Target.AddMethod("ReadJson", "object", "Reads the JSON representation of the object.")
.WithOverride()
.WithBody(cw);
m.AddParam <JsonReader>("reader", Target, "The JsonReader to read from.");
m.AddParam <Type>("objectType", Target, "Type of the object.");
m.AddParam <object>("existingValue", Target, "The existing value of object being read.");
m.AddParam <JsonSerializer>("serializer", Target, "The calling serializer.");
}
private bool CreateEnumAndConversionMethods()
{
var parts = _item.OwnerClasses;
var conflictsCodeMethod = Extensions_CheckConflictsCode(_item);
var optionsToStringCode = new CsCodeWriter();
optionsToStringCode.WriteLine("// generator : " + GetType().Name);
if (!string.IsNullOrEmpty(conflictsCodeMethod))
{
optionsToStringCode.WriteLine($"{conflictsCodeMethod}({valueVariable});");
}
var fb = new EnumFlagsBuilder(MyEnum);
fb.AddFlagsAttribute(MyNamespace);
var enumSource = from q in _item.Options.Values
where string.IsNullOrEmpty(q.Parameter?.Value)
select q;
var generate = false;
foreach (var option in enumSource)
{
generate = true;
var enumItem = new CsEnumItem(option.GetCsName())
{
Description = option.FullDescription,
};
var stringValue = GetStringValue(preferLongNameVariable, option, ExtensionsClass);
optionsToStringCode.WriteDescriptionComment(option);
var condition = GetEnumCondition(valueVariable, MyEnum, enumItem);
optionsToStringCode.SingleLineIf(condition, $"yield return {stringValue};");
MyStruct_AddWithMethod(enumItem, fb.Value == 1);
fb.Append(enumItem);
{
apps.Add((w, r) =>
{
var stringValue = GetStringValue(preferLongNameVariable, option, ExtensionsClass);
w.WriteDescriptionComment(option);
var condition = GetEnumCondition(flagsPropertyName, MyEnum, enumItem);
w.SingleLineIf(condition, $"yield return {stringValue};");
});
}
}
if (!generate)
{
return(false);
}
{
var m = ExtensionsClass
.AddMethod("OptionsToString", MyNamespace.GetTypeName <IEnumerable <string> >())
.WithStatic()
.WithBody(optionsToStringCode);
m.AddParam(valueVariable, MyEnumTypeName).UseThis = true;
m.AddParam <OptionPreference>(preferLongNameVariable, ExtensionsClass).ConstValue =
ExtensionsClass.GetEnumValueCode(OptionPreference.Short);
}
AddEnumToOutput(parts, MyNamespace, MyEnum);
return(true);
}
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);
}
}
protected void Add_Constructor(Col1 col)
{
var target = Target;
var code = new CsCodeWriter();
var m = target.AddConstructor("creates instance of " + target.Name);
var c = col.Writer1.Code;
if (!string.IsNullOrEmpty(c))
{
code.WriteLine(c);
}
foreach (var i in col.Items)
{
var flags = i.CheckingFlags;
code.CheckArgument(i.ArgName, flags.ConvertToArgChecking(), Target);
var p = m.AddParam(i.PropertyName.FirstLower(), i.PropertyType, i.Description);
if ((flags & Flags1.Optional) != 0)
{
p.ConstValue = "null";
}
/*if ((flags & Flags1.TrimValue) != 0)
* {
* code.WriteLine("{0} = {0}?.Trim();", i.ArgName);
* flags &= ~Flags1.TrimValue;
*
* if ((flags & Flags1.NotWhitespace) != 0)
* {
* flags &= ~Flags1.NotWhitespace;
* flags |= Flags1.NotEmpty;
* }
* }*/
/*if ((flags & Flags1.NotNull) != 0)
* {
* flags &= ~Flags1.NotNull;
* p.Attributes.Add(CsAttribute.Make<NotNullAttribute>(target));
* var throwCode = new Args($"nameof({i.ArgName})")
* .Throw<NullReferenceException>(target);
* code.SingleLineIf($"{i.ArgName} is null", throwCode);
* }*/
/*if ((flags & Flags1.NotWhitespace) != 0)
* {
* flags &= ~(Flags1.NotEmpty | Flags1.NotWhitespace);
* // var m = nameof(string.IsNullOrWhiteSpace);
* var throwCode = new Args($"nameof({i.ArgName})")
* .Throw<ArgumentException>(target);
* code.SingleLineIf($"string.IsNullOrWhiteSpace({i.ArgName})", throwCode);
*
* flags &= ~(Flags1.NotNullOrWhitespace | Flags1.NotNullOrEmpty);
* }
*
* if ((flags & Flags1.NotEmpty) != 0)
* {
* flags &= ~Flags1.NotEmpty;
* //var m = nameof(string.IsNullOrEmpty);
* var throwCode = new Args($"nameof({i.ArgName})")
* .Throw<ArgumentException>(target);
* code.SingleLineIf($"string.IsNullOrEmpty({i.ArgName})", throwCode);
*
* flags &= ~(Flags1.NotNullOrWhitespace | Flags1.NotNullOrEmpty);
* }*/
if ((flags & Flags1.DoNotAssignProperty) == 0)
{
code.WriteAssign(i.PropertyName, i.Expression);
}
}
c = col.Writer2.Code;
if (!string.IsNullOrEmpty(c))
{
code.WriteLine(c);
}
m.WithBody(code);
}
