public override IList Deserialize()

in sdk/Transform/GetBucketLifecycleDeserializer.cs [23:135]
103 lines of code
19 McCabe index (conditional complexity)

        public override IList<LifecycleRule> Deserialize(ServiceResponse xmlStream)
        {
            var lifecycleConfig = ContentDeserializer.Deserialize(xmlStream.Content);
            var rules = new List<LifecycleRule>();
            foreach (var lcc in lifecycleConfig.LifecycleRules)
            {
                var rule = new LifecycleRule
                {
                    ID = lcc.ID, 
                    Prefix = lcc.Prefix
                };

                RuleStatus status;
                if (TryParseEnum(lcc.Status, out status))
                    rule.Status = status;
                else
                    throw new InvalidEnumArgumentException(@"Unsupported rule status " + lcc.Status);

                if (lcc.Expiration != null) { 
                    if (lcc.Expiration.IsSetDays())
                        rule.ExpriationDays = lcc.Expiration.Days;
                    else if (lcc.Expiration.IsSetDate())
                        rule.ExpirationTime = DateTime.Parse(lcc.Expiration.Date).ToUniversalTime();
                    else if (!String.IsNullOrEmpty(lcc.Expiration.CreatedBeforeDate))
                        rule.CreatedBeforeDate = DateTime.Parse(lcc.Expiration.CreatedBeforeDate).ToUniversalTime();
                    else if (lcc.Expiration.IsSetExpiredObjectDeleteMarker())
                    {
                        rule.ExpiredObjectDeleteMarker = lcc.Expiration.ExpiredObjectDeleteMarker;
                    }
                }

                if (lcc.AbortMultipartUpload != null)
                {
                    rule.AbortMultipartUpload = new LifecycleRule.LifeCycleExpiration();
                    ConvertExpiration(lcc.AbortMultipartUpload, rule.AbortMultipartUpload);
                }

                if (lcc.Transition != null)
                {
                    rule.Transitions = new LifecycleRule.LifeCycleTransition[lcc.Transition.Length];
                    for (int i = 0; i < rule.Transitions.Length; i++)
                    {
                        rule.Transitions[i] = new LifecycleRule.LifeCycleTransition();
                        ConvertTransition(lcc.Transition[i], rule.Transitions[i]);
                    }
                }

                if (lcc.Tags != null)
                {
                    rule.Tags = new Tag[lcc.Tags.Length];
                    for (int i = 0; i < rule.Tags.Length; i++)
                    {
                        rule.Tags[i] = new Tag()
                        {
                            Key = lcc.Tags[i].Key,
                            Value = lcc.Tags[i].Value
                        };
                    }
                }

                if (lcc.NoncurrentVersionExpiration != null)
                {
                    rule.NoncurrentVersionExpiration = new LifecycleRule.LifeCycleNoncurrentVersionExpiration
                    {
                        NoncurrentDays= lcc.NoncurrentVersionExpiration.NoncurrentDays
                    };
                }

                if (lcc.NoncurrentVersionTransition != null)
                {
                    rule.NoncurrentVersionTransitions = new LifecycleRule.LifeCycleNoncurrentVersionTransition[lcc.NoncurrentVersionTransition.Length];
                    for (int i = 0; i < rule.NoncurrentVersionTransitions.Length; i++)
                    {
                        rule.NoncurrentVersionTransitions[i] = new LifecycleRule.LifeCycleNoncurrentVersionTransition()
                        {
                            NoncurrentDays = lcc.NoncurrentVersionTransition[i].NoncurrentDays,
                            StorageClass = lcc.NoncurrentVersionTransition[i].StorageClass,
                            IsAccessTime = lcc.NoncurrentVersionTransition[i].IsAccessTime,
                            ReturnToStdWhenVisit = lcc.NoncurrentVersionTransition[i].ReturnToStdWhenVisit,
                            AllowSmallFile = lcc.NoncurrentVersionTransition[i].AllowSmallFile
                        };
                    }
                }

                if (lcc.Filter != null)
                {
                    rule.Filter = new LifecycleRule.LifeCycleFilter()
                    {
                        ObjectSizeGreaterThan = lcc.Filter.ObjectSizeGreaterThan,
                        ObjectSizeLessThan = lcc.Filter.ObjectSizeLessThan
                    };
                    if (lcc.Filter.Not != null)
                    {
                        rule.Filter.Not = new LifecycleRule.LifeCycleNot()
                        {
                            Prefix = lcc.Filter.Not.Prefix
                        };

                        if (lcc.Filter.Not.Tag != null)
                        {
                            rule.Filter.Not.Tag = new Tag()
                            {
                                Key = lcc.Filter.Not.Tag.Key,
                                Value = lcc.Filter.Not.Tag.Value
                            };
                        }
                    }
                }

                rules.Add(rule);
            }
            return rules;            
        }