public void SetUp() { _mutableTypeFactoryMock = MockRepository.GenerateStrictMock <IMutableTypeFactory>(); _participantStateMock = MockRepository.GenerateStrictMock <IParticipantState>(); _participantConfigurationID = "participant configuration ID"; _context = new TestableTypeAssemblyContextBase(_mutableTypeFactoryMock, _participantConfigurationID, _participantStateMock); }
public LoadedTypesContext(IEnumerable <LoadedProxy> proxyTypes, IEnumerable <Type> additionalTypes, IParticipantState participantState) { ArgumentUtility.CheckNotNull("proxyTypes", proxyTypes); ArgumentUtility.CheckNotNull("additionalTypes", additionalTypes); ArgumentUtility.CheckNotNull("participantState", participantState); _proxyTypes = proxyTypes.ToList().AsReadOnly(); _additionalTypes = additionalTypes.ToList().AsReadOnly(); _participantState = participantState; }
public void SetUp() { _mutableTypeFactoryMock = MockRepository.GenerateStrictMock <IMutableTypeFactory>(); _complexSerializationEnablerMock = MockRepository.GenerateStrictMock <IComplexSerializationEnabler>(); _participantStateMock = MockRepository.GenerateStrictMock <IParticipantState>(); _requestedType = typeof(RequestedType); _typeID = AssembledTypeIDObjectMother.Create(_requestedType); _assembledType = typeof(AssembledType); }
protected TypeAssemblyContextBase(IMutableTypeFactory mutableTypeFactory, string participantConfigurationID, IParticipantState participantState) { ArgumentUtility.CheckNotNull("mutableTypeFactory", mutableTypeFactory); ArgumentUtility.CheckNotNullOrEmpty("participantConfigurationID", participantConfigurationID); ArgumentUtility.CheckNotNull("participantState", participantState); _mutableTypeFactory = mutableTypeFactory; _participantConfigurationID = participantConfigurationID; _participantState = participantState; }
public static TypeAssemblyContextBase Create( IMutableTypeFactory mutableTypeFactory = null, string participantConfigurationID = "participant configuration ID", IParticipantState state = null) { mutableTypeFactory = mutableTypeFactory ?? new MutableTypeFactory(); state = state ?? new ParticipantState(); return(new TestableTypeAssemblyContextBase(mutableTypeFactory, participantConfigurationID, state)); }
public static ProxyTypeAssemblyContext Create( Type requestedType = null, MutableType proxyType = null, IMutableTypeFactory mutableTypeFactory = null, string participantConfigurationID = "participant configuration ID", IParticipantState state = null) { requestedType = requestedType ?? typeof(UnspecifiedRequestedType); proxyType = proxyType ?? MutableTypeObjectMother.Create(requestedType); mutableTypeFactory = mutableTypeFactory ?? new MutableTypeFactory(); state = state ?? new ParticipantState(); return(new ProxyTypeAssemblyContext(mutableTypeFactory, participantConfigurationID, state, requestedType, proxyType)); }
private IDictionary <ConcreteMixinTypeIdentifier, ConcreteMixinType> GetOrCreateConcreteMixinTypeCache( IParticipantState participantState) { const string key = "ConcreteMixinTypes"; var concreteMixinTypeCache = (Dictionary <ConcreteMixinTypeIdentifier, ConcreteMixinType>)participantState.GetState(key); if (concreteMixinTypeCache == null) { concreteMixinTypeCache = new Dictionary <ConcreteMixinTypeIdentifier, ConcreteMixinType>(); participantState.AddState(key, concreteMixinTypeCache); } return(concreteMixinTypeCache); }
public ProxyTypeAssemblyContext( IMutableTypeFactory mutableTypeFactory, string participantConfigurationID, IParticipantState participantState, Type requestedType, MutableType proxyType) : base(mutableTypeFactory, participantConfigurationID, participantState) { ArgumentUtility.CheckNotNull("requestedType", requestedType); ArgumentUtility.CheckNotNull("proxyType", proxyType); _requestedType = requestedType; _proxyType = proxyType; }
public TypeAssemblyResult AssembleType(AssembledTypeID typeID, IParticipantState participantState, IMutableTypeBatchCodeGenerator codeGenerator) { ArgumentUtility.CheckNotNull("typeID", typeID); ArgumentUtility.CheckNotNull("participantState", participantState); ArgumentUtility.CheckNotNull("codeGenerator", codeGenerator); var requestedType = typeID.RequestedType; CheckRequestedType(requestedType); if (ShortCircuitTypeAssembly(requestedType)) { return(new TypeAssemblyResult(requestedType)); } var typeModificationTracker = _mutableTypeFactory.CreateProxy(requestedType, ProxyKind.AssembledType); var context = new ProxyTypeAssemblyContext( _mutableTypeFactory, _participantConfigurationID, participantState, requestedType, typeModificationTracker.Type); foreach (var participant in _participants) { var idPart = _assembledTypeIdentifierProvider.GetPart(typeID, participant); participant.Participate(idPart, context); } if (!typeModificationTracker.IsModified()) { return(new TypeAssemblyResult(requestedType)); } var generatedTypesContext = GenerateTypes(typeID, context, codeGenerator); context.OnGenerationCompleted(generatedTypesContext); return(new TypeAssemblyResult( generatedTypesContext.GetGeneratedType(context.ProxyType), context.AdditionalTypes.ToDictionary(kvp => kvp.Key, kvp => generatedTypesContext.GetGeneratedType(kvp.Value)))); }
public TypeAssemblyResult AssembleAdditionalType( object additionalTypeID, IParticipantState participantState, IMutableTypeBatchCodeGenerator codeGenerator) { ArgumentUtility.CheckNotNull("additionalTypeID", additionalTypeID); ArgumentUtility.CheckNotNull("participantState", participantState); ArgumentUtility.CheckNotNull("codeGenerator", codeGenerator); var context = new AdditionalTypeAssemblyContext(_mutableTypeFactory, _participantConfigurationID, participantState); var additionalType = _participants.Select(p => p.GetOrCreateAdditionalType(additionalTypeID, context)).FirstOrDefault(t => t != null); if (additionalType == null) { throw new NotSupportedException("No participant provided an additional type for the given identifier."); } var generatedTypesContext = GenerateTypesWithDiagnostics(codeGenerator, context.AdditionalTypes.Values, additionalTypeID.ToString()); context.OnGenerationCompleted(generatedTypesContext); Type resultType; if (additionalType is MutableType) { resultType = generatedTypesContext.GetGeneratedType((MutableType)additionalType); } else { resultType = additionalType; } return(new TypeAssemblyResult( resultType, context.AdditionalTypes.ToDictionary(kvp => kvp.Key, kvp => generatedTypesContext.GetGeneratedType(kvp.Value)))); }
public TestableTypeAssemblyContextBase( IMutableTypeFactory mutableTypeFactory, string participantConfigurationID, IParticipantState participantState) : base(mutableTypeFactory, participantConfigurationID, participantState) { }
public static LoadedTypesContext Create( IEnumerable <LoadedProxy> proxyTypes = null, IEnumerable <Type> additionalTypes = null, IParticipantState state = null) { proxyTypes = proxyTypes ?? new LoadedProxy[0]; additionalTypes = additionalTypes ?? Type.EmptyTypes; state = state ?? new ParticipantState(); return(new LoadedTypesContext(proxyTypes, additionalTypes, state)); }