Пример #1
0
        private static Color DeserializeColor(SerializeReader reader)
        {
            int r = 0, g = 0, b = 0, a = 0;

            if (!reader.InOut(SpecialChars.ObjectStart))
            {
                throw new InvalidDataException("Ожидалось начало объекта");
            }
            var colorName = "";

            for (var i = 0; i < 4; ++i)
            {
                if (!reader.InOut(ref colorName))
                {
                    throw new InvalidDataException("Ожидалось имя цветовой компоненты");
                }
                var colorPart = 0;
                if (!reader.InOut(ref colorPart))
                {
                    throw new InvalidDataException("Ожидалось значение цветовой компоненты");
                }
                switch (colorName)
                {
                case "r":
                    r = colorPart;
                    break;

                case "g":
                    g = colorPart;
                    break;

                case "b":
                    b = colorPart;
                    break;

                case "a":
                    a = colorPart;
                    break;

                default:
                    throw new InvalidDataException("Некорректно задан цвет. Отсутствует одна из компонент");
                }
                if (i != 3)
                {
                    if (!reader.InOut(SpecialChars.Delimiter))
                    {
                        throw new InvalidDataException("Отсутствует разделитель между компонентами цвета");
                    }
                }
            }
            if (!reader.InOut(SpecialChars.ObjectEnd))
            {
                throw new InvalidDataException("Не закрыта секция цвета");
            }
            return(new Color(r, g, b, a));
        }
Пример #2
0
        private static ColorDescription DeserializeColorDescription(SerializeReader reader)
        {
            var comment = "";
            var level   = 0;
            var color   = new Color(0, 0, 0);
            var param   = "";

            if (!reader.InOut(SpecialChars.ObjectStart))
            {
                throw new InvalidDataException("Ожидалось начало секции");
            }
            for (int i = 0; i < 3; ++i)
            {
                if (!reader.InOut(ref param))
                {
                    throw new InvalidDataException("Не обнаружено имя параметра");
                }
                switch (param)
                {
                case "comment":
                    if (!reader.InOut(ref comment))
                    {
                        throw new InvalidDataException("Невозможно прочитать комментарий");
                    }
                    break;

                case "level":
                    if (!reader.InOut(ref level))
                    {
                        throw new InvalidDataException("Невозможно прочитать значение уровня цвета");
                    }
                    break;

                case "color":
                    color = DeserializeColor(reader);
                    break;

                default:
                    throw new InvalidDataException("Неожиданное значение в объекте описания цвета");
                }
                if (i != 2)
                {
                    if (!reader.InOut(SpecialChars.Delimiter))
                    {
                        throw new InvalidDataException("Ожидался разделитель");
                    }
                }
            }
            if (!reader.InOut(SpecialChars.ObjectEnd))
            {
                throw new InvalidDataException("Ожидался конец объекта");
            }
            return(new ColorDescription {
                Color = color, Comment = comment, Level = level
            });
        }
Пример #3
0
        /// <summary>
        /// Пытается получить объект указанного типа из указанного десериализатора
        /// </summary>
        /// <param name="t">Тип объекта, который нужно получить</param>
        /// <param name="reader">Десериализатор</param>
        /// <param name="settingsForTypeCheck">Если тип объекта -- Settings, то необходимо
        /// указать, откуда брать информацию о типах. Значение по-умолчанию null.</param>
        /// <returns>
        /// Объект указанного типа, если удалось его получить
        /// </returns>
        /// <exception cref="InvalidDataException">Объект указанного типа получить не
        /// удалось в силу различных причин</exception>
        private dynamic DeserializeObject(Type t, SerializeReader reader, Settings settingsForTypeCheck = null)
        {
            if (t == typeof(int))
            {
                var i = 0;
                if (reader.InOut(ref i))
                {
                    return(i);
                }
                throw new InvalidDataException("Не удалось прочитать число Int32");
            }
            if (t == typeof(double))
            {
                var d = 0d;
                if (reader.InOut(ref d))
                {
                    return(d);
                }
                throw new InvalidDataException("Не удалось прочитать число типа Double");
            }
            if (t == typeof(float))
            {
                var f = 0f;
                if (reader.InOut(ref f))
                {
                    return(f);
                }
                throw new InvalidDataException("Не удалось прочитать число типа Single");
            }
            if (t == typeof(string))
            {
                var s = "";
                if (reader.InOut(ref s))
                {
                    return(s);
                }
                throw new InvalidDataException("Не удалось прочитать строку");
            }
            if (t == typeof(bool))
            {
                var b = false;
                if (reader.InOut(ref b))
                {
                    return(b);
                }
                throw new InvalidDataException("Не удалось прочитать значение типа bool");
            }

            if (t.IsArray)
            {
                if (!reader.InOut(SpecialChars.ArrayStart))
                {
                    throw new InvalidDataException("Ожидался признак начала массива");
                }
                var arr = new ArrayList();
                while (reader.TestCurrentSpecialChar() != SpecialChars.ArrayEnd)
                {
                    arr.Add(DeserializeObject(t.GetElementType(), reader));
                    if (!reader.InOut(SpecialChars.Delimiter, false))
                    {
                        break;
                    }
                    reader.InOut(SpecialChars.Delimiter);
                }
                if (!reader.InOut(SpecialChars.ArrayEnd))
                {
                    throw new InvalidDataException("Ожидался конец массива либо разделитель");
                }
                var res = Array.CreateInstance(t.GetElementType(), arr.Count);
                arr.CopyTo(res);
                return(res);
            }

            if (t == typeof(Color))
            {
                return(DeserializeColor(reader));
            }
            if (t == typeof(ColorDescription))
            {
                return(DeserializeColorDescription(reader));
            }
            if (t == typeof(Settings))
            {
                var settings = new Settings();
                if (!reader.InOut(SpecialChars.ObjectStart))
                {
                    throw new InvalidDataException("Ожидался маркер начала объекта");
                }

                while (reader.TestCurrentSpecialChar() != SpecialChars.ObjectEnd)
                {
                    var name = "";
                    if (!reader.InOut(ref name))
                    {
                        throw new InvalidDataException("Ожидалось имя параметра");
                    }
                    var type = typeof(string);
                    if (settingsForTypeCheck.Exists(name))
                    {
                        type = settingsForTypeCheck.GetTypeByName(name);
                    }
                    settings[name] = DeserializeObject(type, reader,
                                                       (Settings)(type == typeof(Settings) ? settingsForTypeCheck[name] : null));
                    if (!reader.InOut(SpecialChars.Delimiter, false))
                    {
                        break;
                    }
                    reader.InOut(SpecialChars.Delimiter);
                }

                if (!reader.InOut(SpecialChars.ObjectEnd))
                {
                    throw new InvalidDataException("Ожидался маркер конца объекта");
                }
                return(settings);
            }
            return(null);
        }