/// <summary>
/// Attempts to create an instance of an object using the specified constructor.
/// Checks each constructor parameter to make sure that it can be resolved.
/// </summary>
/// <param name="constructor">The constructor that we are attempting to invoke</param>
/// <returns>An object created by the constructor, or null if the dependencies could not be satisfied</returns>
private static object CreateInstanceWithConstructor(System.Reflection.ConstructorInfo constructor)
{
object instance = null;
var parameters = constructor.GetParameters();
var parameterValues = new List <object>();
// Loop through each parameter and see if we can resolve it
foreach (var parameter in parameters)
{
object instanceOfParameter = Get(parameter.ParameterType, CachePolicy.Cached);
if (instanceOfParameter == null)
{
break;
}
parameterValues.Add(instanceOfParameter);
}
// If we were able to resolve each parameter, create the instance
if (parameterValues.Count == parameters.Count())
{
instance = Activator.CreateInstance(constructor.DeclaringType, parameterValues.ToArray());
}
return(instance);
}
public IReadOnlyList <IParameterInfo> GetParameters([NotNull] System.Reflection.ConstructorInfo constructor)
{
var parameters = new List <IParameterInfo>();
var ownerType = constructor.ReflectedType;
ThrowIf.Variable.IsNull(ownerType, nameof(ownerType));
foreach (var parameter in constructor.GetParameters())
{
var parameterType = parameter.ParameterType;
if (parameterType.IsGenericType && parameterType.GetGenericTypeDefinition() == typeof(IReadOnlyList <>))
{
var itemType = parameterType.GetGenericArguments().First();
ThrowIf.Variable.IsNull(itemType, nameof(itemType));
parameters.Add(new ListParameterInfo(ownerType, itemType));
}
else
{
parameters.Add(new SingleParameterInfo(ownerType, parameterType));
}
}
return(parameters);
}
static bool ConstructorMatch(object[] constructorParameters, System.Reflection.ConstructorInfo constructorInfo)
{
var constructorMatch = false;
var parameterInfos = constructorInfo.GetParameters();
var numberOfParameters = parameterInfos.Length;
if (numberOfParameters == constructorParameters.Length)
{
for (int i = 0; i < numberOfParameters; i++)
{
var constructorParameterType = parameterInfos[i].ParameterType;
var givenParameterType = constructorParameters[i].GetType();
if ((givenParameterType == constructorParameterType) || constructorParameterType.IsAssignableFrom(givenParameterType))
{
constructorMatch = true;
}
else
{
constructorMatch = false;
break;
}
}
}
return(constructorMatch);
}
private object Create(Type type)
{
if (implementations.ContainsKey(type))
{
return(implementations[type]);
}
var availableTypes = types[type];
System.Reflection.ConstructorInfo defConstructor = availableTypes.GetConstructors()[0];
System.Reflection.ParameterInfo[] defParams = defConstructor.GetParameters();
var parameters = defParams.Select(param => {
if (implementations.ContainsKey(param.GetType()))
{
return(implementations[param.GetType()]);
}
else
{
return(Create(param.ParameterType));
}
}).ToArray();
return(defConstructor.Invoke(parameters));
}
public static TypeCache[] ForConstructor(System.Reflection.ConstructorInfo constructor)
{
if (cache.ContainsKey(constructor))
{
return(cache[constructor]);
}
var parameters = constructor.GetParameters();
if (parameters == null || parameters.Length == 0)
{
cache[constructor] = new TypeCache[0];
return(cache[constructor]);
}
var result = new TypeCache[parameters.Length];
var ix = 0;
foreach (var par in parameters)
{
result[ix] = TypeCache.ForParameter(par, null);
if (result[ix].RequirePluginContext)
{
throw new Exceptions.InvalidConstructorServiceArgumentException(constructor, par);
}
ix++;
}
cache[constructor] = result;
return(result);
}
static BaseView()
{
var ctors = typeof(TPainter).GetConstructors().Where(c => c.GetParameters().All(param => param.IsOptional));
if (ctors.IsEmpty())
{
throw new ArgumentException($"The supplied generic type parameter for {nameof(TPainter)}, which is {typeof(TPainter)}, does not have any constructors with no parameters nor all optional parameters.");
}
painterCtor = ctors.First();
ctorParams = Enumerable.Repeat(Type.Missing, painterCtor.GetParameters().Length).ToArray();
var painter = (TPainter)painterCtor.Invoke(ctorParams);
var thisType = typeof(BaseView <TPainter, TSource>);
var drawMethodParams = typeof(TPainter).GetMethod(nameof(ICanvasPainter <SKCanvas, TSource, SKColor> .Draw), new[] { typeof(SKCanvas), typeof(TextAlignment), typeof(Thickness), typeof(float), typeof(float) }).GetParameters();
TPainter p(BindableObject b) => ((BaseView <TPainter, TSource>)b).Painter;
SourceProperty = BindableProperty.Create(nameof(Source), typeof(TSource), thisType, painter.Source, BindingMode.TwoWay, null, (b, o, n) => { p(b).Source = (TSource)n; ((BaseView <TPainter, TSource>)b).ErrorMessage = p(b).ErrorMessage; });
DisplayErrorInlineProperty = BindableProperty.Create(nameof(DisplayErrorInline), typeof(bool), thisType, painter.DisplayErrorInline, propertyChanged: (b, o, n) => p(b).DisplayErrorInline = (bool)n);
FontSizeProperty = BindableProperty.Create(nameof(FontSize), typeof(float), thisType, painter.FontSize, propertyChanged: (b, o, n) => p(b).FontSize = (float)n);
ErrorFontSizeProperty = BindableProperty.Create(nameof(ErrorFontSize), typeof(float?), thisType, painter.ErrorFontSize, propertyChanged: (b, o, n) => p(b).ErrorFontSize = (float)n);
TextColorProperty = BindableProperty.Create(nameof(TextColor), typeof(Color), thisType, painter.TextColor.ToFormsColor(), propertyChanged: (b, o, n) => p(b).TextColor = ((Color)n).ToSKColor());
HighlightColorProperty = BindableProperty.Create(nameof(HighlightColor), typeof(Color), thisType, painter.HighlightColor.ToFormsColor(), propertyChanged: (b, o, n) => p(b).HighlightColor = ((Color)n).ToSKColor());
ErrorColorProperty = BindableProperty.Create(nameof(ErrorColor), typeof(Color), thisType, painter.ErrorColor.ToFormsColor(), propertyChanged: (b, o, n) => p(b).ErrorColor = ((Color)n).ToSKColor());
TextAlignmentProperty = BindableProperty.Create(nameof(TextAlignment), typeof(TextAlignment), thisType, drawMethodParams[1].DefaultValue is DBNull ? default(TextAlignment) : drawMethodParams[1].DefaultValue ?? default(TextAlignment));
DisplacementXProperty = BindableProperty.Create(nameof(DisplacementX), typeof(float), thisType, drawMethodParams[3].DefaultValue, BindingMode.TwoWay);
DisplacementYProperty = BindableProperty.Create(nameof(DisplacementY), typeof(float), thisType, drawMethodParams[4].DefaultValue, BindingMode.TwoWay);
MagnificationProperty = BindableProperty.Create(nameof(Magnification), typeof(float), thisType, painter.Magnification, propertyChanged: (b, o, n) => p(b).Magnification = (float)n);
PaintStyleProperty = BindableProperty.Create(nameof(PaintStyle), typeof(PaintStyle), thisType, painter.PaintStyle, propertyChanged: (b, o, n) => p(b).PaintStyle = (PaintStyle)n);
LineStyleProperty = BindableProperty.Create(nameof(LineStyle), typeof(Enumerations.LineStyle), thisType, painter.LineStyle, propertyChanged: (b, o, n) => p(b).LineStyle = (Enumerations.LineStyle)n);
PaddingProperty = BindableProperty.Create(nameof(Padding), typeof(Thickness), thisType, drawMethodParams[2].DefaultValue ?? default(Thickness));
ErrorMessagePropertyKey = BindableProperty.CreateReadOnly(nameof(ErrorMessage), typeof(string), thisType, painter.ErrorMessage, BindingMode.OneWayToSource);
ErrorMessageProperty = ErrorMessagePropertyKey.BindableProperty;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="validatorType">Tipo do validador associado.</param>
/// <param name="cultureInfo"></param>
public ValidatorCreator(Type validatorType, System.Globalization.CultureInfo cultureInfo)
{
validatorType.Require("validatorType").NotNull();
_validatorType = validatorType;
_cultureInfo = cultureInfo;
_constructor = validatorType.GetConstructors().FirstOrDefault();
_parameters = _constructor.GetParameters();
_parameterNames = _parameters.Select(f => char.ToUpper(f.Name[0]) + f.Name.Substring(1)).ToArray();
}
public ConstructorValueData(System.Reflection.ConstructorInfo ctor)
{
serializedType = new MemberData(ctor.DeclaringType);
System.Reflection.ParameterInfo[] param = ctor.GetParameters();
parameters = new ParameterValueData[param.Length];
for (int i = 0; i < param.Length; i++)
{
parameters[i] = new ParameterValueData()
{
name = param[i].Name,
typeData = MemberData.CreateFromType(param[i].ParameterType)
};
}
}
protected void OutputCtorSig(System.Text.StringBuilder sb,
System.Reflection.ConstructorInfo ci)
{
System.Reflection.ParameterInfo[] ps = ci.GetParameters();
int i;
for (i = 0; i < ps.Length; i++)
{
OutputHaskellType(sb, ps[i].ParameterType, i);
sb.Append(" -> ");
}
sb.AppendFormat("IO ({0} ())", ci.DeclaringType.Name);
sb.Append(System.Environment.NewLine);
}
public ConstructorsInfo(System.Reflection.ConstructorInfo constructor)
{
Name = $"Constructor : {Namer.GetName(constructor.DeclaringType)} (";
var parametrs = constructor.GetParameters();
List <string> temp = new List <string>();
foreach (var parameter in parametrs)
{
temp.Add($"{Namer.GetName(parameter.ParameterType)} {parameter.Name} ");
}
Name += $"{string.Join(", ", temp.ToArray())})";
}
public static MethodName FromConstructorInfo(System.Reflection.ConstructorInfo constructor)
{
if (constructor == null)
{
throw new ArgumentNullException("constructor");
}
return(new DefaultMethodName(
TypeName.FromType(constructor.DeclaringType),
constructor.Name,
DefaultMethodName.SetGenericMangle(0),
DefaultMethodName.SetParameters(
ParameterData.ConvertAll(constructor.GetParameters())
)
));
}
public void SetName(System.Reflection.ConstructorInfo constructor)
{
Name = $"Constructor: {constructor.DeclaringType.Name}(";
foreach (var param in constructor.GetParameters())
{
if (param.ParameterType.IsGenericType)
{
Name += $"{PrettyName(param.ParameterType)}";
}
else
{
Name += param.Name;
}
}
Name += ")";
}
public static string GetSignature(this System.Reflection.ConstructorInfo constructor, bool isConstructor = false)
{
string result = "";
var parameters = constructor.GetParameters();
bool first = true;
foreach (var parameter in parameters)
{
if (!first)
{
result += ", ";
}
result += parameter.ParameterType.ToParameterTypeName() + (parameter.ParameterType == constructor.DeclaringType ? "&" : "") + parameter.GetName();
first = false;
}
return(result);
}
public static Method ReverseEngineer(System.Reflection.ConstructorInfo _constructor)
{
Method constructor = new Method();
//decompile method body
if (!_constructor.IsAbstract)
{
Mono.Cecil.AssemblyDefinition ass = Decompiler.LoadAssembly(_constructor.DeclaringType.Module.Assembly.Location);
MethodDefinition md = ass.MainModule.GetType(_constructor.DeclaringType.FullName).Methods.Where(md2 => md2.Name == _constructor.Name).Select(md2 => md2).First();
constructor.MethodCode = Decompiler.GetSourceCode(md);
}
constructor.Type = constructor.ReturnType = ReverseEngineer(_constructor.DeclaringType);
constructor.Name = constructor.Type.Name;
constructor.IsStatic = _constructor.IsStatic;
constructor.IsAbstract = _constructor.IsAbstract;
constructor.IsVirtual = _constructor.IsVirtual;
constructor.Access = _constructor.GetAccessModifier();
foreach (System.Reflection.ParameterInfo _param in _constructor.GetParameters())
{
MethodArgument ma = new MethodArgument();
ma.Method = constructor;
ma.Name = _param.Name;
ma.Type = ReverseEngineer(_param.ParameterType);
DataBase.Current.Set <MethodArgument>().Add(ma);
}
if (_constructor.IsGenericMethod || _constructor.IsGenericMethodDefinition || _constructor.ContainsGenericParameters)
{
foreach (System.Type _genericArg in _constructor.GetGenericArguments())
{
MethodGenericArgument genericArg = new MethodGenericArgument();
genericArg.ArgumentType = ReverseEngineer(_genericArg);
genericArg.Position = _genericArg.GenericParameterPosition;
genericArg.AppliedTo = constructor;
DataBase.Current.Set <MethodGenericArgument>().Add(genericArg);
}
}
DataBase.Current.Set <Method>().Add(constructor);
}
public void Register <T>()
{
if (registeredTypes.HasRegisteredType(typeof(T)))
{
throw new AlreadyRegisteredDependencyException();
}
Type type = typeof(T);
DependencyCollection collection = registeredTypes.GetOrAddCollection(type, true);
System.Reflection.ConstructorInfo constructor = type.GetConstructors()[0];
foreach (System.Reflection.ParameterInfo t in constructor.GetParameters())
{
DependencyCollection typeCollection = registeredTypes.GetOrAddCollection(t.ParameterType, false);
collection.AddNode(t.ParameterType, typeCollection);
}
}
private static MiniCustomAttributeInfo ParseCustomAttribute(byte[] caBlob, Type caReflectedType)
{
uint b = 2; //skip prolog
System.Reflection.BindingFlags visibility = System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public;
List <MiniCustomAttributeFixedArgInfo> fixedArgs = new List <MiniCustomAttributeFixedArgInfo>();
// to support multiple constructors we would need to look up the exact one in the method table
System.Reflection.ConstructorInfo[] ctors = caReflectedType.GetConstructors(visibility);
if (ctors.Length > 1)
{
throw new NotImplementedException();
}
System.Reflection.ConstructorInfo ctor = ctors[0];
foreach (System.Reflection.ParameterInfo parameterInfo in ctor.GetParameters())
{
if (parameterInfo.ParameterType == typeof(String))
{
String fixedParamString = ReadSerString(caBlob, ref b);
fixedArgs.Add(new MiniCustomAttributeFixedArgInfo(fixedParamString));
}
else
{
throw new NotImplementedException();
}
}
byte low = caBlob[b++];
byte high = caBlob[b++];
int numNamed = (high * 0x100) | low;
List <MiniCustomAttributeNamedArgInfo> namedArgs = new List <MiniCustomAttributeNamedArgInfo>();
for (int j = 0; j < numNamed; j++)
{
String propName, value;
ReadNamedArg(caBlob, ref b, out propName, out value);
namedArgs.Add(new MiniCustomAttributeNamedArgInfo(CorElementType.String, propName, value));
}
return(new MiniCustomAttributeInfo(caReflectedType.Name, fixedArgs.ToArray(), namedArgs.ToArray()));
}
public void System_ConstructorInfo_GetParameters_is_wrapped_by_Routine_MethodInfo()
{
constructorInfo = typeof(TestClass_Members).GetConstructor(new[] { typeof(string), typeof(int) });
testing = type.of <TestClass_Members>().GetConstructor(type.of <string>(), type.of <int>());
var expected = constructorInfo.GetParameters();
var actual = testing.GetParameters();
foreach (var parameter in actual)
{
Assert.IsTrue(expected.Any(p => p.ParameterType == parameter.ParameterType.GetActualType()), parameter.Name + " was not expected in parameters of " + constructorInfo);
}
foreach (var parameter in expected)
{
Assert.IsTrue(actual.Any(p => p.ParameterType.GetActualType() == parameter.ParameterType), parameter.Name + " was expected in index parameters of " + constructorInfo);
}
}
public void DisplayConstructorProperties(System.Reflection.ConstructorInfo constructorInfo)
{
ThisConstructor = constructorInfo;//store the constructor information
Label2.Text = ThisConstructor.Name;//display constructor name
//calling convention output to textbox
Label4.Text = "0x" + ThisConstructor.CallingConvention.ToString("x") + " = " + ThisConstructor.CallingConvention.ToString();
//standard attributes to textbox
Label6.Text = "0x" + ThisConstructor.Attributes.ToString("x") + " = " + ThisConstructor.Attributes.ToString();
//constructor parameters
foreach (System.Reflection.ParameterInfo parm in ThisConstructor.GetParameters())
{
ListBox1.Items.Add(parm);
}
//display custom attributes
foreach (object attr in ThisConstructor.GetCustomAttributes(true))
{
ListBox2.Items.Add(attr);
}
}
private static void TestDtoEquality <T>(Expression <Func <T> > constructor)
where T : IEquatable <T>
{
Assert.Equal(ExpressionType.New, constructor.Body.NodeType);
var newExpression = (NewExpression)constructor.Body;
ParameterExpression p1 = Expression.Parameter(typeof(T), "p1");
ParameterExpression p2 = Expression.Parameter(typeof(T), "p2");
Func <T, T, bool> eq = Expression.Lambda <Func <T, T, bool> >(Expression.Equal(p1, p2), p1, p2).Compile();
Func <T, T, bool> neq = Expression.Lambda <Func <T, T, bool> >(Expression.NotEqual(p1, p2), p1, p2).Compile();
System.Reflection.ConstructorInfo ctor = newExpression.Constructor;
System.Collections.ObjectModel.ReadOnlyCollection <Expression> constructorArguments = newExpression.Arguments;
System.Reflection.ParameterInfo[] ctorParams = ctor.GetParameters();
var param = new Expression[ctorParams.Length];
T allValues = constructor.Compile()();
var hs = new HashSet <T>();
for (var i = -1; i < constructorArguments.Count; i++)
{
for (var j = 0; j < constructorArguments.Count; j++)
{
param[j] = i != j
? ExtractActualArg(constructorArguments[j])
: Expression.Default(ctorParams[j].ParameterType);
}
NewExpression nw = Expression.New(ctor, param);
Func <T> lambda = Expression.Lambda <Func <T> >(nw).Compile();
T current = lambda();
hs.Add(current);
if (i == -1)
{
Assert.Equal(allValues, current);
Assert.NotEqual(default, current);
public override void OnClick(Node source, PortCommandData data, Vector2 mousePosition)
{
if (source.owner)
{
Undo.SetCurrentGroupName("Assign to contructor node");
Undo.RegisterFullObjectHierarchyUndo(source.owner, "Assign to contructor node");
}
var member = data.member;
NodeEditorUtility.AddNewNode <MultipurposeNode>(graph.editorData, null, null, new Vector2(source.editorRect.x - 100, source.editorRect.y), (node) => {
var type = filter.GetActualType();
var ctors = type.GetConstructors();
if (ctors != null && ctors.Length > 0)
{
System.Reflection.ConstructorInfo ctor = null;
foreach (var c in ctors)
{
if (ctor == null)
{
ctor = c;
}
else if (ctor.GetParameters().Length < c.GetParameters().Length)
{
ctor = c;
}
}
node.target.target = new MemberData(ctor);
}
else
{
node.target.target = new MemberData(type.Name + ".ctor", type, MemberData.TargetType.Constructor);
}
MemberDataUtility.UpdateMultipurposeMember(node.target);
member.CopyFrom(new MemberData(node, MemberData.TargetType.ValueNode));
});
graph.Refresh();
}
public SerializeTypeInfo(ImmutablePropertyInfo idProperty, ImmutablePropertyInfo[] properties,
Dictionary <string, string> refProperties,
Dictionary <string, PushInfo[]> pushes,
System.Reflection.ConstructorInfo constructor)
{
this.IdProperty = idProperty;
this.Properties = properties;
this.Properties_Wo_Id = properties.Where(property => property != idProperty).ToArray();
this.RefProperties = refProperties;
this.Pushes = pushes;
this.Constructor = constructor;
if (constructor != null)
{
var parameters = constructor.GetParameters();
this.Parameters = parameters
.Select(parameter =>
{
var pName = ToUpper(parameter.Name);
return(new SerializeParameterInfo(pName, parameter.ParameterType,
IdProperty?.Name == pName, refProperties.Find(pName), pushes.Find(pName)));
}
)
.ToArray();
this.ParameterIndexByName =
this.Parameters.Select((p, i) => new { p.Name, i })
.ToDictionary(pair => pair.Name, pair => pair.i);
this.Construct = constructor.ToFunc(parameters);
}
//if (idProperty != null && idProperty.Field != null && idProperty.Field.DeclaringType == typeof(Planet))
//{
// Construct = values => new Planet((long)values[0], (int)values[1], (int)values[2], (int)values[3], (int)values[4], (int)values[5], (int)values[6]);
//}
}
private static Dictionary <string, BaseUtils.ObjectActivator.Activator <JournalEntry> > GetClassActivators()
{
var actlist = new Dictionary <string, BaseUtils.ObjectActivator.Activator <JournalEntry> > ();
var asm = System.Reflection.Assembly.GetExecutingAssembly();
var types = asm.GetTypes().Where(t => typeof(JournalEntry).IsAssignableFrom(t) && !t.IsAbstract).ToList();
foreach (Type type in types)
{
JournalEntryTypeAttribute typeattrib = type.GetCustomAttributes(false).OfType <JournalEntryTypeAttribute>().FirstOrDefault();
if (typeattrib != null)
{
System.Reflection.ConstructorInfo ctor = type.GetConstructors().First(); // this is freaking deep c# here.
var r = ctor.GetParameters();
System.Diagnostics.Debug.Assert(r.Count() == 1);
var r0t = r[0].GetType();
System.Diagnostics.Debug.Assert(r[0].ParameterType.Name == "JObject"); // checking we are picking the correct ctor
actlist[typeattrib.EntryType.ToString()] = BaseUtils.ObjectActivator.GetActivator <JournalEntry>(ctor);
// System.Diagnostics.Debug.WriteLine("Activator " + typeattrib.EntryType.ToString());
}
}
return(actlist);
}
//TODO: Возможно объеденить с compiled_function_node
private compiled_constructor_node(System.Reflection.ConstructorInfo con_info)
{
_con_info=con_info;
compiled_constructors[con_info] = this;
//type_node ret_val=null;
System.Reflection.ParameterInfo[] pinf=_con_info.GetParameters();
parameter_list pal=new parameter_list();
foreach(System.Reflection.ParameterInfo pi in pinf)
{
Type t=null;
type_node par_type=null;
SemanticTree.parameter_type pt=SemanticTree.parameter_type.value;
if (pi.ParameterType.IsByRef)
{
t=pi.ParameterType.GetElementType();
par_type=compiled_type_node.get_type_node(t);
pt=SemanticTree.parameter_type.var;
}
else
{
par_type=compiled_type_node.get_type_node(pi.ParameterType);
}
string name=pi.Name;
compiled_parameter crpar=new compiled_parameter(pi);
crpar.SetParameterType(pt);
pal.AddElement(crpar);
if (pi.IsOptional && pi.DefaultValue != null)
_num_of_default_parameters++;
}
this.return_value_type=compiled_type_node.get_type_node(_con_info.DeclaringType);
this.parameters.AddRange(pal);
}
public string GetCode()
{
System.Reflection.ParameterInfo[] paras;
if (constructor != null)
{
paras = constructor.GetParameters();
}
else
{
paras = new System.Reflection.ParameterInfo[0];
}
string funccode = Properties.Resources.CreateInstance;
funccode = funccode.Replace("[classname]", classname);
funccode = funccode.Replace("[paracount]", paras.Length.ToString());
string pushparas = string.Empty;
for (int i = 0; i < paras.Length; i++)
{
var para = paras[i];
pushparas = pushparas + "\t\t\t\t" + string.Format("para.Add({0});\n", GetAS3RuntimeTypeString(para.ParameterType));
}
funccode = funccode.Replace("[pushparas]", pushparas);
string loadargs = string.Empty;
for (int i = 0; i < paras.Length; i++)
{
var argement = paras[i];
loadargs = loadargs + GetLoadArgementString(argement);
loadargs = loadargs + "\n";
}
funccode = funccode.Replace("[loadargement]", loadargs);
string newobj = "new ";
newobj += NativeCodeCreatorBase.GetTypeFullName(type);
newobj += "(";
for (int i = 0; i < paras.Length; i++)
{
newobj += string.Format("({0})arg{1}", GetTypeFullName(paras[i].ParameterType), i);
if (i < paras.Length - 1)
{
newobj += ",";
}
}
newobj += ")";
funccode = funccode.Replace("[newinstance]", newobj);
return(funccode);
}
private dynamic ParseCollection(Type t, STEPParser.CollectionContext value)
{
// Ex: #25 = IFCDIRECTION((1., 0., 0.));
// IfcDirection takes a List<double> as its input parameters, so we get the type argument - double - and
// do the coercion for all the items.
// Ex: #31 = IFCSITE('3BoQ8L5UXBEOT1kW0PLzej', #2, 'Default Site', 'Description of Default Site', $, #32, $, $, .ELEMENT., (24, 28, 0), (54, 25, 0), 10., $, $);
// IfcSite takes two IfcCompoundPlaneMeasure objects. It seems that some IFC exporters will not specify a type's constructor, they'll just
// specify the arguments as a collection.
Type collectionType;
System.Reflection.ConstructorInfo ctor = null;
var ctorChain = new List <System.Reflection.ConstructorInfo>();
if (t.IsGenericType)
{
collectionType = t.GetGenericArguments()[0];
}
else
{
ctor = GetConstructorForType(t, ref ctorChain);
collectionType = ctor.GetParameters()[0].ParameterType.GetGenericArguments()[0];
}
var result = new List <object>();
foreach (var cv in value.collectionValue())
{
if (cv.Id() != null)
{
result.Add(ParseId(cv.Id().GetText()));
}
else if (cv.AnyString() != null)
{
result.Add(ParseString(collectionType, cv.AnyString().GetText()));
}
else if (cv.StringLiteral() != null)
{
result.Add(ParseString(collectionType, cv.StringLiteral().GetText()));
}
else if (cv.IntegerLiteral() != null)
{
result.Add(ParseInt(collectionType, cv.IntegerLiteral().GetText()));
}
else if (cv.RealLiteral() != null)
{
result.Add(ParseReal(collectionType, cv.RealLiteral().GetText()));
}
else if (cv.constructor() != null)
{
result.Add(ParseConstructor(currId, cv.constructor()));
}
}
if (ctor != null)
{
return(new InstanceData(-1, t, new List <object>()
{
result
}, ctor, ctorChain));
}
return(result);
}
public string GetCode()
{
System.Reflection.ParameterInfo[] paras;
if (constructor != null)
{
paras = constructor.GetParameters();
}
else
{
paras = new System.Reflection.ParameterInfo[0];
}
string funccode = Properties.Resources.CtorFunc;
funccode = funccode.Replace("[classname]", classname);
funccode = funccode.Replace("[paracount]", paras.Length.ToString());
string pushparas = string.Empty;
for (int i = 0; i < paras.Length; i++)
{
var para = paras[i];
pushparas = pushparas + "\t\t\t\t" + string.Format("para.Add({0});\n", GetAS3RuntimeTypeString(para.ParameterType));
}
funccode = funccode.Replace("[pushparas]", pushparas);
string loadargs = string.Empty;
for (int i = 0; i < paras.Length; i++)
{
var argement = paras[i];
loadargs = loadargs + GetLoadArgementString(argement);
loadargs = loadargs + "\n";
}
funccode = funccode.Replace("[loadargement]", loadargs);
string setnativeinstance = string.Empty;
if (type.IsValueType)
{
//((LinkObj<UInt64>)((ASBinCode.rtData.rtObjectBase)thisObj).value).value = (UInt64)value;
setnativeinstance = "((LinkObj<" + GetTypeFullName(type) + ">)((ASBinCode.rtData.rtObjectBase)thisObj).value).value = ";
}
else
{
setnativeinstance = "((LinkObj<object>)((ASBinCode.rtData.rtObjectBase)thisObj).value).value = ";
}
string newobj = "new ";
newobj += NativeCodeCreatorBase.GetTypeFullName(type);
newobj += "(";
for (int i = 0; i < paras.Length; i++)
{
newobj += string.Format("({0})arg{1}", GetTypeFullName(paras[i].ParameterType), i);
if (i < paras.Length - 1)
{
newobj += ",";
}
}
newobj += ");";
setnativeinstance += newobj;
funccode = funccode.Replace("[setnativeinstance]", setnativeinstance);
return(funccode);
}
public UsedRsDataSets(string RdlPath)
{
//all this code is just to call VBExpressionParser.ParseExpression which is a private class
//that method required all sorts of other objects, not many of which we know what in the world they are for
System.Reflection.Assembly assembly = System.Reflection.Assembly.Load("Microsoft.ReportingServices.ProcessingCore");
#if !YUKON
Type type = BIDSHelper.SSIS.ExpressionHighlighterPlugin.GetPrivateType(assembly.GetTypes()[0], "Microsoft.ReportingServices.RdlExpressions.VBExpressionParser");
#else
Type type = BIDSHelper.SSIS.ExpressionHighlighterPlugin.GetPrivateType(assembly.GetTypes()[0], "Microsoft.ReportingServices.ReportProcessing.VBExpressionParser");
#endif
System.Reflection.ConstructorInfo constructor = type.GetConstructors(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)[0];
//create PublishingErrorContext
Type typeErrorContext = BIDSHelper.SSIS.ExpressionHighlighterPlugin.GetPrivateType(assembly.GetTypes()[0], "Microsoft.ReportingServices.ReportProcessing.PublishingErrorContext");
System.Reflection.ConstructorInfo constructorErrorContext = typeErrorContext.GetConstructors(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)[0];
object oErrorContext = constructorErrorContext.Invoke(new object[] { });
//get ExpressionContext type and constructor
#if !YUKON
Type typeExpressionContext = BIDSHelper.SSIS.ExpressionHighlighterPlugin.GetPrivateType(assembly.GetTypes()[0], "Microsoft.ReportingServices.RdlExpressions.ExpressionParser+ExpressionContext");
#else
Type typeExpressionContext = BIDSHelper.SSIS.ExpressionHighlighterPlugin.GetPrivateType(assembly.GetTypes()[0], "Microsoft.ReportingServices.ReportProcessing.ExpressionParser+ExpressionContext");
#endif
System.Reflection.ConstructorInfo constructorExpressionContext = typeExpressionContext.GetConstructors(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)[0];
#if DENALI || SQL2014
//get InternalPublishingContext constructor
Type typeInternalPublishingContext = BIDSHelper.SSIS.ExpressionHighlighterPlugin.GetPrivateType(assembly.GetTypes()[0], "Microsoft.ReportingServices.ReportPublishing.InternalPublishingContext");
System.Reflection.ConstructorInfo constructorInternalPublishingContext = null;
foreach (System.Reflection.ConstructorInfo c in typeInternalPublishingContext.GetConstructors(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public))
{
if (c.GetParameters().Length == 8)
{
constructorInternalPublishingContext = c;
break;
}
}
if (constructorInternalPublishingContext == null)
{
throw new Exception("Couldn't find InternalPublishingContext constructor");
}
#endif
//get PreviewItemContext
System.Reflection.Assembly assemblyReportPreview = System.Reflection.Assembly.Load("Microsoft.ReportingServices.ReportPreview");
Type typeItemContext = BIDSHelper.SSIS.ExpressionHighlighterPlugin.GetPrivateType(assemblyReportPreview.GetTypes()[0], "Microsoft.Reporting.PreviewItemContext");
////////////////////////////////////////
//now run the main code to parse the RDL
XmlDocument doc = new XmlDocument();
doc.Load(RdlPath);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
nsmgr.AddNamespace("rs", doc.DocumentElement.NamespaceURI);
//build list of all DataSets in report
foreach (XmlNode nodeDataSet in doc.SelectNodes("/rs:Report/rs:DataSets/rs:DataSet", nsmgr))
{
RsDataSet ds = new RsDataSet();
ds.ReportName = System.IO.Path.GetFileNameWithoutExtension(RdlPath);
ds.DataSetName = nodeDataSet.Attributes["Name"].Value;
_dataSets.Add(ds.DataSetName, ds);
}
//build list of all objects such as tables that use the dataset
foreach (XmlNode nodeDataSetRef in doc.SelectNodes("//rs:DataSetName", nsmgr))
{
if (_dataSets.ContainsKey(nodeDataSetRef.InnerText))
{
if (!_dataSets[nodeDataSetRef.InnerText].Usages.Contains(GetPathForXmlNode(nodeDataSetRef)))
{
_dataSets[nodeDataSetRef.InnerText].Usages.Add(GetPathForXmlNode(nodeDataSetRef));
}
}
}
//loop through all expressions and parse them
foreach (XmlNode nodeExpression in doc.SelectNodes("//*[starts-with(text(),'=')]", nsmgr))
{
try
{
//see if the surrounding table, for example, has already said it uses a particular DataSet. If so, we won't report it again
string sDataSetUsedByParent = string.Empty;
XmlNode parentNode = nodeExpression.SelectSingleNode("ancestor-or-self::*/rs:DataSetName", nsmgr);
if (parentNode != null)
{
sDataSetUsedByParent = parentNode.InnerText;
}
//create VBExpressionParser
object vbparser = constructor.Invoke(new object[] { oErrorContext });
//create PreviewItemContext
object itemContext = typeItemContext.GetConstructors(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public)[0].Invoke(null);
#if DENALI || SQL2014
//signature of this function call is: public InternalPublishingContext(ICatalogItemContext catalogContext, Microsoft.ReportingServices.ReportProcessing.ReportProcessing.CheckSharedDataSource checkDataSourceCallback, Microsoft.ReportingServices.ReportProcessing.ReportProcessing.ResolveTemporaryDataSource resolveTemporaryDataSourceCallback, DataSourceInfoCollection originalDataSources, IConfiguration configuration, IDataProtection dataProtection, bool traceAtomicScopes, bool isPackagedReportArchive)
object oInternalPublishingContext = constructorInternalPublishingContext.Invoke(new object[] { itemContext, null, null, null, null, null, false, false });
//create ExpressionContext
//signature of this function call is: internal ExpressionContext(ExpressionParser.ExpressionType expressionType, DataType constantType, LocationFlags location, ObjectType objectType, string objectName, string propertyName, string dataSetName, int maxExpressionLength, InternalPublishingContext publishingContext);
object expressionContext = constructorExpressionContext.Invoke(new object[] { ExpressionInfo.ExpressionType.General, 0x12, ExpressionInfo.LocationFlags.None, ExpressionInfo.ObjectType.Field, string.Empty, "Text", "DSN", int.MaxValue, oInternalPublishingContext });
#elif KATMAI
//create ExpressionContext
object expressionContext = null;
if (constructorExpressionContext.GetParameters().Length == 8)
{
//SSRS2008 R2
//signature of this function call is: internal ExpressionContext(ExpressionParser.ExpressionType expressionType, DataType constantType, LocationFlags location, ObjectType objectType, string objectName, string propertyName, string dataSetName, int maxExpressionLength);
expressionContext = constructorExpressionContext.Invoke(new object[] { ExpressionInfo.ExpressionType.General, 0x12, ExpressionInfo.LocationFlags.None, ExpressionInfo.ObjectType.Field, string.Empty, "Text", "DSN", int.MaxValue });
}
else
{
//SSRS2008
//signature of this function call is: internal ExpressionContext(ExpressionParser.ExpressionType expressionType, DataType constantType, LocationFlags location, ObjectType objectType, string objectName, string propertyName, string dataSetName)
expressionContext = constructorExpressionContext.Invoke(new object[] { ExpressionInfo.ExpressionType.General, 0x12, ExpressionInfo.LocationFlags.None, ExpressionInfo.ObjectType.Field, string.Empty, "Text", "DSN" });
}
#elif YUKON
//create ExpressionContext
//signature of this function call is: internal ExpressionContext(ExpressionParser.ExpressionType expressionType, ExpressionParser.ConstantType constantType, LocationFlags location, ObjectType objectType, string objectName, string propertyName, string dataSetName, bool parseExtended)
object expressionContext = constructorExpressionContext.Invoke(new object[] { ExpressionInfo.ExpressionType.General, 0, ExpressionInfo.LocationFlags.None, ExpressionInfo.ObjectType.Field, string.Empty, "Text", "DSN", false });
#endif
//find and invoke ParseExpression method
#if !YUKON
int iParseExpressionParamCount = 3;
object[] arrParseExpressionParams = new object[] { nodeExpression.InnerText, expressionContext, 0 };
#else
int iParseExpressionParamCount = 2;
object[] arrParseExpressionParams = new object[] { nodeExpression.InnerText, expressionContext };
#endif
System.Reflection.MethodInfo methodParseExpression = null;
foreach (System.Reflection.MethodInfo method in type.GetMethods(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance))
{
if (method.Name == "ParseExpression" && method.GetParameters().Length == iParseExpressionParamCount)
{
methodParseExpression = method;
break;
}
}
if (methodParseExpression == null)
{
throw new Exception("Couldn't find VBExpressionParser.ParseExpression method");
}
object expressionInfo = methodParseExpression.Invoke(vbparser, arrParseExpressionParams);
//create a wrapper for the SSRS object then examine it recursively
ExpressionInfo info = new ExpressionInfo(expressionInfo);
RecurseExpressionInfo(info, nodeExpression, sDataSetUsedByParent);
}
catch (Exception ex)
{
throw new Exception("Error while scanning...\r\nReport: " + RdlPath + "\r\nExpression: " + nodeExpression.InnerText, ex);
}
}
}
public string GetCode()
{
System.Reflection.ParameterInfo[] paras;
if (constructor != null)
{
paras = constructor.GetParameters();
}
else
{
paras = new System.Reflection.ParameterInfo[0];
}
string funccode = Properties.Resources.AdapterCtorFunc;
funccode = funccode.Replace("[adapterclass]", adapterclassname);
funccode = funccode.Replace("[classname]", classname);
funccode = funccode.Replace("[paracount]", paras.Length.ToString());
string pushparas = string.Empty;
for (int i = 0; i < paras.Length; i++)
{
var para = paras[i];
pushparas = pushparas + "\t\t\t\t" + string.Format("para.Add({0});\n", GetAS3RuntimeTypeString(para.ParameterType));
}
funccode = funccode.Replace("[pushparas]", pushparas);
string loadargs = string.Empty;
for (int i = 0; i < paras.Length; i++)
{
var argement = paras[i];
loadargs = loadargs + GetLoadArgementString(argement);
loadargs = loadargs + "\n";
}
funccode = funccode.Replace("[loadargement]", loadargs);
string setnativeinstance = string.Empty;
setnativeinstance = "((LinkObj<object>)((ASBinCode.rtData.rtObjectBase)thisObj).value).value = ";
string newobj = "new ";
newobj += adapterclassname;
newobj += "(";
for (int i = 0; i < paras.Length; i++)
{
newobj += string.Format("({0})arg{1}", GetTypeFullName(paras[i].ParameterType), i);
if (i < paras.Length - 1)
{
newobj += ",";
}
}
newobj += ");";
setnativeinstance += newobj;
setnativeinstance += "\n";
setnativeinstance += @"
((ICrossExtendAdapter)((LinkObj<object>)((ASBinCode.rtData.rtObjectBase)thisObj).value).value)
.SetAS3RuntimeEnvironment(stackframe.player, ((ASBinCode.rtData.rtObjectBase)thisObj).value._class, (ASBinCode.rtData.rtObjectBase)thisObj);
";
funccode = funccode.Replace("[setnativeinstance]", setnativeinstance);
return(funccode);
}
public ConstructorInfo(System.Reflection.ConstructorInfo constructorInfo, XElement xmlDocs)
{
Constructor = constructorInfo;
Parameters = constructorInfo.GetParameters().ToList();
}
private IMVCController CreateNewViewContent_Unsynchronized(IProjectItem document)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
// make sure that the item is already contained in the project
if (!Current.Project.ContainsItem(document))
{
Current.Project.AddItemWithThisOrModifiedName(document);
}
var types = Altaxo.Main.Services.ReflectionService.GetNonAbstractSubclassesOf(typeof(AbstractViewContent));
System.Reflection.ConstructorInfo cinfo = null;
object viewContent = null;
foreach (Type type in types)
{
if (null != (cinfo = type.GetConstructor(new Type[] { document.GetType() })))
{
var par = cinfo.GetParameters()[0];
if (par.ParameterType != typeof(object)) // ignore view content which takes the most generic type
{
viewContent = cinfo.Invoke(new object[] { document });
break;
}
}
}
if (null == viewContent)
{
foreach (IProjectItemDisplayBindingDescriptor descriptor in AddInTree.BuildItems <IProjectItemDisplayBindingDescriptor>("/Altaxo/Workbench/ProjectItemDisplayBindings", this, false))
{
if (descriptor.ProjectItemType == document.GetType())
{
if (null != (cinfo = descriptor.ViewContentType.GetConstructor(new Type[] { document.GetType() })))
{
var par = cinfo.GetParameters()[0];
if (par.ParameterType != typeof(object)) // ignore view content which takes the most generic type
{
viewContent = cinfo.Invoke(new object[] { document });
break;
}
}
}
}
}
var controller = viewContent as IMVCController;
if (controller.ViewObject == null)
{
Current.Gui.FindAndAttachControlTo(controller);
}
if (null != Current.Workbench)
{
Current.Workbench.ShowView(viewContent, true);
}
return(controller);
}
public bool Is <T>() where T : class
{
System.Reflection.ConstructorInfo ctor = typeof(T).GetConstructors()[0];
System.Type paramType = ctor.GetParameters()[0].ParameterType;
return(paramType.IsInstanceOfType(this.WrappedObject));
}
public override void ModifyImplementation(CodeNamespace cns, CodeTypeDeclaration ctd, Type type)
{
if (implementation == NullableImplementation.Default || implementation == NullableImplementation.Abstract)
{
ctd.BaseTypes.Add(new CodeTypeReference("INullable"));
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "IsNull";
prop.Type = new CodeTypeReference(typeof(bool));
prop.Attributes = MemberAttributes.Public;
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
ctd.Members.Add(prop);
}
if (implementation != NullableImplementation.Abstract)
{
CodeTypeDeclaration newType = new CodeTypeDeclaration("Null" + ctd.Name);
newType.BaseTypes.Add(new CodeTypeReference(ctd.Name));
cns.Types.Add(newType);
System.Reflection.ConstructorInfo baseCtor = MainClass.GetBaseCtor(type);
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Private;
if (baseCtor != null)
{
foreach (object o in baseCtor.GetParameters())
{
ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(null));
}
}
newType.Members.Add(ctor);
CodeMemberField field = new CodeMemberField(newType.Name, "instance");
field.Attributes = MemberAttributes.Static;
field.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference(newType.Name));
newType.Members.Add(field);
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "Instance";
prop.Type = new CodeTypeReference(newType.Name);
prop.Attributes = MemberAttributes.Public | MemberAttributes.Static;
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("instance")));
newType.Members.Add(prop);
prop = new CodeMemberProperty();
prop.Name = "IsNull";
prop.Type = new CodeTypeReference(typeof(bool));
prop.Attributes = MemberAttributes.Public | MemberAttributes.Override;
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true)));
newType.Members.Add(prop);
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "AcceptVisitor";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Parameters.Add(new CodeParameterDeclarationExpression("IAstVisitor", "visitor"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "data"));
method.ReturnType = new CodeTypeReference(typeof(object));
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
newType.Members.Add(method);
method = new CodeMemberMethod();
method.Name = "ToString";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(string));
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("[" + newType.Name + "]")));
newType.Members.Add(method);
prop = new CodeMemberProperty();
prop.Name = "Null";
prop.Type = new CodeTypeReference(ctd.Name);
prop.Attributes = MemberAttributes.Public | MemberAttributes.Static;
if (implementation == NullableImplementation.Shadow)
{
prop.Attributes |= MemberAttributes.New;
}
CodeExpression ex = new CodeTypeReferenceExpression(newType.Name);
ex = new CodePropertyReferenceExpression(ex, "Instance");
prop.GetStatements.Add(new CodeMethodReturnStatement(ex));
ctd.Members.Add(prop);
}
}