/// <summary> /// Resets the overrides attached to this node and its descendants, recursively. /// </summary> /// <param name="indexToReset">The index of the override to reset in this node, if relevant.</param> public void ResetOverride(Index indexToReset) { if (indexToReset.IsEmpty) { OverrideContent(false); } else { OverrideItem(false, indexToReset); } var visitor = PropertyGraph.CreateReconcilierVisitor(); visitor.SkipRootNode = true; visitor.Visiting += (node, path) => { var childNode = (AssetNode)node; childNode.OverrideContent(false); foreach (var overrideItem in childNode.GetOverriddenItemIndices()) { childNode.OverrideItem(false, overrideItem); } foreach (var overrideKey in childNode.GetOverriddenKeyIndices()) { childNode.OverrideKey(false, overrideKey); } }; visitor.Visit(this); PropertyGraph.ReconcileWithBase(this); }
private static void CreateObjectPropertyGraphs(TypeInfo cls, ObjectGraph obj) { foreach (var p in cls.GetProperties().Where(w => w.MemberType == MemberTypes.Property)) { var pg = new PropertyGraph { Name = _nullableRegex.IsMatch(p.Name) ? _nullableRegex.Match(p.Name).Value : p.Name, SourceType = p.PropertyType.GetFormattedName(true), IsKeyProperty = p.Name.EndsWith("Id", StringComparison.CurrentCultureIgnoreCase), //NOTE: cheesy }; foreach (var m in p.GetAccessors()) { if (m.Name.StartsWith("get_")) { pg.GetterVisibility = (m.IsPublic) ? MethodVisibilities.Public : m.IsPrivate ? MethodVisibilities.Private : MethodVisibilities.Protected; } if (m.Name.StartsWith("set_")) { pg.SetterVisibility = (m.IsPublic) ? MethodVisibilities.Public : m.IsPrivate ? MethodVisibilities.Private : MethodVisibilities.Protected; } } obj.Properties.Add(pg); Text.GrayLine( $"\tProperty: {p.Name}, Type: {p.PropertyType.GetFormattedName()}, Get: {Enum.GetName(typeof(MethodVisibilities), pg.GetterVisibility)}, Set: {Enum.GetName(typeof(MethodVisibilities), pg.SetterVisibility)}"); } }
public void GraphInitializerConstructorTest() { var graph = new PropertyGraph(g => g.SetProperty("hello", "world!")); Assert.IsNotNull(graph); Assert.IsNotNull(graph.IdKey); Assert.IsNotNull(graph.RevIdKey); Assert.IsNotNull(graph.DescriptionKey); Assert.IsNull (graph.Description); }
/// <inheritdoc/> public void ResetOverride(Index indexToReset) { if (indexToReset.IsEmpty) { OverrideContent(false); } else { OverrideItem(false, indexToReset); } PropertyGraph.ResetOverride(this, indexToReset); }
public static IPropertyGraph CreateTinkerGraph() { var _TinkerGraph = new PropertyGraph() as IPropertyGraph; _TinkerGraph.OnVertexAddition.OnVoting += (graph, vertex, vote) => { Console.WriteLine("I like all vertices!"); }; _TinkerGraph.OnVertexAddition.OnVoting += (graph, vertex, vote) => { if (vertex.Id == 5) { Console.WriteLine("I'm a Jedi!"); vote.Deny(); } }; var marko = _TinkerGraph.AddVertex(v => v.SetProperty("name", "marko"). SetProperty("age", 29)); var vadas = _TinkerGraph.AddVertex(v => v.SetProperty("name", "vadas"). SetProperty("age", 27)); var lop = _TinkerGraph.AddVertex(v => v.SetProperty("name", "lop"). SetProperty("lang", "java")); var josh = _TinkerGraph.AddVertex(v => v.SetProperty("name", "josh"). SetProperty("age", 32)); var vader = _TinkerGraph.AddVertex(v => v.SetProperty("name", "darth vader")); var ripple = _TinkerGraph.AddVertex(v => v.SetProperty("name", "ripple").SetProperty("lang", "java")); var peter = _TinkerGraph.AddVertex(v => v.SetProperty("name", "peter"). SetProperty("age", 35)); Console.WriteLine("Number of vertices added: " + _TinkerGraph.Vertices().Count()); marko.OnPropertyChanging += (sender, Key, oldValue, newValue, vote) => Console.WriteLine("'" + Key + "' property changing: '" + oldValue + "' -> '" + newValue + "'"); marko.OnPropertyChanged += (sender, Key, oldValue, newValue) => Console.WriteLine("'" + Key + "' property changed: '" + oldValue + "' -> '" + newValue + "'"); var _DynamicMarko = marko.AsDynamic(); _DynamicMarko.age += 100; _DynamicMarko.doIt = (Action<String>) ((text) => Console.WriteLine("Some infos: " + text + "!")); _DynamicMarko.doIt(_DynamicMarko.name + "/" + marko.GetProperty("age") + "/"); var e7 = _TinkerGraph.AddEdge(marko, vadas, 7, "knows", e => e.SetProperty("weight", 0.5)); var e8 = _TinkerGraph.AddEdge(marko, josh, 8, "knows", e => e.SetProperty("weight", 1.0)); var e9 = _TinkerGraph.AddEdge(marko, lop, 9, "created", e => e.SetProperty("weight", 0.4)); var e10 = _TinkerGraph.AddEdge(josh, ripple, 10, "created", e => e.SetProperty("weight", 1.0)); var e11 = _TinkerGraph.AddEdge(josh, lop, 11, "created", e => e.SetProperty("weight", 0.4)); var e12 = _TinkerGraph.AddEdge(peter, lop, 12, "created", e => e.SetProperty("weight", 0.2)); return _TinkerGraph; }
public void GraphIdConstructorTest() { var graph = new PropertyGraph(123, null); Assert.IsNotNull(graph); Assert.IsNotNull(graph.IdKey); Assert.AreEqual(123UL, graph.Id); Assert.IsNotNull(graph.RevIdKey); Assert.IsNotNull(graph.DescriptionKey); Assert.IsNull (graph.Description); }
public void CopyGraphTest() { var _SourceGraph = TinkerGraphFactory.CreateTinkerGraph() as IPropertyGraph; var _NumberOfVertices = _SourceGraph.NumberOfVertices(); var _NumberOfEdges = _SourceGraph.NumberOfEdges(); var _DestinationGraph = new PropertyGraph() as IPropertyGraph; //_SourceGraph.CopyGraph(_DestinationGraph); Assert.AreEqual(_NumberOfVertices, _DestinationGraph.NumberOfVertices()); Assert.AreEqual(_NumberOfEdges, _DestinationGraph.NumberOfEdges()); }
public void GraphIdAndHashCodeTest() { var graph1 = new PropertyGraph(123, null) { Description = "The first graph." }; var graph2 = new PropertyGraph(256, null) { Description = "The second graph." }; var graph3 = new PropertyGraph(123, null) { Description = "The third graph." }; Assert.IsNotNull(graph1.Id); Assert.IsNotNull(graph2.Id); Assert.IsNotNull(graph3.Id); Assert.IsNotNull(graph1.Description); Assert.IsNotNull(graph2.Description); Assert.IsNotNull(graph3.Description); Assert.IsNotNull(graph1.GetHashCode()); Assert.IsNotNull(graph2.GetHashCode()); Assert.IsNotNull(graph3.GetHashCode()); Assert.AreEqual(graph1.Id, graph1.GetHashCode()); Assert.AreEqual(graph2.Id, graph2.GetHashCode()); Assert.AreEqual(graph3.Id, graph3.GetHashCode()); Assert.AreEqual(graph1.Id, graph3.Id); Assert.AreEqual(graph1.GetHashCode(), graph3.GetHashCode()); Assert.AreNotEqual(graph1.Description, graph2.Description); Assert.AreNotEqual(graph2.Description, graph3.Description); Assert.AreNotEqual(graph3.Description, graph1.Description); }
public void IPropertiesExtensionMethodsTest() { var graph = new PropertyGraph(123UL, g => g.SetProperty (new KeyValuePair<String, Object>("hello", "world!")). SetProperties(new List<KeyValuePair<String, Object>>() { new KeyValuePair<String, Object>("graphs", "are cool!"), new KeyValuePair<String, Object>("Keep", "it simple!")}). SetProperties(new Dictionary<String, Object>() { { "a", "b" }, { "c", "d" } }). SetProperty ("e", "f")); Assert.AreEqual(123UL, graph.GetProperty("Id")); Assert.AreEqual("world!", graph.GetProperty("hello")); Assert.AreEqual("are cool!", graph.GetProperty("graphs")); Assert.AreEqual("it simple!", graph.GetProperty("Keep")); Assert.AreEqual("b", graph.GetProperty("a")); Assert.AreEqual("d", graph.GetProperty("c")); Assert.AreEqual(123UL, graph.GetProperty("Id", typeof(UInt64))); Assert.AreEqual("world!", graph.GetProperty("hello", typeof(String))); Assert.AreEqual("are cool!", graph.GetProperty("graphs", typeof(String))); Assert.AreEqual("it simple!", graph.GetProperty("Keep", typeof(String))); Assert.AreNotEqual("world!", graph.GetProperty("hello", typeof(UInt64))); // --[Action<TValue>]-------------------------------------------------------------- Nullable<Boolean> check; check = null; graph.UseProperty("false", OnSuccess_PropertyValue => check = true); Assert.IsNull(check); check = null; graph.UseProperty("Id", OnSuccess_PropertyValue => check = true); Assert.IsTrue(check.Value); check = null; graph.UseProperty("hello", OnSuccess_PropertyValue => check = true); Assert.IsTrue(check.Value); check = null; graph.UseProperty("graphs", OnSuccess_PropertyValue => check = true); Assert.IsTrue(check.Value); // --[Action<TKey, TValue>]-------------------------------------------------------- check = null; graph.UseProperty("false", (OnSuccess_PropertyKey, PropertyValue) => check = true); Assert.IsNull(check); check = null; graph.UseProperty("Id", (OnSuccess_PropertyKey, PropertyValue) => check = true); Assert.IsTrue(check.Value); check = null; graph.UseProperty("hello", (OnSuccess_PropertyKey, PropertyValue) => check = true); Assert.IsTrue(check.Value); check = null; graph.UseProperty("graphs", (OnSuccess_PropertyKey, PropertyValue) => check = true); Assert.IsTrue(check.Value); // --[Action<TValue>]--[Error]----------------------------------------------------- check = null; graph.UseProperty("false", OnSuccess_PropertyValue => check = true, OnError => check = false); Assert.IsFalse(check.Value); check = null; graph.UseProperty("Id", OnSuccess_PropertyValue => check = true, OnError => check = false); Assert.IsTrue(check.Value); check = null; graph.UseProperty("hello", OnSuccess_PropertyValue => check = true, OnError => check = false); Assert.IsTrue(check.Value); check = null; graph.UseProperty("graphs", OnSuccess_PropertyValue => check = true, OnError => check = false); Assert.IsTrue(check.Value); // --[Action<TKey, TValue>]--[Error]----------------------------------------------- check = null; graph.UseProperty("false", (OnSuccess_PropertyKey, PropertyValue) => check = true, OnError => check = false); Assert.IsFalse(check.Value); check = null; graph.UseProperty("Id", (OnSuccess_PropertyKey, PropertyValue) => check = true, OnError => check = false); Assert.IsTrue(check.Value); check = null; graph.UseProperty("hello", (OnSuccess_PropertyKey, PropertyValue) => check = true, OnError => check = false); Assert.IsTrue(check.Value); check = null; graph.UseProperty("graphs", (OnSuccess_PropertyKey, PropertyValue) => check = true, OnError => check = false); Assert.IsTrue(check.Value); // --[Func<TValue, TResult>]------------------------------------------------------- #if !__MonoCS__ Assert.AreEqual("world!?", graph.PropertyFunc("hello", PropertyValue => { return (PropertyValue as String) + "?"; })); Assert.AreEqual(124UL, graph.PropertyFunc("Id", PropertyValue => { return ( (UInt64) PropertyValue ) + 1; })); Assert.AreEqual(0, graph.PropertyFunc("XYZ", PropertyValue => { return ( (UInt64) PropertyValue ) + 1; })); Assert.AreEqual(null, graph.PropertyFunc("XYZ", PropertyValue => { return ( (String) PropertyValue ); })); #endif Assert.AreEqual("world!?", graph.PropertyFunc("hello", typeof(String), PropertyValue => { return (PropertyValue as String) + "?"; })); Assert.AreEqual(124UL, graph.PropertyFunc("Id", typeof(UInt64), PropertyValue => { return ( (UInt64) PropertyValue ) + 1; })); Assert.AreEqual(null, graph.PropertyFunc("XYZ", typeof(UInt64), PropertyValue => { return ( (UInt64) PropertyValue ) + 1; })); Assert.AreEqual(null, graph.PropertyFunc("XYZ", typeof(String), PropertyValue => { return ( (String) PropertyValue ); })); #if !__MonoCS__ // --[Func<TKey, TValue, TResult>]------------------------------------------------- Assert.AreEqual("hello world!", graph.PropertyFunc("hello", (OnSuccess_PropertyKey, PropertyValue) => { return OnSuccess_PropertyKey + " " + (PropertyValue as String); })); Assert.AreEqual("Id124", graph.PropertyFunc("Id", (OnSuccess_PropertyKey, PropertyValue) => { return OnSuccess_PropertyKey + ((UInt64) PropertyValue + 1); })); #endif Assert.AreEqual("hello world!", graph.PropertyFunc("hello", typeof(String), (OnSuccess_PropertyKey, PropertyValue) => { return OnSuccess_PropertyKey + " " + (PropertyValue as String); })); Assert.AreEqual("Id124", graph.PropertyFunc("Id", typeof(UInt64), (OnSuccess_PropertyKey, PropertyValue) => { return OnSuccess_PropertyKey + ((UInt64) PropertyValue + 1); })); // Filtered Keys/Values var FilteredKeys1 = graph.FilteredKeys ((k, v) => true).ToList(); Assert.NotNull(FilteredKeys1); Assert.AreEqual(8, FilteredKeys1.Count); var FilteredKeys2 = graph.FilteredKeys ((k, v) => { if ((v as String).IsNotNullAndContains("!")) return true; else return false;}).ToList(); Assert.NotNull(FilteredKeys2); Assert.AreEqual(3, FilteredKeys2.Count); var FilteredValues1 = graph.FilteredValues((k, v) => true).ToList(); Assert.NotNull(FilteredValues1); Assert.AreEqual(8, FilteredValues1.Count); var FilteredValues2 = graph.FilteredValues((k, v) => { if ((v as String).IsNotNullAndContains("!")) return true; else return false; }).ToList(); Assert.NotNull(FilteredValues2); Assert.AreEqual(3, FilteredValues2.Count); }
/// <inheritdoc/> public void ResetOverride(Index indexToReset) { PropertyGraph.ResetOverride(this, indexToReset); }
public void RemoveRevIdTest3() { var graph = new PropertyGraph(123UL); graph.Remove((k, v) => k == "RevId"); }
public void RemoveRevIdTest2() { var graph = new PropertyGraph(123UL); graph.Remove("RevId", 0); }
public void RemoveIdTest2() { var graph = new PropertyGraph(123UL); graph.Remove("Id", 123UL); }
public void ChangeRevIdTest1() { var graph = new PropertyGraph(123UL); graph.SetProperty("RevId", 256UL); }
public void GraphDescriptionTest() { var graph = new PropertyGraph(g => g.SetProperty("hello", "world!")); Assert.IsNotNull(graph); Assert.IsNotNull(graph.IdKey); Assert.IsNotNull(graph.RevIdKey); Assert.IsNotNull(graph.DescriptionKey); Assert.IsNull(graph.Description); graph.Description = "This is a property graph!"; Assert.IsNotNull(graph.Description); Assert.AreEqual("This is a property graph!", graph.Description); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { Text.WhiteLine($"Downloading from [{Config.Address}]"); //https://swagger.io/docs/specification/basic-structure/ var gen = await OpenApiDocument.FromUrlAsync(Config.Address); gen.GenerateOperationIds(); var usings = new[] { "System", "System.Text", "System.Collections", "System.Collections.Generic", "System.Threading.Tasks", "System.Linq", "System.Net.Http", "System.ComponentModel.DataAnnotations", "Newtonsoft.Json", }; var settings = new CSharpClientGeneratorSettings { GenerateDtoTypes = true, AdditionalContractNamespaceUsages = usings, AdditionalNamespaceUsages = usings }; settings.CodeGeneratorSettings.InlineNamedAny = true; settings.CSharpGeneratorSettings.Namespace = Config.OutputNamespace; settings.CSharpGeneratorSettings.ClassStyle = CSharpClassStyle.Inpc; var generator = new NSwag.CodeGeneration.OperationNameGenerators.MultipleClientsFromFirstTagAndPathSegmentsOperationNameGenerator(); var csgen = new CSharpClientGenerator(gen, settings); csgen.Settings.GenerateOptionalParameters = true; csgen.Settings.GenerateResponseClasses = true; csgen.Settings.SerializeTypeInformation = true; csgen.Settings.OperationNameGenerator = generator; Text.White($"Processing contents... "); var code = csgen.GenerateFile(ClientGeneratorOutputType.Full); Text.GreenLine("OK"); var trustedAssembliesPaths = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")).Split(Path.PathSeparator); var neededLibs = new [] { "mscorlib", "netstandard", "System.Core", "System.Runtime", "System.IO", "System.ObjectModel", "System.Linq", "System.Net.Http", "System.Collections", "System.CodeDom.Compiler", "System.ComponentModel", "System.ComponentModel.Annotations", "System.Net.Primitives", "System.Runtime.Serialization", "System.Runtime.Serialization.Primitives", "System.Runtime.Extensions", "System.Private.Uri", "System.CodeDom", "System.Composition.AttributedModel", "System.Composition.Convention", "System.Composition.Runtime", "System.Diagnostics.Tools", "Microsoft.CodeAnalysis.CSharp", "NJsonSchema", "Newtonsoft.Json", }; Text.WhiteLine($"Determining dependencies"); var refs = trustedAssembliesPaths .Where(p => neededLibs.Contains(Path.GetFileNameWithoutExtension(p))) .Select(p => MetadataReference.CreateFromFile(p)) .ToList(); refs.Add(MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location)); var options = new CSharpParseOptions(LanguageVersion.CSharp8, DocumentationMode.Parse, SourceCodeKind.Regular); Text.WhiteLine("Defining entry point"); var rdr = new StringReader(code); var lines = new StringBuilder(); var i = 0; string line; while ((line = await rdr.ReadLineAsync()) != null) { lines.AppendLine(line); if (i == 26) //lol lame { lines.AppendLine(ENTRY_POINT); } i++; } code = lines.ToString(); File.WriteAllText(@"C:\Temp\GeneratedCode.cs", code); Text.WhiteLine("Creating Syntax Tree"); var syntax = CSharpSyntaxTree.ParseText(code, options: options); Text.WhiteLine("Preprocessing"); var comp = CSharpCompilation.Create("swag-gen-temp.dll", new[] { syntax }, refs.ToArray()); await using var stream = new MemoryStream(); Text.White("Creating temporary objects... "); var result = comp.Emit(stream); Text.GreenLine("OK"); if (!result.Success) { Text.RedLine("Unable to build temp library"); var failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (var diagnostic in failures) { Text.RedLine($@"\t{diagnostic.Id}: {diagnostic.GetMessage()}"); } return(new InputGenesisExecutionResult { Success = false, Message = "Errors occurred" }); } stream.Seek(0, SeekOrigin.Begin); var tmpAss = AssemblyLoadContext.Default.LoadFromStream(stream); // loop classes foreach (var c in tmpAss.GetTypes().Where(w => w.IsClass)) { Text.GrayLine($"Class: {c.Name}"); var obj = new ObjectGraph { Name = c.Name, Namespace = Config.OutputNamespace, GraphType = GraphTypes.Object, }; foreach (var p in c.GetProperties().Where(w => w.MemberType == MemberTypes.Property)) { if (!p.CanWrite || !p.GetSetMethod(/*nonPublic*/ true).IsPublic) { continue; //for now; } var pg = new PropertyGraph { Name = p.Name, SourceType = p.PropertyType.Name, IsKeyProperty = p.Name.EndsWith("Id", StringComparison.CurrentCultureIgnoreCase), //NOTE: cheesy Accesibility = (p.CanWrite && p.GetSetMethod(/*nonPublic*/ true).IsPublic) ? "public" : "protected" }; obj.Properties.Add(pg); Text.GrayLine($"\tProperty: {c.Name}"); } foreach (var m in c.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) { var meth = new MethodGraph { Name = m.Name.Replace("get_", string.Empty), MethodVisibility = MethodVisibilities.Public, ReturnDataType = m.ReturnType, HasGenericParams = m.ContainsGenericParameters, IsGeneric = m.IsGenericMethod, }; foreach (var par in m.GetParameters().Where(w => w.IsIn).OrderBy(o => o.Position)) { var mp = new ParameterGraph { DataType = par.ParameterType, Name = par.Name, IsOut = par.IsOut, IsOptional = par.IsOptional, Position = par.Position }; meth.Parameters.Add(mp); Text.GrayLine($"\tMethod: {c.Name}"); } } genesis.Objects.Add(obj); } Text.SuccessGraffiti(); return(await base.Execute(genesis, args)); //TODO: fix the whole IGenesisExecutionResult "stuff" }
internal void ProcessReplacements() { foreach (var t in rewriteAssembly.GetTypes()) { bool forceImplRewrite = t.Name.StartsWith("<PrivateImplementationDetails>"); var repl = t.GetCustomAttribute <RewriteAttribute>(false); TypeGraph typeTarget = null; TypeRewrite typeRewrite = null; if (repl != null) { if (repl.action == RewriteAction.Add) { typeTarget = new TypeGraph(t, null, _graph._modules.First()); if (repl.typeName != null) { typeTarget.FullName = repl.typeName; } continue; } typeTarget = (from x in Graph.Modules from y in x.TypeGraphs where y.FullName == repl.typeName select y).Single(); if (repl.action == RewriteAction.Replace) { typeTarget._replacementType = t; } _typeRewrites.Add(typeRewrite = new TypeRewrite() { MemberInfo = t, Rewrite = repl, Graph = typeTarget }); } foreach (var m in t.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly)) { if (forceImplRewrite) { if (m is MethodInfo) { _staticImplCache.Add(m as MethodInfo); } } var mRep = m.GetCustomAttribute <RewriteAttribute>(); if (mRep == null) { continue; } var mTypeTarget = mRep.typeName == null || (repl != null && repl.typeName == mRep.typeName) ? typeTarget : (from x in Graph.Modules from y in x.TypeGraphs where y.FullName == mRep.typeName select y).Single(); if (typeRewrite == null) { _typeRewrites.Add(typeRewrite = new TypeRewrite() { MemberInfo = t }); } var name = mRep.targetName ?? m.Name; if (m is MethodBase) { var mb = m as MethodBase; var target = mTypeTarget.Methods.FirstOrDefault(x => x.Name == name); MethodGraph newTarget = null; if (mRep.action == RewriteAction.Add) { newTarget = new MethodGraph(mb, mTypeTarget); } else if (mRep.action == RewriteAction.Remove) { target.DeclaringObject = null; } else if (mRep.action != RewriteAction.None) { newTarget = target.SwitchImpl(mb, mRep.newName, mRep.oldName); if (mRep.action == RewriteAction.Replace) { target.DeclaringObject = null; } else if (mRep.action == RewriteAction.Swap && newTarget.Name == target.Name) { target.Name += "_Orig"; } } if (mRep.contentHandler != null) { t.GetMethod(mRep.contentHandler).Invoke(null, new object[] { target, newTarget }); } typeRewrite.MethodRewrites.Add(new RewriteInfo <MethodBase, MethodGraph>() { MemberInfo = mb, Rewrite = mRep, Graph = mRep.action == RewriteAction.Replace || mRep.stubAction == StubAction.UseNew ? (newTarget ?? target) : (target ?? newTarget) }); } else if (m is PropertyInfo) { var p = m as PropertyInfo; var target = mTypeTarget.Properties.FirstOrDefault(x => x.Name == name); PropertyGraph newTarget = null; MethodGraph newGet = null, newSet = null; MethodGraph oldGet = null, oldSet = null; if (mRep.action == RewriteAction.Add) { newTarget = new PropertyGraph(p, mTypeTarget); if (newTarget._getAccessor != null) { newGet = new MethodGraph(newTarget._getAccessor, mTypeTarget); } if (newTarget._setAccessor != null) { newSet = new MethodGraph(newTarget._setAccessor, mTypeTarget); } } else { oldGet = target._getAccessor != null?mTypeTarget.Methods.FirstOrDefault(x => x._sourceObject == target._getAccessor) : null; oldSet = target._setAccessor != null?mTypeTarget.Methods.FirstOrDefault(x => x._sourceObject == target._setAccessor) : null; if (mRep.action == RewriteAction.Remove) { if (oldGet != null) { oldGet.DeclaringObject = null; } if (oldSet != null) { oldSet.DeclaringObject = null; } target.DeclaringObject = null; } else if (mRep.action != RewriteAction.None) { newTarget = new PropertyGraph(p, mTypeTarget); newTarget.Source = target.Source; if (newTarget._getAccessor != null) { newGet = oldGet.SwitchImpl(newTarget._getAccessor); } if (newTarget._setAccessor != null) { newSet = oldSet.SwitchImpl(newTarget._setAccessor); } if (mRep.action == RewriteAction.Replace) { if (oldGet != null) { oldGet.DeclaringObject = null; } if (oldSet != null) { oldSet.DeclaringObject = null; } target.DeclaringObject = null; } else if (mRep.action == RewriteAction.Swap && newTarget.Name == target.Name) { target.Name += "_Orig"; if (oldGet != null) { oldGet.Name += "_Orig"; } if (oldSet != null) { oldSet.Name += "_Orig"; } } } } if (mRep.contentHandler != null) { t.GetMethod(mRep.contentHandler).Invoke(null, new object[] { target, newTarget }); } typeRewrite.PropertyRewrites.Add(new PropertyRewrite() { MemberInfo = p, Rewrite = mRep, Graph = mRep.action == RewriteAction.Replace || mRep.stubAction == StubAction.UseNew ? (newTarget ?? target) : (target ?? newTarget), GetGraph = mRep.action == RewriteAction.Replace || mRep.stubAction == StubAction.UseNew ? (newGet ?? oldGet) : (oldGet ?? newGet), SetGraph = mRep.action == RewriteAction.Replace || mRep.stubAction == StubAction.UseNew ? (newSet ?? oldSet) : (oldSet ?? newSet) }); } else if (m is FieldInfo) { var f = m as FieldInfo; var target = mTypeTarget.Fields.FirstOrDefault(x => x.Name == name); FieldGraph newTarget = null; if (mRep.action == RewriteAction.Remove) { target.DeclaringObject = null; } else if (mRep.action != RewriteAction.None) { newTarget = new FieldGraph(f, mTypeTarget); if (mRep.action == RewriteAction.Replace) { newTarget.Source = target.Source; target.DeclaringObject = null; } else if (mRep.action == RewriteAction.Swap) { target.Name += "_Orig"; } } if (mRep.contentHandler != null) { t.GetMethod(mRep.contentHandler).Invoke(null, new object[] { target, newTarget }); } typeRewrite.FieldRewrites.Add(new RewriteInfo <FieldInfo, FieldGraph>() { MemberInfo = f, Rewrite = mRep, Graph = mRep.action == RewriteAction.Replace || mRep.stubAction == StubAction.UseNew ? (newTarget ?? target) : (target ?? newTarget) }); } } } }
public void ChangePropertyEventTest() { Nullable<Boolean> check = null; var graph = new PropertyGraph(123UL, g => g.SetProperty("key", "value"). SetProperty("nokey", "value")); graph.OnPropertyChanging += (g, key, oldvalue, newvalue, vote) => { if (key.StartsWith("ke")) vote.Ok(); else vote.Deny(); }; graph.OnPropertyChanged += (g, key, oldvalue, newvalue) => check = true; graph.SetProperty("nokey", "value"); Assert.IsNull(check); graph.SetProperty("key", "value"); Assert.IsTrue(check.Value); }
/// <inheritdoc/> public void ResetOverrideRecursively(Index indexToReset) { OverrideItem(false, indexToReset); PropertyGraph.ResetAllOverridesRecursively(node, indexToReset); }
public void RemovePropertyEventTest() { Nullable<Boolean> check = null; var graph = new PropertyGraph(123UL, g => g.SetProperty("key", "value"). SetProperty("nokey", "value")); graph.OnPropertyRemoving += (g, key, value, vote) => { if (key.StartsWith("ke")) vote.Ok(); else vote.Deny(); }; graph.OnPropertyRemoved += (g, key, value) => check = true; graph.Remove("nokey", "value"); Assert.IsNull(check); Assert.IsTrue(graph.ContainsKey("nokey")); graph.Remove("key", "value"); Assert.IsTrue(check.Value); Assert.IsFalse(graph.ContainsKey("key")); }