private static void RunProxyLargeDocLoad(int iterations, List <string> output, List <LargeDocumentViewModel> largeDocReference)
{
ClassConstructor.SetInstanceFactory(new ProxyInstanceFactory());
_currentIsProxy = true;
RunIterations(LoadLargeDocs, _largeDocumentReaders, iterations, output, "proxy", largeDocReference);
ClassConstructor.SetInstanceFactory(new DefaultInstanceFactory());
}
private static void RunProxyBlogLoad(int iterations, List <string> output, List <BlogEntryViewModel> blogReferences)
{
ClassConstructor.SetInstanceFactory(new ProxyInstanceFactory());
_currentIsProxy = true;
RunIterations(LoadPosts, _blogPostReaders, iterations, output, "proxy", blogReferences);
ClassConstructor.SetInstanceFactory(new DefaultInstanceFactory());
}
private static Action <TSrc, Targ> GetMapper <TSrc, Targ>()
{
Type target = typeof(Targ);
Type src = typeof(TSrc);
var name = string.Format("{0}To{1}", Utility.GetValidString(src.FullName), Utility.GetValidString(target.FullName));
return((Action <TSrc, Targ>)delegates.GetOrAdd(name, (n) =>
{
var srcProps = src.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
var trgtProps = target.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
var sr = Expression.Parameter(src);
var trgt = Expression.Parameter(target);
ClassConstructor cc = new ClassConstructor(name);
MethodConstructor mc = new MethodConstructor("Copy",
Expression.Lambda <Action <TSrc, Targ> >(
Expression.Block(
(from item in trgtProps
from s in srcProps
where item.Name == s.Name && item.PropertyType == s.PropertyType
select Expression.Assign(Expression.Property(trgt, item.Name), Expression.Property(sr, item.Name)))), sr, trgt),
System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.Static);
cc.AddMethod(mc);
_manager.AddType(cc);
_manager.BuildClass(AppDomain.CurrentDomain, cc.Name);
return mc.CreateDelegate(typeof(Action <TSrc, Targ>));
}));
}
public ReadOnlyClassConstructor(IClassType declaringType, ClassConstructor constructor)
{
this.declaringType = declaringType;
this.constructor = constructor;
body = new ReadOnlyMethodBody(constructor.Statements);
parameters = constructor.Parameters.ToArray(parameter => new ReadOnlyConstructorParameter(parameter));
}
void Generate(ClassConstructorModel model)
{
var template = new ClassConstructor(model);
var content = template.TransformText();
var fileName = String.Concat(model.Name, "Constructor", _options.Extension);
_files.Add(new GeneratedFile(content, fileName));
}
public ActionResult ValueShouldMatchCmsContent()
{
ClassConstructor.SetInstanceFactory(new DefaultInstanceFactory());
var referenceModel = Vault.Context.GetByDocumentType <BlogEntryViewModel>().FirstOrDefault();
ClassConstructor.SetInstanceFactory(new ProxyInstanceFactory());
var proxyModel = Vault.Context.GetContentById <BlogEntryViewModel>(referenceModel.CmsContent.Id);
var result = Content(FormatResult(referenceModel.Content, referenceModel.Content, proxyModel.Content), "text/html");
ClassConstructor.SetInstanceFactory(new DefaultInstanceFactory());
return(result);
}
public void TextExitEvent()
{
Guid newId = Guid.NewGuid();
string tempFileName = Path.Combine(Path.GetTempPath(), newId.ToString());
try
{
AcmaExternalExitEventCmd e = new AcmaExternalExitEventCmd();
e.ID = "test external event";
e.RuleGroup = new RuleGroup()
{
Operator = GroupOperator.Any
};
e.RuleGroup.Items.Add(new ObjectChangeRule()
{
TriggerEvents = TriggerEvents.Add
});
e.CommandLine = "cmd.exe";
e.Arguments = new ValueDeclaration("/c dir >> " + tempFileName.Replace(@"\", @"\\"));
if (!ActiveConfig.XmlConfig.ClassConstructors.Contains("person"))
{
ClassConstructor constructor = new ClassConstructor();
constructor.ObjectClass = ActiveConfig.DB.GetObjectClass("person");
ActiveConfig.XmlConfig.ClassConstructors.Add(constructor);
}
ActiveConfig.XmlConfig.ClassConstructors["person"].ExitEvents.Add(e);
MAObjectHologram sourceObject = ActiveConfig.DB.CreateMAObject(newId, "person");
sourceObject.SetAttributeValue(ActiveConfig.DB.GetAttribute("mail"), "*****@*****.**");
sourceObject.CommitCSEntryChange();
if (!System.IO.File.Exists(tempFileName))
{
Assert.Fail("The external event did not created the expected file");
}
}
finally
{
if (System.IO.File.Exists(tempFileName))
{
System.IO.File.Delete(tempFileName);
}
}
}
public ActionResult ValueShouldBeOverWritten()
{
const string OverrideContent = "This content has been overwritten";
ClassConstructor.SetInstanceFactory(new DefaultInstanceFactory());
var referenceModel = Vault.Context.GetByDocumentType <BlogEntryViewModel>().FirstOrDefault();
ClassConstructor.SetInstanceFactory(new ProxyInstanceFactory());
var proxyModel = Vault.Context.GetContentById <BlogEntryViewModel>(referenceModel.CmsContent.Id);
proxyModel.Content = OverrideContent;
var result = Content(FormatResult(referenceModel.Content, OverrideContent, proxyModel.Content), "text/html");
ClassConstructor.SetInstanceFactory(new DefaultInstanceFactory());
return(result);
}
public _Ctor(ClassConstructor def, VectorInstFromScriptClass inst) : base(inst)
{
var defParams = def.getParameters();
var instParams = (defParams.length == 0)
? Array.Empty <MethodTraitParameter>()
: new MethodTraitParameter[defParams.length];
for (int i = 0; i < instParams.Length; i++)
{
var defParam = defParams[i];
var instParamType = inst._substituteElement(defParam.type);
instParams[i] = new MethodTraitParameter(
defParam.name, instParamType, defParam.isOptional, defParam.hasDefault, defParam.defaultValue);
}
setSignature(instParams, def.hasRest);
setMetadata(def.metadata);
setUnderlyingCtorInfo(def.underlyingConstructorInfo);
}
public override JSValue Evaluate(Context context)
{
JSValue variable = null;
if ((_codeContext & CodeContext.InExpression) == 0)
{
variable = context.DefineVariable(Name);
}
var ctor = new ClassConstructor(context, _constructor, this)
{
RequireNewKeywordLevel = RequireNewKeywordLevel.WithNewOnly
};
if (_baseClass != null)
{
JSValue baseProto = _baseClass.Evaluate(context)._oValue as JSObject;
if (baseProto == null)
{
ctor.prototype.__proto__ = null;
}
else
{
ctor.prototype.__proto__ = Tools.InvokeGetter(baseProto.GetProperty("prototype"), baseProto)._oValue as JSObject;
}
ctor.__proto__ = baseProto as JSObject;
}
foreach (var member in _members)
{
var value = member.Value.Evaluate(context);
var target = member.Static ? ctor : ctor.prototype;
target.SetProperty(member.Name.Evaluate(null), value, true);
}
foreach (var prop in computedProperties)
{
JSObject target = prop.Static ? ctor : ctor.prototype._oValue as JSObject;
var key = prop._name.Evaluate(context).CloneImpl(false);
var value = prop._value.Evaluate(context).CloneImpl(false);
JSValue existedValue;
Symbol symbolKey = null;
string stringKey = null;
if (key.Is <Symbol>())
{
symbolKey = key.As <Symbol>();
if (target._symbols == null)
{
target._symbols = new Dictionary <Symbol, JSValue>();
}
if (!target._symbols.TryGetValue(symbolKey, out existedValue))
{
target._symbols[symbolKey] = existedValue = value;
}
}
else
{
stringKey = key.As <string>();
if (!target._fields.TryGetValue(stringKey, out existedValue))
{
target._fields[stringKey] = existedValue = value;
}
}
if (existedValue == value)
{
continue;
}
if (existedValue.Is(JSValueType.Property) && value.Is(JSValueType.Property))
{
var egs = existedValue.As <Core.PropertyPair>();
var ngs = value.As <Core.PropertyPair>();
egs.getter = ngs.getter ?? egs.getter;
egs.setter = ngs.setter ?? egs.setter;
}
else
{
if (key.Is <Symbol>())
{
target._symbols[symbolKey] = value;
}
else
{
target._fields[stringKey] = value;
}
}
}
if ((_codeContext & CodeContext.InExpression) == 0)
{
variable.Assign(ctor);
}
return(ctor);
}
public void TestSerialization()
{
AttributeValueDeleteConstructor constructorToSerialize1 = new AttributeValueDeleteConstructor();
constructorToSerialize1.Attribute = ActiveConfig.DB.GetAttribute("sn");
constructorToSerialize1.ID = "abc123";
constructorToSerialize1.Description = "some description";
constructorToSerialize1.RuleGroup = new RuleGroup()
{
Operator = GroupOperator.Any
};
constructorToSerialize1.RuleGroup.Items.Add(new ObjectChangeRule()
{
TriggerEvents = TriggerEvents.Delete
});
AttributeValueDeleteConstructor constructorToSerialize2 = new AttributeValueDeleteConstructor();
constructorToSerialize2.Attribute = ActiveConfig.DB.GetAttribute("sn");
constructorToSerialize2.ID = "abc123";
constructorToSerialize2.Description = "some description";
constructorToSerialize2.RuleGroup = new RuleGroup()
{
Operator = GroupOperator.All
};
constructorToSerialize2.RuleGroup.Items.Add(new ObjectChangeRule()
{
TriggerEvents = TriggerEvents.Add
});
AttributeConstructorGroup groupToSerialize = new AttributeConstructorGroup();
groupToSerialize.Description = "my description";
groupToSerialize.ID = "myID";
groupToSerialize.ExecutionRule = GroupExecutionRule.ExitAfterFirstSuccess;
groupToSerialize.RuleGroup = new RuleGroup()
{
Operator = GroupOperator.Any
};
groupToSerialize.RuleGroup.Items.Add(new ObjectChangeRule()
{
TriggerEvents = TriggerEvents.Delete
});
groupToSerialize.Constructors.Add(constructorToSerialize1);
ClassConstructor classConstructorToSerialize = new ClassConstructor();
classConstructorToSerialize.ObjectClass = ActiveConfig.DB.GetObjectClass("person");
classConstructorToSerialize.ExitEvents.Add(new AcmaInternalExitEvent()
{
ID = "testName"
});
classConstructorToSerialize.Constructors.Add(groupToSerialize);
classConstructorToSerialize.Constructors.Add(constructorToSerialize2);
classConstructorToSerialize.ResurrectionParameters = new DBQueryGroup();
classConstructorToSerialize.ResurrectionParameters.Operator = GroupOperator.Any;
classConstructorToSerialize.ResurrectionParameters.DBQueries.Add(new DBQueryByValue(ActiveConfig.DB.GetAttribute("sn"), ValueOperator.Equals, new ValueDeclaration("test")));
classConstructorToSerialize.ResurrectionParameters.DBQueries.Add(new DBQueryByValue(ActiveConfig.DB.GetAttribute("sn"), ValueOperator.Equals, ActiveConfig.DB.GetAttribute("sn")));
XmlConfigFile toSerialize = new XmlConfigFile();
toSerialize.ClassConstructors.Add(classConstructorToSerialize);
toSerialize.Transforms = new TransformKeyedCollection();
toSerialize.Transforms.Add(new TrimStringTransform()
{
TrimType = TrimType.Both, ID = "trimboth"
});
UniqueIDCache.ClearIdCache();
XmlConfigFile deserialized = UnitTestControl.XmlSerializeRoundTrip <XmlConfigFile>(toSerialize);
Assert.AreEqual(toSerialize.ClassConstructors.Count, deserialized.ClassConstructors.Count);
Assert.AreEqual(toSerialize.Transforms.Count, deserialized.Transforms.Count);
}
public void Add(TLDefinition tld, Stream srcStm)
{
TLFunction tlf = tld as TLFunction;
if (tlf != null)
{
if (IsConstructor(tlf.Signature, tlf.Class))
{
Constructors.Add(tlf, srcStm);
}
else if (tlf.Signature is SwiftClassConstructorType)
{
if (ClassConstructor.Values.Count() == 0)
{
ClassConstructor.Add(tlf, srcStm);
}
else
{
throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 12, $"multiple type metadata accessors for {tlf.Class.ClassName.ToFullyQualifiedName ()}");
}
}
else if (IsDestructor(tlf.Signature, tlf.Class))
{
Destructors.Add(tlf, srcStm);
}
else if (IsProperty(tlf.Signature, tlf.Class))
{
if (IsSubscript(tlf.Signature, tlf.Class))
{
if (IsPrivateProperty(tlf.Signature, tlf.Class))
{
PrivateSubscripts.Add(tlf);
}
else
{
Subscripts.Add(tlf);
}
}
else
{
if (IsStaticProperty(tlf.Signature, tlf.Class))
{
if (IsPrivateProperty(tlf.Signature, tlf.Class))
{
StaticPrivateProperties.Add(tlf, srcStm);
}
else
{
StaticProperties.Add(tlf, srcStm);
}
}
else
{
if (IsPrivateProperty(tlf.Signature, tlf.Class))
{
PrivateProperties.Add(tlf, srcStm);
}
else
{
Properties.Add(tlf, srcStm);
}
}
}
}
else if (IsMethodOnClass(tlf.Signature, tlf.Class))
{
if (tlf is TLMethodDescriptor)
{
MethodDescriptors.Add(tlf, srcStm);
}
else
{
Methods.Add(tlf, srcStm);
}
}
else if (IsStaticMethod(tlf.Signature, tlf.Class))
{
StaticFunctions.Add(tlf, srcStm);
}
else if (IsWitnessTable(tlf.Signature, tlf.Class))
{
WitnessTable.Add(tlf, srcStm);
}
else if (IsInitializer(tlf.Signature, tlf.Class))
{
Initializers.Add(tlf, srcStm);
}
else
{
FunctionsOfUnknownDestination.Add(tlf);
}
return;
}
var meta = tld as TLDirectMetadata;
if (meta != null)
{
if (DirectMetadata != null)
{
throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 13, $"duplicate direct metadata in class {DirectMetadata.Class.ClassName.ToFullyQualifiedName ()}");
}
DirectMetadata = meta;
return;
}
var lazy = tld as TLLazyCacheVariable;
if (lazy != null)
{
if (LazyCacheVariable != null)
{
throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 14, $"duplicate lazy cache variable in class {LazyCacheVariable.Class.ClassName.ToFullyQualifiedName ()}");
}
LazyCacheVariable = lazy;
return;
}
var mc = tld as TLMetaclass;
if (mc != null)
{
if (Metaclass != null)
{
throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 15, $"duplicate type meta data descriptor in class {Metaclass.Class.ClassName.ToFullyQualifiedName ()}");
}
Metaclass = mc;
return;
}
var nom = tld as TLNominalTypeDescriptor;
if (nom != null)
{
if (TypeDescriptor != null)
{
throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 16, $"duplicate nominal type descriptor in class {TypeDescriptor.Class.ClassName.ToFullyQualifiedName ()}");
}
TypeDescriptor = nom;
return;
}
var tlvar = tld as TLVariable;
if (tlvar != null)
{
if (tlvar is TLPropertyDescriptor tlpropDesc)
{
PropertyDescriptors.Add(tlpropDesc);
}
else
{
Variables.Add(tlvar, srcStm);
}
return;
}
var tlprot = tld as TLProtocolConformanceDescriptor;
if (tlprot != null)
{
ProtocolConformanceDescriptors.Add(tlprot);
return;
}
DefinitionsOfUnknownDestination.Add(tld);
}
public void TestSerialization()
{
AttributeValueDeleteConstructor constructorToSerialize1 = new AttributeValueDeleteConstructor();
constructorToSerialize1.Attribute = ActiveConfig.DB.GetAttribute("sn");
constructorToSerialize1.ID = "abc123";
constructorToSerialize1.Description = "some description";
constructorToSerialize1.RuleGroup = new RuleGroup()
{
Operator = GroupOperator.Any
};
constructorToSerialize1.RuleGroup.Items.Add(new ObjectChangeRule()
{
TriggerEvents = TriggerEvents.Delete
});
AttributeValueDeleteConstructor constructorToSerialize2 = new AttributeValueDeleteConstructor();
constructorToSerialize2.Attribute = ActiveConfig.DB.GetAttribute("sn");
constructorToSerialize2.ID = "abc123";
constructorToSerialize2.Description = "some description";
constructorToSerialize2.RuleGroup = new RuleGroup()
{
Operator = GroupOperator.All
};
constructorToSerialize2.RuleGroup.Items.Add(new ObjectChangeRule()
{
TriggerEvents = TriggerEvents.Add
});
AttributeConstructorGroup groupToSerialize = new AttributeConstructorGroup();
groupToSerialize.Description = "my description";
groupToSerialize.ID = "myID";
groupToSerialize.ExecutionRule = GroupExecutionRule.ExitAfterFirstSuccess;
groupToSerialize.RuleGroup = new RuleGroup()
{
Operator = GroupOperator.Any
};
groupToSerialize.RuleGroup.Items.Add(new ObjectChangeRule()
{
TriggerEvents = TriggerEvents.Delete
});
groupToSerialize.Constructors.Add(constructorToSerialize1);
ClassConstructor toSerialize = new ClassConstructor();
toSerialize.ObjectClass = ActiveConfig.DB.GetObjectClass("person");
toSerialize.ExitEvents.Add(new AcmaInternalExitEvent()
{
ID = "testName"
});
toSerialize.Constructors.Add(groupToSerialize);
toSerialize.Constructors.Add(constructorToSerialize2);
toSerialize.ResurrectionParameters = new DBQueryGroup();
toSerialize.ResurrectionParameters.Operator = GroupOperator.Any;
toSerialize.ResurrectionParameters.DBQueries.Add(new DBQueryByValue(ActiveConfig.DB.GetAttribute("sn"), ValueOperator.Equals, new ValueDeclaration("test")));
toSerialize.ResurrectionParameters.DBQueries.Add(new DBQueryByValue(ActiveConfig.DB.GetAttribute("sn"), ValueOperator.Equals, ActiveConfig.DB.GetAttribute("sn")));
UniqueIDCache.ClearIdCache();
ClassConstructor deserialized = UnitTestControl.XmlSerializeRoundTrip <ClassConstructor>(toSerialize);
Assert.AreEqual(groupToSerialize.ExecutionRule, ((AttributeConstructorGroup)deserialized.Constructors[0]).ExecutionRule);
Assert.AreEqual(groupToSerialize.ID, ((AttributeConstructorGroup)deserialized.Constructors[0]).ID);
Assert.AreEqual(groupToSerialize.Description, ((AttributeConstructorGroup)deserialized.Constructors[0]).Description);
Assert.AreEqual(groupToSerialize.RuleGroup.Operator, ((AttributeConstructorGroup)deserialized.Constructors[0]).RuleGroup.Operator);
Assert.AreEqual(((ObjectChangeRule)groupToSerialize.RuleGroup.Items[0]).TriggerEvents, ((ObjectChangeRule)((AttributeConstructorGroup)deserialized.Constructors[0]).RuleGroup.Items[0]).TriggerEvents);
Assert.AreEqual(constructorToSerialize2.Attribute, ((AttributeConstructor)deserialized.Constructors[1]).Attribute);
Assert.AreEqual(constructorToSerialize2.ID, ((AttributeConstructor)deserialized.Constructors[1]).ID);
Assert.AreEqual(constructorToSerialize2.Description, ((AttributeConstructor)deserialized.Constructors[1]).Description);
Assert.AreEqual(constructorToSerialize2.RuleGroup.Operator, ((AttributeConstructor)deserialized.Constructors[1]).RuleGroup.Operator);
Assert.AreEqual(((ObjectChangeRule)constructorToSerialize2.RuleGroup.Items[0]).TriggerEvents, ((ObjectChangeRule)((AttributeConstructor)deserialized.Constructors[1]).RuleGroup.Items[0]).TriggerEvents);
}
protected override void OnApplicationStarting(object sender, EventArgs e)
{
RouteConfig.RegisterRoutes(RouteTable.Routes);
ClassConstructor.SetInstanceFactory(new ProxyInstanceFactory());
}
internal new void setConstructor(ClassConstructor ctor) => base.setConstructor(ctor);
