public static List <EngineClass> BuildAsList(List <EngineClass> classes)
{
Dictionary <IEngineObject, List <EngineClass> > subclassDictionary =
new Dictionary <IEngineObject, List <EngineClass> >();
Dictionary <string, EngineClass> classNameDictionary = new Dictionary <string, EngineClass>();
// Create a mapping from classname to class objects
classes.ForEach(x => classNameDictionary[x.Name] = x);
classes.ForEach(x => {
// First, filter out non-simclasses
if (x.SuperType == null)
{
return;
}
// Insert the current simclass as a subclass to the parent
if (!subclassDictionary.ContainsKey(x.SuperType))
{
subclassDictionary[x.SuperType] = new List <EngineClass>();
}
subclassDictionary[x.SuperType].Add(x);
});
List <EngineClass> simClasses = new List <EngineClass>();
// Locate the top-level class
EngineClass simObjectClass = classes.Find(x => x.Name == "SimObject");
// Insert all sim classes into the simClasses list
AddClassAndSubclasses(subclassDictionary, simClasses, simObjectClass);
return(simClasses);
}
public EngineClass GetMultipleClass()
{
try
{
var className = $"{Name}Response";
var result = new EngineClass()
{
Name = className,
Type = "object",
};
foreach (var response in Responses)
{
var engineProprty = new EngineProperty()
{
Name = response.Name,
Description = response.Description,
Type = QlikApiUtils.GetDotNetType(response.GetRealType()),
Required = response.Required,
Format = response.Format,
};
var serviceType = response.GetServiceType();
if (serviceType != null)
{
engineProprty.Type = serviceType;
}
result.Properties.Add(engineProprty);
}
return(result);
}
catch (Exception ex)
{
throw new Exception("The method \"GetMultipleClass\" was failed.", ex);
}
}
public void Execute()
{
SelectCarType();
Brand brand = SelectBrand();
SelectColour();
IColourDecoration colourDecoration = SelectColourDeco();
EngineClass engine = SelectEngine();
SelectWheel();
IWheelDeco wheelDeco = SelectWheelDeco();
Numberplate numberplate = AssignNumberplate();
IWheel wheel = (IWheel)Activator.CreateInstance(wheelList[listOfIndex.Last()], wheelDeco);
listOfIndex.RemoveAt(listOfIndex.Count - 1);
ICarColour carColour = (ICarColour)Activator.CreateInstance(carColourList[listOfIndex.Last()], colourDecoration);
listOfIndex.RemoveAt(listOfIndex.Count - 1);
Vehicle vehicle = (Vehicle)Activator.CreateInstance(types[listOfIndex.Last()], new object[] { carColour, wheel, brand, numberplate, engine });
Console.WriteLine("Congratulation you successfully added a new vehicle");
carDealer.AddVehicleToList(vehicle);
command = new PrintVehicleCommand()
{
List = carDealer.Vehicles
};
command.Execute();
listOfIndex.Clear();
}
public void GenerateHierarchy()
{
for (int index = Classes.Count - 1; index >= 0; index--)
{
EngineClass engineClass = Classes[index];
foreach (string parentClassName in engineClass.ParentClassNames)
{
foreach (EngineClass innerT6Class in Classes)
{
if (innerT6Class.ClassName.Equals(parentClassName))
{
engineClass.ParentClasses[parentClassName] = innerT6Class;
}
}
}
if (engineClass.ParentClasses.Count <= 0 && engineClass.ClassName != "SimObject")
{
Classes.Remove(engineClass);
}
}
foreach (EngineClass t6Class in Classes)
{
if (t6Class.DerivesFromSimObject)
{
continue;
}
t6Class.DerivesFromSimObject = t6Class.ParentsDerivesFromSimObject();
}
}
public ParseState Parse(XmlElement element, ParseState parseState)
{
string name = element.Attributes["name"].InnerText;
string docs = element.Attributes["docs"].InnerText;
string superType = element.Attributes["superType"]?.InnerText;
bool isAbstract = GenericMarshal.StringToBool(element.Attributes["isAbstract"].InnerText);
bool isInstantiable = GenericMarshal.StringToBool(element.Attributes["isInstantiable"].InnerText);
bool isDisposable = GenericMarshal.StringToBool(element.Attributes["isDisposable"].InnerText);
bool isSingleton = GenericMarshal.StringToBool(element.Attributes["isSingleton"].InnerText);
EngineClass engineClass = new EngineClass(name)
{
Docs = docs,
SuperTypeName = superType,
Scope = parseState.Scope,
IsAbstract = isAbstract,
IsInstantiable = isInstantiable,
IsDisposable = isDisposable,
IsSingleton = isSingleton
};
ParseState functionParseState = new ParseState()
.EnterScope(name);
foreach (XmlElement childNode in element.ChildNodes)
{
if (childNode.Name.Equals("properties"))
{
List <EngineClass.Property> properties = ParseProperties(childNode, null);
foreach (EngineClass.Property property in properties)
{
engineClass.Add(property);
}
}
else if (childNode.Name.Equals("exports"))
{
foreach (XmlElement funElement in childNode.ChildNodes)
{
if (funElement.Name.Equals("RegisterObject"))
{
Debugger.Break();
}
new FunctionParser().Parse(funElement, functionParseState);
}
}
else
{
}
}
foreach (EngineFunction engineFunction in functionParseState.Functions)
{
engineClass.Add(engineFunction);
}
parseState.Classes.Add(engineClass);
return(parseState);
}
public void WagFile(string filenamewithpath)
{
using (STFReader stf = new STFReader(filenamewithpath, false))
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("engine", () => { Engine = new EngineClass(stf); }),
new STFReader.TokenProcessor("_openrails", () => { OpenRails = new OpenRailsData(stf); }),
});
}
protected Vehicle(ICarColour carColour, IWheel wheel, Brand brand, Numberplate numberplate, EngineClass engine)
{
this.brand = brand;
this.carColour = carColour;
this.numberplate = numberplate;
this.wheel = wheel;
this.engine = engine;
id = ++counter;
price = wheel.Price() + carColour.CalculatePrice() + brand.GetPrice() + engine.GetPrice();
}
private static void AddClassAndSubclasses(Dictionary <IEngineObject, List <EngineClass> > subclassDictionary,
List <EngineClass> simClasses, EngineClass simObjectClass, bool isDatablock = false)
{
simObjectClass.IsDatablock = isDatablock;
simObjectClass.IsSimObject = true;
// Add this class to the simClasses
simClasses.Add(simObjectClass);
// If this class has no subclasses, return
if (!subclassDictionary.ContainsKey(simObjectClass))
{
return;
}
// Add the class and all subclasses
subclassDictionary[simObjectClass].ForEach(x =>
AddClassAndSubclasses(subclassDictionary, simClasses, x, isDatablock || x.Name == "SimDataBlock"));
}
public IEnumerable <CarClass> GetList()
{
string query = "SELECT * FROM cars";
MySqlDataReader reader = GetReader(query);
while (reader.Read())
{
int carId = int.Parse(reader[0].ToString());
BodyworkClass bodywork = SQLBodyworks.GetInstance().Search(reader[1].ToString());
EngineClass engine = SQLEngines.GetInstance().Search(reader[2].ToString());
ClientClass client = ClientService.SearchClientById(int.Parse(reader[3].ToString()));
int kilometrage = int.Parse(reader[4].ToString());
int cost = int.Parse(reader[5].ToString());
int carStatus = int.Parse(reader[6].ToString());
yield return(new CarClass(carId, bodywork, engine, client, kilometrage, cost, carStatus));
}
reader.Close();
}
public static string Render(EngineClass @class, string scope)
{
Template template;
using (StreamReader reader = new StreamReader("Resources/Templates/SimClass.scriban")) {
template = Template.Parse(reader.ReadToEnd(), "Resources/Templates/SimClass.scriban");
}
var scriptObject = new ScriptObject {
{ "class", @class },
{ "scope", scope }
};
scriptObject.Import(BaseTemplate.GetScriptObject());
var context = BaseTemplate.GetTemplateContext();
context.PushGlobal(scriptObject);
return(template.Render(context));
}
public CarClass Search(string carId)
{
string query = "SELECT * FROM cars WHERE carId='" + carId + "'";
CarClass car = null;
MySqlDataReader reader = GetReader(query);
try
{
reader.Read();
BodyworkClass bodywork = SQLBodyworks.GetInstance().Search(reader[1].ToString());
EngineClass engine = SQLEngines.GetInstance().Search(reader[2].ToString());
ClientClass client = ClientService.SearchClientById(int.Parse(reader[3].ToString()));
int kilometrage = int.Parse(reader[4].ToString());
int cost = int.Parse(reader[5].ToString());
int carStatus = int.Parse(reader[6].ToString());
car = new CarClass(int.Parse(carId), bodywork, engine, client, kilometrage, cost, carStatus);
}
catch (Exception e) { Console.WriteLine(e.Message); }
finally { reader.Close(); }
return(car);
}
private static void GenerateFor(string outputDir, EngineApi engineApi, EngineClass @class)
{
string scope = (string.IsNullOrEmpty(@class.Scope) ? "Global" : @class.Scope);
var scriptObject = new ScriptObject();
scriptObject.Add("class", @class);
scriptObject.Add("scope", scope);
string output = ClassTemplate.Render(@class, scope);
string dir = $"{outputDir}/Classes/{scope.Replace('.', '/')}";
Console.WriteLine($"{dir}/{@class.Name}.cs");
Directory.CreateDirectory(dir);
using (StreamWriter SW = new StreamWriter($"{dir}/{@class.Name}.cs")
) {
SW.Write(output);
}
}
private static List <EngineClass> ParseClassesFromHeaderFile(string pHeaderFile, List <CFunction> pFunctions)
{
List <EngineClass> classes = new List <EngineClass>();
StreamReader SR = new StreamReader(pHeaderFile);
while (!SR.EndOfStream)
{
string line = SR.ReadLine().Trim();
if (line.StartsWith("class") && line.Contains(":") && !line.Contains("##"))
{
MatchCollection parentMatches =
Regex.Matches(line,
":?\\s*,?\\s*public\\s+(?:virtual\\s+)?([a-zA-Z0-9:<>]+)");
MatchCollection classMatches =
Regex.Matches(line,
"class (?:(?:[a-zA-Z 0-9_]|::)* )?([a-zA-Z0-9]+)\\s*");
if (classMatches.Count <= 0)
{
continue;
}
EngineClass engineClass = new EngineClass(classMatches[0].Groups[1].Value);
foreach (Match match in parentMatches)
{
engineClass.ParentClassNames.Add(match.Groups[1].Value);
}
foreach (CFunction cFunction in pFunctions)
{
if (cFunction.FunctionName.StartsWith(engineClass.ClassName) &&
cFunction.FunctionParams.Count > 0 &&
cFunction.FunctionParams[0].ParamTypeInfo.DataName != null &&
cFunction.FunctionParams[0].ParamTypeInfo.DataName.Equals(engineClass.ClassName) ||
cFunction.FunctionName == engineClass.ClassName + "CreateInstance")
{
cFunction.OwnerClass = engineClass;
}
}
classes.Add(engineClass);
StringBuilder bodyBuilder = new StringBuilder();
int indentation = 0;
while ((line = SR.ReadLine()) != null)
{
if (line.Contains("}"))
{
indentation--;
}
if (indentation != 0)
{
bodyBuilder.AppendLine(line);
}
if (line.Contains("{"))
{
indentation++;
}
if (indentation == 0)
{
break;
}
}
}
}
SR.Close();
return(classes);
}
private static List <T6Field> ParseFieldsFromCCFile(string pCcFile, List <EngineClass> pClasses,
List <CFunction> pFunctions)
{
List <T6Field> fields = new List <T6Field>();
StreamReader SR = new StreamReader(pCcFile);
bool inComment = false;
while (!SR.EndOfStream)
{
string line = SR.ReadLine().Trim();
if (inComment)
{
line = "/*" + line; //hack
}
if (line.IndexOf("//", StringComparison.Ordinal) >= 0)
{
line = line.Remove(line.IndexOf("//", StringComparison.Ordinal));
}
while (line.IndexOf("/*", StringComparison.Ordinal) >= 0)
{
int commentStartIdx = line.IndexOf("/*", StringComparison.Ordinal);
if (line.IndexOf("*/", StringComparison.Ordinal) >= 0)
{
int commentEndIdx = line.IndexOf("*/", StringComparison.Ordinal);
line = line.Remove(commentStartIdx, commentEndIdx - commentStartIdx + 2);
inComment = false;
}
else
{
line = line.Remove(commentStartIdx);
inComment = true;
continue;
}
}
if (line.Contains("::initPersistFields()") &&
!line.Contains("Parent::initPersistFields()"))
{
Match match =
Regex.Matches(line,
"void\\s+([a-zA-Z 0-9:_]+)::initPersistFields()")
[0];
string className = match.Groups[1].Value;
EngineClass engineClass = pClasses.Find(c => c.ClassName.Equals(className));
int indentation = 0;
while ((line = SR.ReadLine()) != null)
{
line = line.Trim();
if (line.StartsWith("//"))
{
continue;
}
if (line.Contains("}"))
{
indentation--;
}
if (indentation != 0)
{
MatchCollection matches =
Regex.Matches(line,
"Field\\(\\s*\"?([a-zA-Z0-9:_]+)\"?[\\s,]+([a-zA-Z0-9:_]+)[\\s,]+(?:Offset\\([^\\)]*\\)|0)[\\s,]*([0-9]+)?");
if (matches.Count <= 0)
{
continue;
}
match = matches[0];
string fieldName = match.Groups[1].Value.Trim();
T6Field t6Field = new T6Field
{
FieldName = fieldName[0].ToString().ToUpper() + fieldName.Substring(1),
FieldTypeInfo = T6Field.TypeFromString(match.Groups[2].Value.Trim())
};
t6Field.FieldCount = match.Groups[3].Success ? int.Parse(match.Groups[3].Value.Trim()) : -1;
engineClass.Fields.Add(t6Field);
foreach (CFunction cFunction in pFunctions)
{
if (cFunction.OwnerClass != engineClass)
{
continue;
}
if (
cFunction.FunctionName.ToLower()
.Equals(engineClass.ClassName.ToLower() + "get" + t6Field.FieldName.ToLower()))
{
t6Field.GetterFunction = cFunction;
cFunction.PropertyFunction = true;
}
else if (
cFunction.FunctionName.ToLower()
.Equals(engineClass.ClassName.ToLower() + "set" + t6Field.FieldName.ToLower()))
{
t6Field.SetterFunction = cFunction;
cFunction.PropertyFunction = true;
}
}
fields.Add(t6Field);
}
if (line.Contains("{"))
{
indentation++;
}
if (indentation == 0)
{
break;
}
}
}
}
SR.Close();
return(fields);
}
private void AddDefinitions(JObject mergeObject)
{
try
{
var definitions = mergeObject["definitions"] as JObject;
foreach (var child in definitions.Children())
{
var jProperty = child as JProperty;
foreach (var subChild in child.Children())
{
logger.Debug($"Object name: {jProperty.Name}");
dynamic jObject = subChild as JObject;
var export = jObject?.export?.ToObject <bool>() ?? true;
if (!export)
{
continue;
}
var objectType = jObject?.type?.ToString() ?? null;
EngineClass engineClass = null;
switch (objectType)
{
case "object":
engineClass = jObject.ToObject <EngineClass>();
engineClass.Name = jProperty.Name;
//special case for .NET JObject - JsonObject is ignored
if (engineClass.Name == "JsonObject")
{
logger.Info("The class \"JsonObject\" is ignored because \"JObject\" already exists in the namespace Newtonsoft.");
continue;
}
engineClass.SeeAlso = GetValueFromProperty <List <string> >(jObject, "x-qlik-see-also");
var properties = ReadProperties(jObject, "properties", engineClass.Name);
if (properties.Count == 0)
{
logger.Info($"The Class \"{engineClass.Name}\" has no properties.");
}
engineClass.Properties.AddRange(properties);
EngineObjects.Add(engineClass);
//Special for ObjectInterface => Add IObjectInterface
if (engineClass.Name == Config.BaseObjectInterfaceClassName)
{
var baseInterface = new EngineInterface()
{
Name = Config.BaseObjectInterfaceName,
Description = "Generated Interface",
};
baseInterface.Properties.AddRange(engineClass.Properties);
EngineObjects.Add(baseInterface);
}
break;
case "array":
engineClass = jObject.ToObject <EngineClass>();
engineClass.Name = jProperty.Name;
engineClass.SeeAlso = GetValueFromProperty <List <string> >(jObject, "x-qlik-see-also");
var arrays = ReadProperties(jObject, "items", engineClass.Name);
engineClass.Properties.AddRange(arrays);
EngineObjects.Add(engineClass);
break;
case "enum":
EngineEnum engineEnum = jObject.ToObject <EngineEnum>();
engineEnum.Name = jProperty.Name;
var enums = GetEnumValues(jObject);
engineEnum.Values = enums;
if (EnumExists(engineEnum) == null)
{
EngineObjects.Add(engineEnum);
}
break;
default:
logger.Error($"Unknown object type {objectType}");
break;
}
}
}
}
catch (Exception ex)
{
logger.Error(ex, "The definitions could not be added.");
}
}
public Player(String PlayerName, EngineClass engine) : base(PlayerName, engine)
{
}
public Vehicle CreateVWVehicle(string name, CarColour carColour, IWheel wheel, Numberplate numberplate, EngineClass engine)
{
this.brand = new VW(name);
return(new Car(carColour, wheel, brand, numberplate, engine));
}
public Truck(ICarColour carColour, IWheel wheel, Brand brand, Numberplate numberplate, EngineClass engine)
:
base(carColour, wheel, brand, numberplate, engine)
{
}
public Vehicle CreateVehicle(CarColour carColour, IWheel wheel, Brand brand, Numberplate numberplate, EngineClass engine)
{
return(new Car(carColour, wheel, brand, numberplate, engine));
}