public void TestReplaced2() { TextFile file1 = new TextFile(); file1.AddLine("1"); file1.AddLine("4"); file1.AddLine("3"); TextFile file2 = new TextFile(); file2.AddLine("2"); FileComparer fileComparer = new FileComparer(); ModificationCollection report = fileComparer.Compare(file1, file2); ModificationAreEqual(report[0], "Replaced", 0, 0, 1); ModificationAreEqual(report[1], "Removed", 1, -1, 2); }
// [MenuItem("JS for Unity/Generate JS Enum Bindings")] // public static void GenerateEnumBindings() // { // JSGenerator2.OnBegin(); // // for (int i = 0; i < JSBindingSettings.enums.Length; i++) // { // JSGenerator2.Clear(); // JSGenerator2.type = JSBindingSettings.enums[i]; // JSGenerator2.GenerateEnum(); // } // // JSGenerator2.OnEnd(); // // Debug.Log("Generate JS Enum Bindings finish. total = " + JSBindingSettings.enums.Length.ToString()); // } //public static Dictionary<Type, string> typeClassName = new Dictionary<Type, string>(); //static string className = string.Empty; public static void GenBindings(Type[] arrEnums, Type[] arrClasses) { JSGenerator.OnBegin(); TextFile tfAll = new TextFile(); TextFile tfFun = tfAll.Add("(function ($hc) {").In().Add("\"use strict\";"); int hc = 1; // enums for (int i = 0; i < arrEnums.Length; i++) { JSGenerator.Clear(); JSGenerator.type = arrEnums[i]; TextFile tf = JSGenerator.GenEnum(); if (tf != null) { tfFun.Add("if ($hc < {0}) {{ return; }}", hc++); tfFun.AddLine().Add(tf.Ch); } } // classes for (int i = 0; i < arrClasses.Length; i++) { JSGenerator.Clear(); JSGenerator.type = arrClasses[i]; //if (!typeClassName.TryGetValue(type, out className)) // className = type.Name; TextFile tf = JSGenerator.GenerateClass(); tfFun.Add("if ($hc < {0}) {{ return; }}", hc++); tfFun.AddLine() //.Add("if (Bridge.findObj(\"{0}\") == null) {{", type.JsFullName()) //.In() .Add(tf.Ch) //.BraceOut() ; } tfFun.Out().Add("})(1000000);"); File.WriteAllText(JSMgr.jsGenFile, tfAll.Format(-1)); JSGenerator.OnEnd(); Debug.Log("Generate JS Bindings OK. enum " + arrEnums.Length.ToString() + ", class " + arrClasses.Length.ToString()); }
public void TestAdded() { TextFile file1 = new TextFile(); file1.AddLine("1"); file1.AddLine("3"); TextFile file2 = new TextFile(); file2.AddLine("1"); file2.AddLine("2"); file2.AddLine("3"); FileComparer fileComparer = new FileComparer(); ModificationCollection report = fileComparer.Compare(file1, file2); ModificationAreEqual(report[0], "NoChanged", 0, 0, 1); ModificationAreEqual(report[1], "Added", -1, 1, 1); ModificationAreEqual(report[2], "NoChanged", 1, 2, 1); }
public void TestEmptyFiles() { TextFile emptyFile = new TextFile(); TextFile file2 = new TextFile(); file2.AddLine("public class MyClass"); file2.AddLine("{"); file2.AddLine("}"); FileComparer fileComparer = new FileComparer(); ModificationCollection report = fileComparer.Compare(emptyFile, file2); ModificationAreEqual(report[0], "Added", -1, 0, 3); report = fileComparer.Compare(file2, emptyFile); ModificationAreEqual(report[0], "Removed", 0, -1, 3); report = fileComparer.Compare(emptyFile, emptyFile); Assert.AreEqual(report.Count, 0); }
public void TestMethod1() { TextFile file1 = new TextFile(); file1.AddLine("public class MyClass"); file1.AddLine("{"); file1.AddLine(" public MyClass()"); file1.AddLine(" { }"); file1.AddLine(); file1.AddLine(" public string StringProperty"); file1.AddLine(" {"); file1.AddLine(" get;"); file1.AddLine(" set;"); file1.AddLine(" }"); file1.AddLine("}"); TextFile file2 = new TextFile(); file2.AddLine("public class MyClass"); file2.AddLine("{"); file2.AddLine(" public MyClass()"); file2.AddLine(" { }"); file2.AddLine(); file2.AddLine(" public int MyMethod(int value)"); file2.AddLine(" {"); file2.AddLine(" Console.WriteLine(value);"); file2.AddLine(" }"); file2.AddLine("}"); FileComparer fileComparer = new FileComparer(); ModificationCollection report = fileComparer.Compare(file1, file2); ModificationAreEqual(report[0], "NoChanged", 0, 0, 5); ModificationAreEqual(report[1], "Replaced", 5, 5, 1); ModificationAreEqual(report[2], "NoChanged", 6, 6, 1); ModificationAreEqual(report[3], "Replaced", 7, 7, 1); ModificationAreEqual(report[4], "Removed", 8, -1, 1); ModificationAreEqual(report[5], "NoChanged", 9, 8, 2); }
static void GenAMessage(Info info) { TextFile tf = new TextFile(null, "// auto gen"); tf.Add("using UnityEngine;"); tf.Add("using UnityEngine.UI;"); tf.AddLine(); TextFile tfNs = tf.Add("namespace jsb").BraceIn(); { TextFile tfC = tfNs.Add("public class {0} : MonoBehaviour", info.className).BraceIn(); { TextFile tfM = tfC.Add("public void {0}", info.signature).BraceIn(); { tfM.Add("JSComponent[] coms = GetComponents<JSComponent>();") .Add("if (coms == null || coms.Length == 0)") .BraceIn() .Add("Destroy(this);") .Add("return;") .BraceOut() .AddLine() .Add("foreach (var com in coms)"); TextFile tfF = tfM.BraceIn(); { tfF.Add("com.RecvMsg({0});", info.argList); } tfF.BraceOut(); } tfM.BraceOut(); } tfC.BraceOut(); } tfNs.BraceOut(); string s = tf.Format(-1); File.WriteAllText(CsDir + "/" + info.className + ".cs", s); }
/// <summary> /// Import a new strategy from an external file (given as parameter) /// </summary> /// <param name="inputFileName">filename of internal file</param> /// <param name="patternFileName">pattern file to use for the importation</param> /// <returns></returns> public int Import(String inputFileName, String patternFileName) { int Ret = -1; int patternLineIndex = 0; int importLineIndex = 0; int minLineIndex = 0; int nbLineToRemove = 0; int currentLineIndex = 0; int counter = 0; TextFile patternFile = new TextFile(); // Fichier pattern pour l'import des données TextFile fileToImport = new TextFile(); // Fichier à importer StructuredFile importFile = new StructuredFile(); // Fichier utiliser pour lire les données List <String> patternLoop = new List <string>(); // Pour stocker les lignes du pattern à repeter dans la rubrique LOOP String lineRead = ""; // Variable pour lire les données du fichier StructuredFileKey currentKey = null; try { // Verification des paramètres if ((inputFileName != null) && (patternFileName != null)) { // Lecture du fichier modele patternFile.Load(patternFileName); // Lecture du fichier à importer fileToImport.Load(inputFileName); // Si les fichiers sont valides, on les prépare pour les importer if ((patternFile.Count() > 0) && (fileToImport.Count() > 0)) { #region PreparationDesFichiers // Suppression des tabulations patternFile.ReplaceInFile("\t", ""); fileToImport.ReplaceInFile("\t", ""); // Suppression des lignes inutiles patternFile.RemoveEmptyLine(); fileToImport.RemoveEmptyLine(); // Mise en correspondance des fichiers // Recherche de l'index du début de boucle importLineIndex = fileToImport.GetFirstIndexLine(PrivateConst.subStrategyBeginTag, 0); patternLineIndex = patternFile.GetFirstIndexLine(PrivateConst.subStrategyBeginTag, 0); // Verification de la presence de la boucle dans les 2 fichiers if ((importLineIndex >= 0) && (patternLineIndex >= 0)) { // Lecture du minimum de ligne minLineIndex = Math.Min(importLineIndex, patternLineIndex); // Verification si un ecart existe dans le positionnement du tag de debut de boucle if (importLineIndex != patternLineIndex) { // Suppression des lignes en trop dans le fichier d'import nbLineToRemove = importLineIndex - minLineIndex; for (int i = 0; i < nbLineToRemove; i++) { fileToImport.RemoveLine(minLineIndex); } // Suppression des lignes en trop dans le fichier de modèle nbLineToRemove = patternLineIndex - minLineIndex; for (int i = 0; i < nbLineToRemove; i++) { patternFile.RemoveLine(minLineIndex); } } // Creation des boucles // 1 - Lecture des lignes du modèle do { // Lecture de la ligne lineRead = patternFile.GetLine(minLineIndex + 1); // Verification du contenu if ((lineRead != null) && (lineRead.Contains(PrivateConst.subStrategyBeginTag) == false) && (lineRead.Contains(PrivateConst.subStrategyEndTag) == false)) { patternLoop.Add(lineRead); // Ajout de la ligne courante patternFile.RemoveLine(minLineIndex + 1); } }while ((lineRead != null) && (lineRead.Contains(PrivateConst.subStrategyEndTag) == false)); if (patternLoop.Count() > 0) { // 2 - Duplication des données du modele en fonction des données du fichier à importer currentLineIndex = minLineIndex + 1; // On se place au début de la boucle counter = 0; // Initialisation du compteur pour dupliquer le pattern do { // Lecture de la ligne lineRead = fileToImport.GetLine(currentLineIndex); if ((lineRead != null) && (lineRead.Contains(PrivateConst.subStrategyBeginTag) == false) && (lineRead.Contains(PrivateConst.subStrategyEndTag) == false)) { // Verification du compteur if (counter >= patternLoop.Count()) { counter = 0; } // Ajout de la ligne de pattern en conséquence patternFile.AddLine(patternLoop[counter], currentLineIndex); counter = counter + 1; } currentLineIndex = currentLineIndex + 1; }while ((lineRead != null) && (lineRead.Contains(PrivateConst.subStrategyEndTag) == false)); } } // Ajout des lignes dans le fichier d'import si les tailles ne correspondent pas while (patternFile.Count() > fileToImport.Count()) { fileToImport.AddLine("EMPTY LINE"); } // Ajout des lignes dans le fichier pattern si les tailles ne correspondent pas while (fileToImport.Count() > patternFile.Count()) { patternFile.AddLine("EMPTY LINE"); } #endregion #region LectureDesDonnees // Ajout du fichier pattern importFile.SetPatternFile(patternFile); // Lecture du fichier importFile.Import(fileToImport); #endregion #region TraitementDesDonnees if (importFile.Count() > 0) { // Lecture des groupes un par un foreach (StructuredFileGroup currentGroup in importFile.GetAllGroup()) { // Lecture de la clé contenant le nom de la Stategy currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_SubStrategyName); // Si la clé courante fait partie d'une stratégie if (currentKey != null) { // Si le group actuel appartient à une stratégie, lecture du nom de la stratégie String subStrategyName = currentKey.valueString; RobotAction actionToImport = new RobotAction(); // Si il s'agit d'une action à ajouter à la stratégie if (actionToImport.Import(currentGroup) == true) { bool isAdded = false; for (int i = 0; i < _subStrategies.Count(); i++) { // Si la clé lue appartient à la stratégie courante, on l'ajoute if (subStrategyName == _subStrategies[i].Name) { _subStrategies[i].AddAction(actionToImport); isAdded = true; } } // Si la clé n'a pas été ajoutée, on l'ajoute if (isAdded == false) { int subStrategyID = Convert.ToInt32(Math.Floor(actionToImport.ID / 100.0)); SubStrategy subStrategyToAdd = new SubStrategy(subStrategyName, subStrategyID); subStrategyToAdd.AddAction(actionToImport); _subStrategies.Add(subStrategyToAdd); } } } else { // Sinon la clé est ajoutée aux variables globales de l'appli (si la clé est nécessaire) // Lecture du nom de la stratégie currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_StrategyName); if (currentKey != null) { _strategyName = currentKey.valueString; } // Variables pour la position initiale currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_InitialPosX); if (currentKey != null) { _initialPos.param2 = currentKey.valueString; } currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_InitialPosY); if (currentKey != null) { _initialPos.param3 = currentKey.valueString; } currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_InitialPosA); if (currentKey != null) { _initialPos.param4 = currentKey.valueString; } // Valeur par défaut currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_DefaultSpeed); if (currentKey != null) { _defaultSpeed = currentKey.valueInt; } // Valeur par défaut currentKey = currentGroup.GetFirstKey(PrivateConst.TAG_DefaultPivotSpeed); if (currentKey != null) { _defaultPivotSpeed = currentKey.valueInt; } } } } #endregion } } } catch (Exception ex) { _debugTool.WriteLine("Strategy Import() : " + ex.Message); Ret = -1; } return(Ret); }
/// <summary> /// Export current strategy into an external file (given as parameter) /// </summary> /// <param name="outputFileName">filename of output file</param> /// <param name="patternFileName">pattern file to use for the exportation</param> /// <returns></returns> public int Export(String outputFileName, String patternFileName) { int Ret = -1; int iLine = 0; // iterator bool loopSubStrategyPatternFlag = false; // Flag pour indiquer si la ligne en cours est une ligne de sub-stratégie pattern String currentLine = ""; // Ligne courrante (pour copie et/ou analyse) StructuredFile outputFile = new StructuredFile(); // Fichier de sortie TextFile patternFile = new TextFile(); // Fichier pattern TextFile outputPatternFile = new TextFile(); // Fichier pattern à utiliser pour écrire le fichier de sortie List <String> loopSubStrategyPattern = new List <string>(); // Lignes à répéter pour les subStratégies dans le fichier de sortie try { // Verification des paramètres d'entrée et des paramètres internes if ((outputFileName != null) && (patternFileName != null) && (_subStrategies != null)) { // Chargement du fichier model patternFile.Load(patternFileName); // Verification du fichier pattern et création du fichier réel de sortie if (patternFile.Count() > 0) { // On parcourt tout le fichier et on copie toutes les lignes qui n'appartiennent pas à boucle de stratégie for (iLine = 0; iLine < patternFile.Count(); iLine++) { // Lecture de la ligne currentLine = patternFile.GetLine(iLine); // Analyse de la ligne // Est-ce dans une boucle de lecture de pattern if (loopSubStrategyPatternFlag == true) { if (loopSubStrategyPatternFlag == true) { // A-t-on trouver le flag de fin de boucle if (currentLine.ToUpper().Contains(PrivateConst.subStrategyEndTag.ToUpper()) == true) { // La fin de boucle a été trouvée. On abaisse le flag loopSubStrategyPatternFlag = false; // On duplique le modèle en fonction des données en interne // Pour toutes les sub-stratégies for (int iSubStrategy = 0; iSubStrategy < _subStrategies.Count(); iSubStrategy++) { SubStrategy currentSubStrategy = _subStrategies[iSubStrategy]; // Export des données de la sous-stratégie for (int i = 0; i < currentSubStrategy.Count(); i++) { // Ecriture des infos de la stratégie foreach (String patternLineToAdd in loopSubStrategyPattern) { outputPatternFile.AddLine(patternLineToAdd); } } // Ecriture d'un saut de ligne pour la mise en page outputPatternFile.AddLine(""); } // On ajoute la Tag de fin de boucle outputPatternFile.AddLine(currentLine); } else { // Nous ajoutons la ligne courante au pattern loopSubStrategyPattern.Add(currentLine); } } } else { if (currentLine.ToUpper().Contains(PrivateConst.subStrategyBeginTag.ToUpper()) == true) { loopSubStrategyPatternFlag = true; } // Nous sommes en lecture normale, cette ligne sera copiée dans le fichier de pattern final outputPatternFile.AddLine(currentLine); } } } // Si le fichier pattern est prêt, nous écrivons les données dans le fichier de sortie if (outputPatternFile.Count() > 0) { StructuredFileGroup groupToAdd = null; // Creation des données génériques groupToAdd = new StructuredFileGroup(0); // Creation du groupe générique groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_StrategyName, _strategyName)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_DefaultSpeed, _defaultSpeed)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_DefaultPivotSpeed, _defaultPivotSpeed)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_InitialPosX, _initialPos.param2)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_InitialPosY, _initialPos.param3)); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_InitialPosA, _initialPos.param4)); // Ajout du groupe outputFile.AddGroup(groupToAdd); // Creation des données spécifiques if (_subStrategies.Count() > 0) { // Pour chaque sous stratégies foreach (SubStrategy currentSubStrategy in _subStrategies) { String currentSubStrategyName = currentSubStrategy.Name; if (currentSubStrategy.Count() > 0) { // Pour chacune des actions de la stratégie foreach (RobotAction currentAction in currentSubStrategy.GetAllActions()) { groupToAdd = currentAction.Export(); groupToAdd.AddKey(new StructuredFileKey(PrivateConst.TAG_SubStrategyName, currentSubStrategyName)); outputFile.AddGroup(groupToAdd); } } } } // Ecriture du fichier final outputFile.SetPatternFile(outputPatternFile); outputFile.Export(outputFileName); // Sauvegarde des données Save(); } } } catch (Exception ex) { _debugTool.WriteLine("Strategy Export() : " + ex.Message); Ret = -1; } return(Ret); }
static void GenMMgr(string className) { TextFile tf = new TextFile(null, "// auto gen"); tf.Add("using UnityEngine;"); tf.Add("using UnityEngine.UI;"); tf.Add("using System;"); tf.Add("using System.Collections;"); tf.Add("using System.Collections.Generic;"); tf.Add("using jsb;"); tf.AddLine(); TextFile tfNs = tf.Add("namespace jsb").BraceIn(); { TextFile tfC = tfNs.Add("public class {0}", className).BraceIn(); { tfC.Add("static Dictionary<string, int[]> jID = new Dictionary<string, int[]>();"); { tfC.AddMultiline(@" static int[] GetJsClassMessages(string jsFullName) { if (jID.ContainsKey(jsFullName)) return jID[jsFullName]; if (!JSMgr.vCall.CallJSFunctionName(JSCache.GetBridgeJsID(), ""getLMsgs"", jsFullName)) throw new Exception(""call Bridge.getLMsgs failed!""); string str = JSApi.getStringS((int)JSApi.GetType.JSFunRet); if (string.IsNullOrEmpty(str)) { jID[jsFullName] = null; return null; } string[] arr = str.Split(','); int[] r = new int[arr.Length]; for (int i = 0; i < arr.Length; i++) r[i] = int.Parse(arr[i]); jID[jsFullName] = r; return r; }"); } tfC.AddLine(); { tfC.AddMultiline(@" public static void CreateMessages(string jsFullName, GameObject go) { int[] ids = GetJsClassMessages(jsFullName); if (ids == null) return; // ID号 JS和CS保持一致才不会错 for (int i = 0; i < ids.Length; i++) { Type type = MessageTypes[ids[i]]; if (go.GetComponent(type) == null) go.AddComponent(type); } }"); } tfC.AddLine(); { TextFile tfM = tfC.Add("static Type[] MessageTypes = new Type[]").BraceIn(); { for (int i = 0; i < infos.Length; i++) { Info info = infos[i]; tfM.Add("typeof(jsb.{0}),", info.className); } } tfM.BraceOutSC(); } } tfC.BraceOut(); } tfNs.BraceOut(); string s = tf.Format(-1); File.WriteAllText(CsDir + "/" + className + ".cs", s); }
public static void GenWraps(Type[] arrEnums, Type[] arrClasses, HashSet <string> bridgeTypes) { GeneratorHelp.ClearTypeInfo(); Dictionary <Type, TypeStatus> dict = new Dictionary <Type, TypeStatus>(); Action <Type> onNewType = null; onNewType = (nt) => { while (true) { if (nt.IsByRef || nt.IsArray) { nt = nt.GetElementType(); continue; } if (nt.IsGenericType && !nt.IsGenericTypeDefinition) { foreach (var ga in nt.GetGenericArguments()) { onNewType(ga); } nt = nt.GetGenericTypeDefinition(); continue; } if (nt.IsGenericParameter) { return; } break; } if (!bridgeTypes.Contains(nt.FullName) && !dict.ContainsKey(nt)) { dict.Add(nt, new TypeStatus()); } }; Func <Type, TypeStatus> getParent = (type) => { if (dict.ContainsKey(type)) { return(dict[type]); } return(null); }; foreach (var type in arrEnums) { onNewType(type); } foreach (var type in arrClasses) { onNewType(type); } while (true) { Type[] keys = new Type[dict.Count]; dict.Keys.CopyTo(keys, 0); foreach (Type type in keys) { TypeStatus ts = dict[type]; if (ts.status != TypeStatus.Status.Wait) { continue; } if (ShouldIgnoreType(type)) { ts.status = TypeStatus.Status.Ignored; continue; } if (type.IsEnum) { GenEnum(type, ts, getParent, onNewType); } else if (typeof(Delegate).IsAssignableFrom(type)) { GenDelegate(type, ts, getParent, onNewType); } else { GenInterfaceOrStructOrClass(type, ts, getParent, onNewType); } } bool bContinue = false; foreach (var kv in dict) { if (kv.Value.status == TypeStatus.Status.Wait) { bContinue = true; break; } } if (!bContinue) { break; } } TextFile tfAll = new TextFile(); tfAll.Add("#pragma warning disable 626, 824"); foreach (var kv in dict) { if (kv.Value.status == TypeStatus.Status.Exported && !kv.Value.IsInnerType) { tfAll.Add(kv.Value.tf.Ch); tfAll.AddLine(); } } tfAll.Add("#pragma warning restore 626, 824"); File.WriteAllText(JSBindingSettings.CswFilePath, tfAll.Format(-1)); }
static void GenInterfaceOrStructOrClass(Type type, TypeStatus ts, Func <Type, TypeStatus> getParent, Action <Type> onNewType) { TextFile tfFile = null; if (type.DeclaringType != null) { ts.IsInnerType = true; TypeStatus tsParent = getParent(type.DeclaringType); if (tsParent == null || tsParent.status == TypeStatus.Status.Wait) { return; } if (tsParent.status == TypeStatus.Status.Ignored) { ts.status = TypeStatus.Status.Ignored; return; } tfFile = tsParent.tf.FindByTag("epos"); } if (tfFile == null) { tfFile = new TextFile(); } ts.tf = tfFile; ts.status = TypeStatus.Status.Exported; GeneratorHelp.ATypeInfo ti = GeneratorHelp.CreateTypeInfo(type); StringBuilder sb = new StringBuilder(); TextFile tfNs = tfFile; //string dir = Dir; if (type.DeclaringType == null && !string.IsNullOrEmpty(type.Namespace)) { tfNs = tfFile.Add("namespace {0}", type.Namespace).BraceIn(); tfNs.BraceOut(); } tfNs.Add("[Bridge.FileName(\"csw\")]"); TextFile tfClass = null; sb.Remove(0, sb.Length); { if (type.IsPublic || type.IsNestedPublic) { sb.Append("public "); } if (type.IsClass) { if (type.IsAbstract && type.IsSealed) { sb.Append("static "); } //else if (type.IsAbstract) // sb.Append("abstract "); //else if (type.IsSealed) // sb.Append("sealed "); //if (type.is) } if (type.IsInterface) { sb.Append("interface "); } else if (type.IsValueType) { sb.Append("struct "); } else { sb.Append("class "); } string className = type.CsFullName(CsNameOption.CompilableWithT); int dot = className.LastIndexOf("."); if (dot >= 0) { className = className.Substring(dot + 1); } sb.Append(className); Type vBaseType = type.ValidBaseType(); Type[] interfaces = type.GetDeclaringInterfaces(); if (vBaseType != null || interfaces.Length > 0) { sb.Append(" : "); args a = new args(); if (vBaseType != null) { a.Add(typefn(vBaseType, type.Namespace)); onNewType(vBaseType); } foreach (var i in interfaces) { a.Add(typefn(i, type.Namespace)); onNewType(i); } sb.Append(a.ToString()); } tfClass = tfNs.Add(sb.ToString()).BraceIn(); tfClass.BraceOut(); } tfClass.AddTag("epos"); for (int i = 0; i < ti.Fields.Count; i++) { MemberInfoEx infoEx = ti.Fields[i]; FieldInfo field = infoEx.member as FieldInfo; tfClass.Add("public {0}{1} {2};", (field.IsStatic ? "static " : ""), typefn(field.FieldType, type.Namespace), field.Name); onNewType(field.FieldType); } if (ti.Fields.Count > 0) { tfClass.AddLine(); } for (int i = 0; i < ti.Cons.Count; i++) { MemberInfoEx infoEx = ti.Cons[i]; ConstructorInfo con = infoEx.member as ConstructorInfo; if (type.IsValueType) { // 结构体不需要无参数构造函数 if (con == null || con.GetParameters().Length == 0) { continue; } } string ctorName = type.Name; if (type.IsGenericTypeDefinition) { int flag = ctorName.LastIndexOf('`'); if (flag >= 0) { ctorName = ctorName.Substring(0, flag); } } tfClass.Add("public extern {0}({1});", ctorName, con == null ? "" : Ps2String(type, con.GetParameters())); if (con != null) { foreach (var p in con.GetParameters()) { onNewType(p.ParameterType); } } } if (ti.Cons.Count > 0) { tfClass.AddLine(); } handlePros(tfClass, type, ti, onNewType); if (ti.Pros.Count > 0) { tfClass.AddLine(); } handleMethods(tfClass, type, ti, onNewType); if (!type.IsInterface) { handleInterfaceProblems(tfClass, type, onNewType); } }
static void handleMethods(TextFile tfClass, Type type, GeneratorHelp.ATypeInfo ti, Action <Type> OnNewType) { Action <MethodInfo> action = (method) => { StringBuilder sbDef = new StringBuilder(); bool isI = type.IsInterface; if (!isI) { if (method.IsPublic) { sbDef.Append("public "); } else if (method.IsFamily) { sbDef.Append("protected "); } else if (method.IsAssembly) { sbDef.Append("internal "); } if (method.IsStatic) { sbDef.Append("static "); } sbDef.Append("extern "); if (method.GetBaseDefinition() != method) { sbDef.Append("override "); } else if (!type.IsValueType && method.IsVirtual && !type.IsValueType) { sbDef.Append("virtual "); } } if (!(method.IsSpecialName && method.Name == "op_Implicit")) { sbDef.Append(typefn(method.ReturnType, type.Namespace, CsNameOption.CompilableWithT) + " "); } OnNewType(method.ReturnType); sbDef.Append(MethodNameString(type, method)); if (method.IsGenericMethodDefinition) { Type[] argus = method.GetGenericArguments(); args t_args = new args(); foreach (var a in argus) { t_args.Add(a.Name); } sbDef.Append(t_args.Format(args.ArgsFormat.GenericT)); } sbDef.Append("("); bool hasExtensionAttribute = (method.GetCustomAttributes(typeof(System.Runtime.CompilerServices.ExtensionAttribute), false).Length > 0); ParameterInfo[] ps = method.GetParameters(); { sbDef.Append(Ps2String(type, ps, hasExtensionAttribute)); sbDef.Append(");"); foreach (var p in ps) { OnNewType(p.ParameterType); } } tfClass.Add(sbDef.ToString()); }; bool hasSpecial = false; for (int i = 0; i < ti.Methods.Count; i++) { MemberInfoEx infoEx = ti.Methods[i]; MethodInfo method = infoEx.member as MethodInfo; if (method.IsSpecialName) { hasSpecial = true; action(method); } } if (hasSpecial) { tfClass.AddLine(); } for (int i = 0; i < ti.Methods.Count; i++) { MemberInfoEx infoEx = ti.Methods[i]; MethodInfo method = infoEx.member as MethodInfo; if (!method.IsSpecialName) { action(method); } } }
static void handlePros(TextFile tfClass, Type type, GeneratorHelp.ATypeInfo ti, Action <Type> OnNewType) { Action <PropertyInfo> action = (pro) => { bool isI = type.IsInterface; OnNewType(pro.PropertyType); ParameterInfo[] ps = pro.GetIndexParameters(); args iargs = new args(); bool isIndexer = (ps.Length > 0); if (isIndexer) { for (int j = 0; j < ps.Length; j++) { iargs.AddFormat("{0} {1}", typefn(ps[j].ParameterType, type.Namespace), ps[j].Name); OnNewType(ps[j].ParameterType); } } MethodInfo getm = pro.GetGetMethod(); MethodInfo setm = pro.GetSetMethod(); bool canGet = getm != null && getm.IsPublic; bool canSet = setm != null && setm.IsPublic; string getset = ""; if (!isI) { if (canGet) { getset += string.Format("get {{ return default({0}); }}", typefn(pro.PropertyType, type.Namespace)); } if (canSet) { getset += " set {}"; } } else { if (canGet) { getset += "get;"; } if (canSet) { getset += " set;"; } } string vo = string.Empty; if (!isI) { vo = "public "; if ((getm != null && getm.IsStatic) || (setm != null && setm.IsStatic)) { vo += "static "; } if (!type.IsValueType) { if ((getm != null && getm.IsVirtual) || (setm != null && setm.IsVirtual)) { vo += ((getm != null && getm.GetBaseDefinition() != getm) || (setm != null && setm.GetBaseDefinition() != setm)) ? "override " : "virtual "; } } } if (isIndexer) { tfClass.Add("{3}{0} this{1} {{ {2} }}", typefn(pro.PropertyType, type.Namespace), iargs.Format(args.ArgsFormat.Indexer), getset, vo); } else { tfClass.Add("{3}{0} {1} {{ {2} }}", typefn(pro.PropertyType, type.Namespace), pro.Name, getset, vo); } }; bool hasNoneIndexer = false; for (int i = 0; i < ti.Pros.Count; i++) { MemberInfoEx infoEx = ti.Pros[i]; PropertyInfo pro = infoEx.member as PropertyInfo; if (pro.GetIndexParameters().Length == 0) { hasNoneIndexer = true; action(pro); } } if (hasNoneIndexer) { tfClass.AddLine(); } for (int i = 0; i < ti.Pros.Count; i++) { MemberInfoEx infoEx = ti.Pros[i]; PropertyInfo pro = infoEx.member as PropertyInfo; if (pro.GetIndexParameters().Length > 0) { action(pro); } } }
static void Main(string[] args) { // ############################################################################################################################ // ##### TextFile // ############################################################################################################################ #region TexteFile //Declaration des variables TextFile textFileFromFile = null; // Fichier permettant de lire un fichier depuis le disque TextFile newTextFile = null; // Fichier pour tester l'ajout et la suppression de ligne bool Validated = true; // Test 0101 : Creation d'un fichier texte __________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0101 - Creation et chargement d'un fichier texte : \n"); Console.WriteLine(" -> Creation du fichier"); textFileFromFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement du fichier de test :"); if (textFileFromFile.Load("TestFiles/Test_Load.txt") >= 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement du fichier vide : "); if (textFileFromFile.Load("TestFiles/Test_EmptyFile.txt") >= 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Tentative d'ouverture d'un fichier inexistant : "); if (textFileFromFile.Load("InvalidFile") == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> FilePath vide : "); if (textFileFromFile.Load("") == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement d'un fichier de 100 Lignes : "); if (textFileFromFile.Load("TestFiles/Test_100Lines.txt") == 100) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement d'un fichier de 1000 Lignes : "); if (textFileFromFile.Load("TestFiles/Test_1000Lines.txt") == 1000) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Chargement d'un fichier de 10000 Lignes : "); if (textFileFromFile.Load("TestFiles/Test_10000Lines.txt") == 10000) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0101 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0102 : Verification des propriétés __________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0102 - Test des priorités : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Count sur un fichier vide :"); if (newTextFile.Count() == 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Count sur un fichier normal (100 Lignes) :"); newTextFile.Load("TestFiles/Test_100Lines.txt"); if (newTextFile.Count() == 100) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Count sur un fichier normal (1000 Lignes) :"); newTextFile.Load("TestFiles/Test_1000Lines.txt"); if (newTextFile.Count() == 1000) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0102 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0103 : Ajout de ligne _______________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0103 - Ajout de nouvelle ligne : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne dans un fichier vide:"); newTextFile.AddLine("Ligne 01"); if (newTextFile.Count() == 1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne vide :"); newTextFile.AddLine(null); if (newTextFile.Count() == 1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne sans contenu :"); newTextFile.AddLine(""); if (newTextFile.Count() == 2) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne avec un index erroné :"); newTextFile.AddLine("Ligne -1", -1); if (newTextFile.Count() == 2) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne à un index spécifié :"); newTextFile.AddLine("Ligne 00", 0); if (newTextFile.Count() == 3) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne null à un index spécifié :"); newTextFile.AddLine(null, 0); if (newTextFile.Count() == 3) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ajout d'une ligne à un index erroné :"); newTextFile.AddLine(null, -1); if (newTextFile.Count() == 3) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0103 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0104 : Récupération d'une ligne _____________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0104 - Lecture d'une ligne : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'une ligne dans un fichier vide:"); if (newTextFile.GetLine(0) == null) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'une ligne avec un index négatif :"); newTextFile.AddLine("Ligne 01"); newTextFile.AddLine("Ligne 02"); newTextFile.AddLine("Ligne 03"); if (newTextFile.GetLine(-1) == null) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'une ligne avec un index erroné :"); if (newTextFile.GetLine(100) == null) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'une ligne valide :"); if (newTextFile.GetLine(0) == "Ligne 01") { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture de la dernière ligne du fichier :"); if (newTextFile.GetLine(2) == "Ligne 03") { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0104 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0105 : Sauvegarde du fichier ________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0105 - Sauvegarde des fichiers : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde d'un fichier non initialisé :"); if (newTextFile.Save() == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde d'un fichier null :"); if (newTextFile.SaveTo(null) == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde d'un fichier non valide :"); if (newTextFile.SaveTo("Invalid") == -1) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde dans un fichier valide :"); newTextFile.Load("TestFiles/Test_100Lines.txt"); if (newTextFile.SaveTo("TestFiles/Test_100Lines_ouptut_SaveTo.txt") == 100) { Console.Write(" Ok + Verification manuelle à réaliser\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Sauvegarde d'un fichier valide :"); newTextFile.SaveTo("TestFiles/Test_100Lines_ouptut_Save.txt"); if (newTextFile.Save() == 100) { Console.Write(" Ok + Verification manuelle à réaliser\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0105 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0106 : Caractère spéciaux ___________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0106 - Utilisation de caractères spéciaux : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); String textToCheck = "\t&@éèàûîêäëïç'§µ%"; newTextFile.AddLine(textToCheck); // ------------------------------------------------------------------------------------------ Console.Write(" -> Ecriture du fichier :"); if (newTextFile.SaveTo("TestFiles/SpecificChar.txt") > 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Relecture du fichier :"); newTextFile.Load("TestFiles/SpecificChar.txt"); if (newTextFile.GetLine(0) == textToCheck) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0106 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } // Test 0107 : Suppression d'une ligne ______________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0107 - Suppression d'une ligne : \n"); Console.WriteLine(" -> Creation du fichier"); newTextFile = new TextFile(); // ------------------------------------------------------------------------------------------ Console.Write(" -> Suppression d'une ligne dans un fichier vide :"); newTextFile.RemoveLine(0); if (newTextFile.Count() == 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Suppression d'une ligne non valide :"); newTextFile.RemoveLine(-1); if (newTextFile.Count() == 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Suppression d'une ligne dans un fichier :"); newTextFile.AddLine("Ligne01"); newTextFile.AddLine("Ligne02"); newTextFile.AddLine("Ligne03"); newTextFile.RemoveLine(0); if ((newTextFile.Count() == 2) && (newTextFile.GetLine(0) == "Ligne02")) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Suppression de toutes les lignes d'un fichier :"); newTextFile.AddLine("Ligne01"); newTextFile.AddLine("Ligne02"); newTextFile.AddLine("Ligne03"); newTextFile.RemoveAllLine(); if (newTextFile.Count() == 0) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0107 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } #endregion // ############################################################################################################################ // ##### StructuredFileKey // ############################################################################################################################ #region StructuredFileKey StructuredFileKey testKey = null; // Test 0201 : Constructeurs ________________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0201 - StructuredFileKey : \n"); // ------------------------------------------------------------------------------------------ Console.Write(" -> Constructeur vide :"); testKey = new StructuredFileKey(); if ((null != testKey) && (testKey.keyName == null) && (testKey.valueString == null)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres ('keyString', 'valueString') :"); testKey = new StructuredFileKey("keyString", "valueString"); if ((null != testKey) && (testKey.keyName == "keyString") && (testKey.valueString == "valueString")) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres ('keyInt', 100) :"); testKey = new StructuredFileKey("keyInt", 100); if ((null != testKey) && (testKey.keyName == "keyInt") && (testKey.valueInt == 100)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres ('keyDouble', 1.2) :"); testKey = new StructuredFileKey("keyDouble", 1.2); if ((null != testKey) && (testKey.keyName == "keyDouble") && (testKey.valueDouble == 1.2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0201 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } #endregion // ############################################################################################################################ // ##### StructuredFileGroup // ############################################################################################################################ #region StructuredFileGroup StructuredFileGroup testKeyGroup = null; StructuredFileGroup testKeyGroup1 = null; StructuredFileGroup testKeyGroup2 = null; // Test 0301 : Constructeurs ________________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0301 - StructuredFileGroup : \n"); // ------------------------------------------------------------------------------------------ Console.Write(" -> Constructeur vide :"); testKeyGroup = new StructuredFileGroup(0); if ((testKeyGroup.ID == 0) && (testKeyGroup.GetAllKeys() == null)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres (groupID = 0 et key = null) :"); testKeyGroup = new StructuredFileGroup(0, null); if ((testKeyGroup.ID == 0) && (testKeyGroup.GetAllKeys() == null)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Constructeur avec paramètres (groupID=0 et key=(TestKey, TestValue) :"); testKeyGroup = new StructuredFileGroup(5, new StructuredFileKey("TestKey", "TestValue")); if ((testKeyGroup.ID == 5) && (testKeyGroup.GetAllKeys().Count == 1)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction Add() :"); testKeyGroup = new StructuredFileGroup(1); testKeyGroup.AddKey(new StructuredFileKey("1", "1")); testKeyGroup.AddKey(new StructuredFileKey("2", "2")); if ((testKeyGroup.ID == 1) && (testKeyGroup.GetAllKeys().Count == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction Add(List<>) :"); testKeyGroup = new StructuredFileGroup(1); List <StructuredFileKey> listToAdd = new List <StructuredFileKey>(); listToAdd.Add(new StructuredFileKey("1", "1")); listToAdd.Add(new StructuredFileKey("2", "2")); testKeyGroup.AddKey(listToAdd); if ((testKeyGroup.ID == 1) && (testKeyGroup.Count() == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction Count() :"); testKeyGroup = new StructuredFileGroup(1, null); testKeyGroup1 = new StructuredFileGroup(1, new StructuredFileKey("Key1", "Value1")); testKeyGroup2 = new StructuredFileGroup(2, new StructuredFileKey("Key1", "Value1")); testKeyGroup2.AddKey(new StructuredFileKey("Key2", "Value2")); if ((testKeyGroup.Count() == 0) && (testKeyGroup1.Count() == 1) && (testKeyGroup2.Count() == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction GetAllKeys() :"); testKeyGroup = new StructuredFileGroup(1); testKeyGroup.AddKey(new StructuredFileKey("Key1", "Value1")); testKeyGroup.AddKey(new StructuredFileKey("Key2", "Value2")); if ((testKeyGroup.ID == 1) && (testKeyGroup.GetAllKeys().Count() == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Test de la fonction GetKeys(keyID) :"); testKeyGroup = new StructuredFileGroup(1); testKeyGroup.AddKey(new StructuredFileKey("Key1", "Value1")); testKeyGroup.AddKey(new StructuredFileKey("Key2", "Value2")); testKeyGroup.AddKey(new StructuredFileKey("Key2", "Value22")); if ((testKeyGroup.ID == 1) && (testKeyGroup.GetKeys("Key3") == null) && (testKeyGroup.GetKeys("Key2").Count() == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0301 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } #endregion // ############################################################################################################################ // ##### StructuredFile // ############################################################################################################################ #region StructuredFile StructuredFile testStructuredFile = null; StructuredFile testStructuredFile2 = null; // Test 0401 : Constructeurs ________________________________________________________________________________________ try { DisplaySeparator(); Console.WriteLine("Test 0401 - Constructeurs : \n"); // ------------------------------------------------------------------------------------------ Console.Write(" -> Constructeur vide :"); testStructuredFile = new StructuredFile(); if (null != testStructuredFile) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Constructeur avec paramètre :"); testStructuredFile = new StructuredFile("CheminInvalid"); if (null != testStructuredFile) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction GetAllGroupID vide :"); testStructuredFile = new StructuredFile(); if (testStructuredFile.GetAllGroup() == null) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction d'ajout :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); testStructuredFile.AddGroup(null); testStructuredFile2.AddGroup(new StructuredFileGroup(1, new StructuredFileKey("Key1", 1))); testStructuredFile2.AddGroup(new StructuredFileGroup(1, new StructuredFileKey("Key2", 2))); testStructuredFile2.AddGroup(new StructuredFileGroup(2, new StructuredFileKey("Key3", 3))); if ((testStructuredFile.GetAllGroup().Count() == 1) && (testStructuredFile.GetAllGroup().Count() == 1)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction de suppression totale :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); testStructuredFile.AddGroup(new StructuredFileGroup(2)); testStructuredFile.AddGroup(new StructuredFileGroup(3)); testStructuredFile.RemoveAllGroup(); testStructuredFile2.RemoveAllGroup(); if ((testStructuredFile.GetAllGroup() == null) && (testStructuredFile2.GetAllGroup() == null)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction de suppression à partir de l'ID :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); testStructuredFile.AddGroup(new StructuredFileGroup(2)); testStructuredFile.AddGroup(new StructuredFileGroup(3)); testStructuredFile.RemoveGroupByID(2); testStructuredFile.RemoveGroupByID(5); testStructuredFile2.RemoveGroupByID(5); if (testStructuredFile.GetAllGroup().Count() == 2) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Fonction de recherche à partir de l'ID :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); testStructuredFile.AddGroup(new StructuredFileGroup(2)); testStructuredFile.AddGroup(new StructuredFileGroup(3)); if ((testStructuredFile2.GetGroupByID(5) == null) && (testStructuredFile.GetGroupByID(5) == null) && (testStructuredFile.GetGroupByID(2).ID == 2)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Ecriture du fichier via SaveTo (format par défaut) :"); testStructuredFile = new StructuredFile(); testStructuredFile2 = new StructuredFile(); testStructuredFile.AddGroup(new StructuredFileGroup(1)); StructuredFileGroup newGroup = new StructuredFileGroup(2, new StructuredFileKey("Key1", 1)); newGroup.AddKey(new StructuredFileKey("Key2", 2)); newGroup.AddKey(new StructuredFileKey("Key3", 3)); testStructuredFile.AddGroup(newGroup); testStructuredFile.AddGroup(new StructuredFileGroup(3, new StructuredFileKey("Key1", 10))); if ((testStructuredFile.SaveTo("TestFiles/StructuredFile.sfile") > 0) && (testStructuredFile2.SaveTo("TestFiles/StructuredFileErr.sfile") == -1)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } Console.Write(" -> Ecriture du fichier via Save (format par défaut) :"); if ((testStructuredFile.Save() > 0) && (testStructuredFile2.Save() == -1)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Lecture d'un fichier :"); newTextFile = new TextFile(); newTextFile.AddLine("key1 = A"); newTextFile.AddLine("key2 = B"); newTextFile.AddLine("[Groupe 5]"); newTextFile.AddLine("key3 = C"); newTextFile.AddLine("key4 = D"); newTextFile.AddLine("key5 E"); newTextFile.AddLine("key6 = F"); newTextFile.AddLine("key7 = G"); newTextFile.AddLine("key8 = H"); newTextFile.AddLine("key9 = I"); newTextFile.AddLine(" "); newTextFile.AddLine("key10 = J"); newTextFile.AddLine("[Groupe A]"); newTextFile.AddLine("key11 = K"); newTextFile.AddLine("key12 = L"); newTextFile.AddLine("[ Groupe 5]"); newTextFile.AddLine("[Groupe 7]"); newTextFile.AddLine("[Groupe 5]"); newTextFile.AddLine("key13 = M"); testStructuredFile = new StructuredFile(); if ((testStructuredFile.Load(newTextFile) > 0) && (testStructuredFile.SaveTo("TestFiles/StructuredFile2.sfile") > 0)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Export d'un fichier :"); newTextFile = new TextFile(); newTextFile.AddLine("[Groupe 0]"); newTextFile.AddLine("Key1 = (0,1)"); newTextFile.AddLine("Key2 = (0,2)"); newTextFile.AddLine("[Groupe 2]"); newTextFile.AddLine("Key1 = (2,1)"); newTextFile.AddLine("Key2 = (2,2)"); newTextFile.AddLine("[Groupe 3]"); newTextFile.AddLine("Key1 = (3,1)"); newTextFile.AddLine("Key2 = (3,2)"); newTextFile.AddLine("[Groupe 1]"); newTextFile.AddLine("Var1 = Var1-1"); newTextFile.AddLine("Var2 = Var2-1"); newTextFile.AddLine("Var3 = Var3-1"); newTextFile.AddLine("Var4 = Var4-1"); newTextFile.AddLine("Var5 = Var5-1"); newTextFile.AddLine("[Groupe 2]"); newTextFile.AddLine("Var1 = Var1-2"); newTextFile.AddLine("Var2 = Var2-2"); newTextFile.AddLine("Var3 = Var3-2"); newTextFile.AddLine("Var4 = Var4-2"); newTextFile.AddLine("Var5 = Var5-2"); newTextFile.AddLine("[Groupe 3]"); newTextFile.AddLine("Var1 = Var1-3"); newTextFile.AddLine("Var2 = Var2-3"); newTextFile.AddLine("Var3 = Var3-3"); newTextFile.AddLine("Var4 = Var4-3"); newTextFile.AddLine("Var5 = Var5-3"); newTextFile.AddLine("[Groupe 4]"); newTextFile.AddLine("Var1 = Var1-4"); newTextFile.AddLine("Var2 = Var2-4"); newTextFile.AddLine("Var3 = Var3-4"); newTextFile.AddLine("Var4 = Var4-4"); newTextFile.AddLine("Var5 = Var5-4"); newTextFile.AddLine("[Groupe 5]"); newTextFile.AddLine("Var1 = Var1-5"); newTextFile.AddLine("Var2 = Var2-5"); newTextFile.AddLine("Var3 = Var3-5"); newTextFile.AddLine("Var4 = Var4-5"); newTextFile.AddLine("Var5 = Var5-5"); testStructuredFile = new StructuredFile(); testStructuredFile.Load(newTextFile); testStructuredFile.SetPatternFile("TestFiles/ExportPatternFile.pattern"); if (testStructuredFile.Export("TestFiles/ExportPatternFile.output") == 6) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } // ------------------------------------------------------------------------------------------ Console.Write(" -> Import d'un fichier :"); testStructuredFile = new StructuredFile(); testStructuredFile.SetPatternFile("TestFiles/ImportPatternFile.pattern"); if ((testStructuredFile.Import("TestFiles/ImportFile.txt") > 0) && (testStructuredFile.SaveTo("TestFiles/ImportFile.sfile") > 0)) { Console.Write(" Ok\n"); } else { Console.Write(" Error !\n"); Validated = false; } } catch (Exception ex) { Console.WriteLine("Test 0401 Failed !!"); Console.WriteLine(ex.Message); Validated = false; } #endregion // Fin du programme ----------------------------------------------------------------------------- DisplaySeparator(); Console.Write("\nTest terminé. Etat du module : "); if (Validated == true) { Console.Write("Validé ! \n(Sous réserve que les fichiers de sortie soit valides)\n"); } else { Console.Write("Invalide !\n"); } Console.Read(); }
static void GenInterfaceOrStructOrClass(Type type, TypeStatus ts, Func <Type, TypeStatus> getParent, Action <Type> onNewType) { TextFile tfFile = null; if (type.DeclaringType != null) { ts.IsInnerType = true; TypeStatus tsParent = getParent(type.DeclaringType); if (tsParent == null || tsParent.status == TypeStatus.Status.Wait) { if (tsParent == null) { onNewType(type.DeclaringType); } return; } if (tsParent.status == TypeStatus.Status.Ignored) { ts.status = TypeStatus.Status.Ignored; return; } tfFile = tsParent.tf.FindByTag("epos"); } if (tfFile == null) { tfFile = new TextFile(); } ts.tf = tfFile; ts.status = TypeStatus.Status.Exported; GeneratorHelp.ATypeInfo ti = GeneratorHelp.CreateTypeInfo(type); StringBuilder sb = new StringBuilder(); TextFile tfNs = tfFile; //string dir = Dir; // // ignore Experimental @eugenejiang // if (type.Namespace != null && type.Namespace.IndexOf("UnityEngine.Experimental.") >= 0) { // return; // } if (type.DeclaringType == null && !string.IsNullOrEmpty(type.Namespace)) { tfNs = tfFile.Add("namespace {0}", type.Namespace).BraceIn(); tfNs.BraceOut(); } GenAttributeForClassIfNeeded(type, tfNs); // multiple attributes // tfNs.Add("[Bridge.External]"); TextFile tfClass = null; sb.Remove(0, sb.Length); { // force public if (type.IsPublic || type.IsNestedPublic || type.IsNested || type.IsNestedFamily) { sb.Append("public "); } // if (type.IsNestedFamily) { // sb.Append("protected "); // } // if (type.FullName.IndexOf("DropdownItem") >= 0) { // Debug.Assert(false); // } if (type.IsClass) { if (type.IsAbstract && type.IsSealed) { sb.Append("static "); } //else if (type.IsAbstract) // sb.Append("abstract "); //else if (type.IsSealed) // sb.Append("sealed "); //if (type.is) } if (type.IsInterface) { sb.Append("interface "); } else if (type.IsValueType) { sb.Append("struct "); } else { sb.Append("class "); } string className = type.CsFullName(CsNameOption.CompilableWithT); int dot = className.LastIndexOf("."); if (dot >= 0) { className = className.Substring(dot + 1); } sb.Append(className); Type vBaseType = type.ValidBaseType(); Type[] interfaces = type.GetDeclaringInterfaces(); if (vBaseType != null || interfaces.Length > 0) { sb.Append(" : "); args a = new args(); if (vBaseType != null) { a.Add(typefn(vBaseType, type.Namespace, CsNameOption.CompilableWithT)); onNewType(vBaseType); } foreach (var i in interfaces) { a.Add(typefn(i, type.Namespace, CsNameOption.CompilableWithT)); onNewType(i); } sb.Append(a.ToString()); } tfClass = tfNs.Add(sb.ToString()).BraceIn(); tfClass.BraceOut(); } tfClass.AddTag("epos"); if (handleEvents(tfClass, type, onNewType)) { tfClass.AddLine(); } for (int i = 0; i < ti.Fields.Count; i++) { MemberInfoEx infoEx = ti.Fields[i]; FieldInfo field = infoEx.member as FieldInfo; var publicOrProtected = "public"; if (field.IsFamily) { // publicOrProtected = "protected"; } if (field.IsLiteral && !field.IsInitOnly) { { var attributes = field.GetCustomAttributes(); foreach (var attr in attributes) { tfClass.Add("[{0}]", attr.GetType().Name); onNewType(attr.GetType()); } } if ("string" == typefn(field.FieldType, type.Namespace)) { tfClass.Add(publicOrProtected + " const {0} {1} = \"{2}\";", typefn(field.FieldType, type.Namespace), field.Name, field.GetValue(null)); } else if ("float" == typefn(field.FieldType, type.Namespace)) { var fv = (float)field.GetValue(null); string defaultvalue; if (float.IsNaN(fv)) { defaultvalue = "float.NaN"; } else if (float.IsPositiveInfinity(fv)) { defaultvalue = "float.PositiveInfinity"; } else if (float.IsNegativeInfinity(fv)) { defaultvalue = "float.NegativeInfinity"; } else { defaultvalue = fv + "f"; } tfClass.Add(publicOrProtected + " const {0} {1} = {2};", typefn(field.FieldType, type.Namespace), field.Name, defaultvalue); } else { tfClass.Add(publicOrProtected + " const {0} {1} = {2};", typefn(field.FieldType, type.Namespace), field.Name, field.GetValue(null)); } } else { tfClass.Add(publicOrProtected + " {0}{1} {2};", (field.IsStatic ? "static " : ""), typefn(field.FieldType, type.Namespace), field.Name); } onNewType(field.FieldType); } if (ti.Fields.Count > 0) { tfClass.AddLine(); } // Constructors for (int i = 0; i < ti.Cons.Count; i++) { MemberInfoEx infoEx = ti.Cons[i]; ConstructorInfo con = infoEx.member as ConstructorInfo; if (type.IsValueType) { // 结构体不需要无参数构造函数 if (con == null || con.GetParameters().Length == 0) { continue; } } string ctorName = type.Name; if (type.IsGenericTypeDefinition) { int flag = ctorName.LastIndexOf('`'); if (flag >= 0) { ctorName = ctorName.Substring(0, flag); } } var constructorBuilder = new StringBuilder(); var paras = con == null ? "" : Ps2String(type, con.GetParameters()); constructorBuilder.Append($"public {ctorName}({paras})"); var baseType = type.ValidBaseType(); if (baseType != null && !HasDefaultConstructor(baseType)) { constructorBuilder.Append($" : base({BaseConstructorParameters(baseType)})"); } constructorBuilder.Append(" { throw new Exception(\"not impl\"); }"); tfClass.Add(constructorBuilder.ToString()); if (con != null) { foreach (var p in con.GetParameters()) { onNewType(p.ParameterType); } } } if (ti.Cons.Count > 0) { tfClass.AddLine(); } handlePros(tfClass, type, ti, onNewType); if (ti.Pros.Count > 0) { tfClass.AddLine(); } handleMethods(tfClass, type, ti, onNewType); if (!type.IsInterface) { handleInterfaceProblems(tfClass, type, onNewType); } }