private IReflectionValueDescriptor CreateDescriptor(IReflectionStateMember member, object value,
                                                            Type runtimeMemberType)
        {
            Type descriptorType;

            Type memberType = member.MemberType;

            if (memberType.IsEnum)
            {
                descriptorType = typeof(ReflectionEnumValueDescriptor <, ,>)
                                 .MakeGenericType(memberType, runtimeMemberType,
                                                  memberType.GetEnumUnderlyingType());
            }
            else
            {
                descriptorType = typeof(ReflectionValueDescriptor <,>)
                                 .MakeGenericType(memberType, runtimeMemberType);
            }

            IReflectionValueDescriptor descriptor =
                (IReflectionValueDescriptor)Activator.CreateInstance
                    (descriptorType,
                    _processor, _stateMemberProvider, member, value);

            return(descriptor);
        }
 public ReflectionValueDescriptor(object processor, IStateMemberProvider stateMemberProvider,
                                  IReflectionStateMember stateMember, object owner)
 {
     _stateMemberProvider = stateMemberProvider;
     _stateMember         = stateMember;
     _owner     = owner;
     _processor = processor;
 }
        private void VisitMember(IReflectionStateMember member,
                                 object owner,
                                 Type runtimeMemberType,
                                 bool skipSpecialMethod,
                                 bool routed)
        {
            IReflectionValueDescriptor descriptor =
                CreateDescriptor(member, owner, runtimeMemberType);

            CallProcess(descriptor, skipSpecialMethod, routed);
        }
        private Type GetRuntimeMemberType(IReflectionStateMember member, object value)
        {
            Type memberType = member.MemberType;

            object memberValue = member.GetValue(value);

            var result =
                memberValue != null?memberValue.GetType() : memberType;

            return(result);
        }
        private void ClimbArray(Array array)
        {
            int dimension = array.Rank;

            IEnumerable <IEnumerable <int> > indexesSets =
                Enumerable.Range(0, dimension)
                .Select(index => Enumerable.Range(array.GetLowerBound(index),
                                                  array.GetLength(index)));

            IEnumerable <IEnumerable <int> > allIndexes =
                Combinatorics.CartesianProduct(indexesSets.Reverse());

            foreach (IEnumerable <int> indexSet in allIndexes)
            {
                int[] indices = indexSet.Reverse().ToArray();

                IReflectionStateMember decorated = (IReflectionStateMember)
                                                   _stateMemberProvider.ProvideArrayMember(array.GetType(), indices);

                Type runtimeMemberType = GetRuntimeMemberType(decorated, array);

                VisitMember(decorated, array, runtimeMemberType, false, false);
            }
        }
 public EnumUnderlyingValueStateMember(IReflectionStateMember stateMember)
 {
     _stateMember    = stateMember;
     _enumType       = _stateMember.MemberType;
     _underlyingType = _enumType.GetEnumUnderlyingType();
 }
 public ReflectionEnumValueDescriptor(object processor, IStateMemberProvider stateMemberProvider, IReflectionStateMember stateMember, object owner) :
     base(processor, stateMemberProvider, stateMember, owner)
 {
     _underlyingValueStateMember = new EnumUnderlyingValueStateMember(stateMember);
 }
 public MyCustomStateMember(IReflectionStateMember underlying, Type memberType)
 {
     _underlying = underlying;
     _memberType = memberType;
 }