private static Dictionary<MediaRangeInfo, List<Slot>> ParseMediaRangeInfo(XElement source, IParseResult result)
        {
            Dictionary<MediaRangeInfo,List<Slot>> ranges = new Dictionary<MediaRangeInfo, List<Slot>>();

            var rangeElements = source.Elements("MediaRange");

            if (rangeElements.Any())
            {
                MediaRangeInfo range;
                ParseResult error;
                string val;
                XElement node;

                foreach (var rangeElement in rangeElements)
                {
                    range = new MediaRangeInfo();
                    error = new ParseResult(rangeElement.Name.LocalName);

                    TryExecute(
                        () =>
                        {
                            val = ParseAttribute<string>(rangeElement, "MediaType");
                            Validate(() => Validator.HasValue(val));
                            range.MediaType = ParseEnum<MediaType>(val);
                        }, "MediaType", error);

                    TryExecute(
                        () =>
                        {
                            val = ParseAttribute<string>(rangeElement, "MediaManufacturer");
                            Validate(() => Validator.HasValue(val));
                            range.Manufacturer = val;
                        }, "MediaManufacturer", error);

                    TryExecute(
                        () =>
                        {
                            val = ParseAttribute<string>(rangeElement, "MediaRangeName");
                            Validate(() => Validator.HasValue(val));
                            range.Name = val;
                        }, "MediaRangeName", error);

                    if (error.FieldsWithError.Count == 0)
                    {
                        ranges[range] = ParseSlot(rangeElement, range, error);
                    }

                    if (error.HaveError) result.ErrorList.Add(error);
                }
            }

            return ranges;
        }
        /// <summary>
        /// Some slot are inside MediaRange tag. Parent tag mapped in property
        /// E:\Workspace\Mike\FixtureLibrary\source\data\fixtures\clay_paky\goldenscan_3_8_ch\goldenscan_3_8_ch.xml
        /// </summary>
        /// <param name="source"></param>
        /// <param name="parentMediaRange"></param>
        /// <returns></returns>
        private static List<Slot> ParseSlot(XElement source, MediaRangeInfo parentMediaRange, IParseResult result)
        {
            List<Slot> slots = new List<Slot>();

            var slotElements = source.Elements("Slot");

            if (slotElements.Any())
            {
                foreach (var slotElement in slotElements)
                {
                    var slot = new Slot();
                    slot.MediaRangeInfo = parentMediaRange;

                    ParseResult error = new ParseResult(slotElement.Name.LocalName);
                    string val;

                    TryExecute(
                        () =>
                        {
                            val = ParseAttribute<string>(slotElement, "SlotNumber");
                            Validate(() => Validator.HasValue(val));
                            slot.Number = ParseValue<int>(val);
                        }, "SlotNumber", error);

                    TryExecute(
                        () =>
                        {
                            val = ParseAttribute<string>(slotElement, "LocalName");
                            Validate(() => Validator.HasValue(val));
                            slot.Name = val;
                        }, "LocalName", error);

                    TryExecute(
                        () =>
                        {
                            val = ParseAttribute<string>(slotElement, "MediaName");
                            Validate(() => Validator.HasValue(val));
                            slot.MediaName = val;
                        }, "MediaName", error);

                    if (error.FieldsWithError.Count == 0)
                        slots.Add(slot);

                    if (error.HaveError) result.ErrorList.Add(error);
                }
            }

            return slots;
        }