Example #1
0
        private void MapMethods(IAspectsMap aspectsMap, IEnumerable <IAspectMethodMap> aspectMappedMethods)
        {
            var mappedMethodsEnumerable = from mapped in aspectMappedMethods
                                          from aspectMap in aspectsMap.Where(map => {
                return(map.Method.IsMatchedTo(mapped.ImplementationMember));
            })
                                          .DefaultIfEmpty(AspectMap.Empty)
                                          select new CompositeMethodMap(mapped.ContractType,
                                                                        mapped.ImplementationType,
                                                                        mapped.ContractMember,
                                                                        mapped.ImplementationMember,
                                                                        aspectMap.Aspects);

            mappedMethods = mappedMethodsEnumerable.ToListOf <ICompositeMethodMap>();
        }
Example #2
0
        private void MapProperties(IAspectsMap aspectsMap, IEnumerable <IAspectPropertyMap> aspectMappedProperties)
        {
            var mappedPropertiesList = aspectMappedProperties.ToList();

            var mappedFragmentProperties = MapProperties(aspectsMap, mappedPropertiesList, mapped => mapped.AspectGetProperty, (contractType, implementationType, contractMember, implementationMember, aspectMap) => {
                return(new CompositeGetPropertyMap(contractType, implementationType, contractMember, implementationMember, aspectMap));
            });

            mappedFragmentProperties = mappedFragmentProperties.Concat(MapProperties(aspectsMap, mappedPropertiesList, mapped => mapped.AspectSetProperty, (contractType, implementationType, contractMember, implementationMember, aspectMap) => {
                return(new CompositeSetPropertyMap(contractType, implementationType, contractMember, implementationMember, aspectMap));
            }));

            mappedProperties = mappedFragmentProperties.Where(compositefragment => compositefragment.FragmentMethod.IsNotNull())
                               .ToGroupedDictionary(map => map.Target)
                               .ToList(keyValue => new CompositePropertyMap(keyValue.Value) as ICompositePropertyMap);
        }
Example #3
0
        private void MapProperties(IAspectsMap aspectsMap, IEnumerable <IAspectPropertyMap> aspectMappedProperties)
        {
            var mappedPropertiesEnumerable = from mapped in aspectMappedProperties
                                             from aspectMap in aspectsMap.Where(map => {
                var method = map.Member as PropertyInfo;

                return(method.IsMatchedTo(mapped.ImplementationMember));
            }).DefaultIfEmpty()
                                             select new CompositePropertyMap(mapped.ContractType,
                                                                             mapped.ImplementationType,
                                                                             mapped.ContractMember,
                                                                             mapped.ImplementationMember,
                                                                             aspectMap.Aspects);

            mappedProperties = mappedPropertiesEnumerable.ToListOf <ICompositePropertyMap>();
        }
Example #4
0
        private void MapEvents(IAspectsMap aspectsMap, IEnumerable <IAspectEventMap> aspectMappedEvents)
        {
            var mappedEventsList = aspectMappedEvents.ToList();

            var mappedFragmentEvents = MapEvents(aspectsMap, mappedEventsList, mapped => mapped.AspectAddEvent, (contractType, implementationType, contractMember, implementationMember, aspectMap) => {
                return(new CompositeAddEventMap(contractType, implementationType, contractMember, implementationMember, aspectMap));
            });

            mappedFragmentEvents = mappedFragmentEvents.Concat(MapRaiseEvents(aspectsMap, mappedEventsList));

            mappedFragmentEvents = mappedFragmentEvents.Concat(MapEvents(aspectsMap, mappedEventsList, mapped => mapped.AspectRemoveEvent, (contractType, implementationType, contractMember, implementationMember, aspectMap) => {
                return(new CompositeRemoveEventMap(contractType, implementationType, contractMember, implementationMember, aspectMap));
            }));

            mappedEvents = mappedFragmentEvents.Where(compositefragment => compositefragment.FragmentMethod.IsNotNull())
                           .ToGroupedDictionary(map => map.Target)
                           .ToList(keyValue => new CompositeEventMap(keyValue.Value) as ICompositeEventMap);
        }
Example #5
0
        private void MapEvents(IAspectsMap aspectsMap, IEnumerable<IAspectEventMap> aspectMappedEvents)
        {
            var mappedEventsList = aspectMappedEvents.ToList();

            var mappedFragmentEvents = MapEvents(aspectsMap, mappedEventsList, mapped => mapped.AspectAddEvent, (contractType, implementationType, contractMember, implementationMember, aspectMap) => {
                return new CompositeAddEventMap(contractType, implementationType, contractMember, implementationMember, aspectMap);
            });

            mappedFragmentEvents = mappedFragmentEvents.Concat(MapRaiseEvents(aspectsMap, mappedEventsList));

            mappedFragmentEvents = mappedFragmentEvents.Concat(MapEvents(aspectsMap, mappedEventsList, mapped => mapped.AspectRemoveEvent, (contractType, implementationType, contractMember, implementationMember, aspectMap) => {
                return new CompositeRemoveEventMap(contractType, implementationType, contractMember, implementationMember, aspectMap);
            }));

            mappedEvents = mappedFragmentEvents.Where(compositefragment => compositefragment.FragmentMethod.IsNotNull())
                                               .ToGroupedDictionary(map => map.Target)
                                               .ToList(keyValue => new CompositeEventMap(keyValue.Value) as ICompositeEventMap);
        }
Example #6
0
 public CompositeMemberMapper(IAspectsMap aspectMap, IAspectMemebrsCollection aspectMembersCollection)
 {
     MapEvents(aspectMap, aspectMembersCollection.Events);
     MapMethods(aspectMap, aspectMembersCollection.Methods);
     MapProperties(aspectMap, aspectMembersCollection.Properties);
 }
Example #7
0
 public CompositeMemberMapper(IAspectsMap aspectMap, IAspectMemebrsCollection aspectMembersCollection)
 {
     MapEvents(aspectMap, aspectMembersCollection.Events);
     MapMethods(aspectMap, aspectMembersCollection.Methods);
     MapProperties(aspectMap, aspectMembersCollection.Properties);
 }
Example #8
0
        private void MapProperties(IAspectsMap aspectsMap, IEnumerable<IAspectPropertyMap> aspectMappedProperties)
        {
            var mappedPropertiesList = aspectMappedProperties.ToList();

            var mappedFragmentProperties = MapProperties(aspectsMap, mappedPropertiesList, mapped => mapped.AspectGetProperty, (contractType, implementationType, contractMember, implementationMember, aspectMap) => {
                return new CompositeGetPropertyMap(contractType, implementationType, contractMember, implementationMember, aspectMap);
            });

            mappedFragmentProperties = mappedFragmentProperties.Concat(MapProperties(aspectsMap, mappedPropertiesList, mapped => mapped.AspectSetProperty, (contractType, implementationType, contractMember, implementationMember, aspectMap) => {
                return new CompositeSetPropertyMap(contractType, implementationType, contractMember, implementationMember, aspectMap);
            }));

            mappedProperties = mappedFragmentProperties.Where(compositefragment => compositefragment.FragmentMethod.IsNotNull())
                                                       .ToGroupedDictionary(map => map.Target)
                                                       .ToList(keyValue => new CompositePropertyMap(keyValue.Value) as ICompositePropertyMap);
        }
Example #9
0
        private void MapMethods(IAspectsMap aspectsMap, IEnumerable<IAspectMethodMap> aspectMappedMethods)
        {
            var mappedMethodsEnumerable = from mapped in aspectMappedMethods
                                          from aspectMap in aspectsMap.Where(map => {
                                              return map.Method.IsMatchedTo(mapped.ImplementationMember);
                                          })
                                          .DefaultIfEmpty(AspectMap.Empty)
                                          select new CompositeMethodMap(mapped.ContractType,
                                                                        mapped.ImplementationType,
                                                                        mapped.ContractMember,
                                                                        mapped.ImplementationMember,
                                                                        aspectMap.Aspects);

            mappedMethods = mappedMethodsEnumerable.ToListOf<ICompositeMethodMap>();
        }