public void TestFactory()
{
CompositeBase comp = CompositeFactory.CreateInstance("Policy");
Assert.IsNotNull(comp, "Expected Policy received null!");
var policy = comp as Policy;
Assert.IsNotNull(policy, "Could not cast instance to Policy!");
}
public static IFactory CreateTransformFactory()
{
var factory = new CompositeFactory();
factory.Add(new FunctionAdapter3<IFactory, object>(FromObject));
factory.Add(new FunctionAdapter2<IAngle, string>(IAngleHelper.FromString));
factory.Add(new FunctionAdapter2<ILength, string>(ILengthHelper.FromString));
factory.Add(new FunctionAdapter3<ITranslation, IDictionary>(ITranslationHelper.FromIDictionary));
factory.Add(new FunctionAdapter3<IRotations, IDictionary>(IRotationsHelper.FromIDictionary));
factory.Add(new FunctionAdapter3<IMatrix3D, IDictionary>(IMatrix3DHelper.FromIDictionary));
factory.Add(new FunctionAdapter2<ITypeName, IDictionary>(ITypeNameHelper.FromIDictionary));
factory.Add(new FunctionAdapter3<IColor, string>(IColorHelper.FromString));
factory.Add(new FunctionAdapter3<Material, string>(MaterialHelper.FromString));
factory.Add(new FunctionAdapter3<IPrimaryModel, IDictionary>(IPrimaryModelHelper.FromIDictionary));
factory.Add(new FunctionAdapter3<Model3D, IDictionary>(Model3DHelper.FromIDictionary));
factory.Add(new FunctionAdapter3<Visual3D, IDictionary>(Visual3DHelper.FromIDictionary));
factory.Add(new FunctionAdapter3<double[], IList>(ArrayHelper.DoubleArrayFromIList));
factory.Add(new FunctionAdapter3<double[,], IList>(ArrayHelper.DoubleArray2DFromIList));
factory.Add(new FunctionAdapter3<ILocalToParent, IDictionary>(ILocalToParentHelper.FromIDictionary));
factory.Add(new FunctionAdapter3<ILocalToWorld, IDictionary>(ILocalToWorldHelper.FromIDictionary));
return factory;
}
//public void Add(Composite composite, string compositetag)
//{
// string tag = String.Format(@"SCEC.SCEC_Kuzbass.{0}.EmergencyResponsePlan", compositetag);
// try
// {
// var tags = new List<string>
// {
// "Period.Start",
// "Period.End",
// "NumberOfPosition.AtTheBegining",
// "NumberOfPosition.ForToday",
// "Involved",
// "Changes.AddedChanges",
// "Changes.AddedPosition",
// "Changes.ExtractedPosition"
// };
// var propertyTags = tags.Select(t => String.Format("{0}.{1}", tag, t)).ToList();
// Write(propertyTags[0], composite.PeriodStart.ToString("dd.MM.yyyy"));
// Write(propertyTags[1], composite.PeriodEnd.ToString("dd.MM.yyyy"));
// Write(propertyTags[2], composite.NumberOfPositionAtBegining.ToString(CultureInfo.InvariantCulture));
// Write(propertyTags[3], composite.NumberOfPositionForToday.ToString(CultureInfo.InvariantCulture));
// Write(propertyTags[4], composite.Involved.ToString(CultureInfo.InvariantCulture));
// Write(propertyTags[5], composite.AddedChanges.ToString(CultureInfo.InvariantCulture));
// Write(propertyTags[6], composite.AddedPosition.ToString(CultureInfo.InvariantCulture));
// Write(propertyTags[7], composite.ExtractedPosition.ToString(CultureInfo.InvariantCulture));
// }
// catch
// {
// throw new Exception();
// }
//}
public Composite Get(string tag)
{
var compositeItem = new CompositeFactory().Create(tag);
return(compositeItem);
}
public void SetUp()
{
_factory = new CompositeFactory();
}
public FakeSwitch()
{
Cases = new List <FakeCase <TValue, TResult> >();
Body = new CompositeFactory <TValue, TResult>(this).Evaluate;
}
public void loadSprite(String path)
{ // needs handling if failed. Also needs to be moved out of object class into sprites
CompositeFactory.addGraphicTo(this, new Sprite.Stillframe(path), false);
}
public void addRigidbodyTo()
{
CompositeFactory.addRigidbodyTo(this);
}
public GraphicComposite addGraphicTo(Sprite sprite, boolean isRotateable)
{
return(CompositeFactory.addGraphicTo(this, sprite, isRotateable));
}
public DynamicRotationComposite addDynamicRotationTo()
{
return(CompositeFactory.addDynamicRotationTo(this));
}
public Collider addRotationalColliderTo(AngularComposite angularComposite, Boundary bounds)
{
return(CompositeFactory.addRotationalColliderTo(this, bounds, angularComposite));
}
public Collider addUltralightColliderTo(int radius, BoardAbstract board)
{
return(CompositeFactory.addUltralightColliderTo(this, radius, board));
}
public Collider addColliderTo(Boundary bounds, BoardAbstract board)
{
return(CompositeFactory.addColliderTo(this, bounds, board));
}
public Collider addInitialColliderTo(Boundary bounds)
{ //FIXME AUTOMATICALLY CHECK IF ENTITIY IS ADDED
return(CompositeFactory.addInitialColliderTo(this, bounds));
}
public TranslationComposite addTranslationComposite()
{
return(CompositeFactory.addTranslationTo(this));
}
/* #########################################################################################################################
* CompositeFactory utility methods
* #########################################################################################################################
*/
public AngularComposite addAngularComposite()
{
return(CompositeFactory.addAngularComposite(this));
}
public PublicCompositeTypeGenerationResultImpl(
CompositeModel cModel,
CompositeTypeModel tModel,
EventHandler <AssemblyLoadingArgs> loadingEvt,
IDictionary <Assembly, Assembly> assDic,
CompositeCodeGenerationInfo codeGenerationInfo
)
{
//var orderer = new TypeLoadOrderer( cModel );
var collectionsFactory = cModel.ApplicationModel.CollectionsFactory;
var publicTypes = cModel
.GetAllCompositeTypes()
.Concat(cModel.GetAllFragmentTypes())
//.OrderBy( t => t, orderer )
.Where(t => cModel.ApplicationModel.AffectedAssemblies.Contains(t.GetAssembly()))
.OrderBy(t => t.Equals(cModel.MainCodeGenerationType) ? 0 : 1) // Populate main code generation type first
.Select(t => GetGeneratedPublicType(t, cModel, codeGenerationInfo, loadingEvt, assDic))
.Distinct()
.ToArray();
var mainTypes = publicTypes.Where(iResult => iResult.IsPublicTypeMainCompositeType());
if (!mainTypes.Any() || mainTypes.Skip(1).Any())
{
throw new ArgumentException((mainTypes.Any() ? "Too many" : "Too little") + " generated main types (" + String.Join(", ", mainTypes) + "), exactly one allowed.");
}
var mainType = mainTypes.First();
this._compositeFactory = (CompositeFactory)mainType.GetAssembly().GetType(mainType.Name + codeGenerationInfo.CompositeFactorySuffix, true)
#if WINDOWS_PHONE_APP
.GetAllInstanceConstructors().First()
#else
.GetConstructors()[0]
#endif
.Invoke(null);
var fragmentTypeGenerationResults = tModel.FragmentTypeInfos.Keys
//.OrderBy( t => t, orderer )
.Select(t => Tuple.Create(t, GetParticipantType(t, cModel, codeGenerationInfo, loadingEvt, assDic, codeGenerationInfo.FragmentPrefix, true)))
.Where(t => t.Item2 != null)
.Select(t => (FragmentTypeGenerationResult) new FragmentTypeGenerationResultImpl(t.Item1, t.Item2))
.ToArray();
var concernInvocationGenerationResults = tModel.ConcernInvocationTypeInfos.Keys
//.OrderBy( t => t, orderer )
.Select(t => Tuple.Create(t, GetParticipantType(t, cModel, codeGenerationInfo, loadingEvt, assDic, codeGenerationInfo.ConcernInvocationPrefix)))
.Where(t => t.Item2 != null)
.Select(t => (TypeGenerationResult) new TypeGenerationResultImpl(t.Item2, t.Item1))
.ToArray();
var sideEffectInvocationGenerationResults = tModel.SideEffectInvocationTypeInfos.Keys
//.OrderBy( t => t, orderer )
.Select(t => Tuple.Create(t, GetParticipantType(t, cModel, codeGenerationInfo, loadingEvt, assDic, codeGenerationInfo.SideEffectInvocationPrefix)))
.Where(t => t.Item2 != null)
.Select(t => (TypeGenerationResult) new TypeGenerationResultImpl(t.Item2, t.Item1))
.ToArray();
var privateCompositeGenerationresults = tModel.PrivateCompositeTypeInfos.Keys
//.OrderBy( t => t, orderer )
.Select(t => Tuple.Create(t, GetParticipantType(t, cModel, codeGenerationInfo, loadingEvt, assDic, codeGenerationInfo.PrivateCompositePrefix)))
.Where(t => t.Item2 != null)
.Select(t => (TypeGenerationResult) new TypeGenerationResultImpl(t.Item2, t.Item1))
.ToArray();
var pGArgs = collectionsFactory.NewDictionaryProxy(
tModel.PublicCompositeGenericArguments
.Select((gArg, idx) => Tuple.Create(gArg, idx))
.GroupBy(tuple => tuple.Item1.DeclaringType)
.ToDictionary(grouping => grouping.Key, grouping => collectionsFactory.NewListProxy(grouping.Select(tuple => tuple.Item2).ToList()).CQ));
this._generatedPublicMainType = mainType;
this._maxParamCountForCtors = mainType
#if WINDOWS_PHONE_APP
.GetAllInstanceConstructors().First()
#else
.GetConstructors(BindingFlags.Instance | BindingFlags.Public)[0]
#endif
.GetParameters().Length;
this._generatedPublicTypes = collectionsFactory.NewListProxy(publicTypes.Select(
pt => (GeneratedTypeInfo) new GeneratedTypeInfoImpl(pt))
.ToList()).CQ;
this._publicCompositeGenericArguments = pGArgs.CQ;
this._privateCompositeGenerationResults = collectionsFactory.NewListProxyFromParams(privateCompositeGenerationresults).CQ;
this._fragmentGenerationResults = collectionsFactory.NewListProxyFromParams(fragmentTypeGenerationResults).CQ;
this._concernInvocationGenerationResults = collectionsFactory.NewListProxyFromParams(concernInvocationGenerationResults).CQ;
this._sideEffectInvocationGenerationResults = collectionsFactory.NewListProxyFromParams(sideEffectInvocationGenerationResults).CQ;
// Remember to remove Qi4CS assembly if present
assDic.Remove(ReflectionHelper.QI4CS_ASSEMBLY);
}
