public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var o           = JObject.Load(reader);
            var ps          = o.Properties().ToDictionary(p => p.Name, p => p.Value);
            var aggregation = new MovingAverageAggregation
            {
                Format    = GetOrDefault <string>("format", ps),
                GapPolicy = GetGapPolicy(ps),
                Minimize  = GetOrDefault <bool?>("minimize", ps),
                Predict   = GetOrDefault <int?>("predict", ps),
                Window    = GetOrDefault <int?>("window", ps),
                Model     = GetModel(ps)
            };

#if DOTNETCORE
            JToken value;
            if (ps.TryGetValue("buckets_path", out value) && value != null)
            {
                aggregation.BucketsPath = new SingleBucketsPath((string)value);
            }
            else
            {
                aggregation.BucketsPath = default(SingleBucketsPath);
            }
#else
            aggregation.BucketsPath = GetOrDefault <SingleBucketsPath>("buckets_path", ps);
#endif
            return(aggregation);
        }
Exemple #2
0
        public IMovingAverageAggregation Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
        {
            if (reader.GetCurrentJsonToken() != JsonToken.BeginObject)
            {
                return(null);
            }

            var count                        = 0;
            var aggregation                  = new MovingAverageAggregation();
            ArraySegment <byte> model        = default;
            ArraySegment <byte> modelSegment = default;

            while (reader.ReadIsInObject(ref count))
            {
                var propertyName = reader.ReadPropertyNameSegmentRaw();
                if (AutomataDictionary.TryGetValue(propertyName, out var value))
                {
                    switch (value)
                    {
                    case 0:
                        aggregation.Format = reader.ReadString();
                        break;

                    case 1:
                        aggregation.GapPolicy = formatterResolver.GetFormatter <GapPolicy?>()
                                                .Deserialize(ref reader, formatterResolver);
                        break;

                    case 2:
                        aggregation.Minimize = reader.ReadBoolean();
                        break;

                    case 3:
                        aggregation.Predict = reader.ReadInt32();
                        break;

                    case 4:
                        aggregation.Window = reader.ReadInt32();
                        break;

                    case 5:
                        modelSegment = reader.ReadNextBlockSegment();
                        break;

                    case 6:
                        model = reader.ReadStringSegmentUnsafe();
                        break;

                    case 7:
                        var path = reader.ReadString();
                        if (!string.IsNullOrEmpty(path))
                        {
                            aggregation.BucketsPath = new SingleBucketsPath(path);
                        }
                        break;
                    }
                }
            }

            if (model != default && ModelDictionary.TryGetValue(model, out var modelValue))
            {
                var modelReader = new JsonReader(modelSegment.Array, modelSegment.Offset);
                switch (modelValue)
                {
                case 0:
                    aggregation.Model = formatterResolver.GetFormatter <LinearModel>()
                                        .Deserialize(ref modelReader, formatterResolver);
                    break;

                case 1:
                    aggregation.Model = formatterResolver.GetFormatter <SimpleModel>()
                                        .Deserialize(ref modelReader, formatterResolver);
                    break;

                case 2:
                    aggregation.Model = formatterResolver.GetFormatter <EwmaModel>()
                                        .Deserialize(ref modelReader, formatterResolver);
                    break;

                case 3:
                    aggregation.Model = formatterResolver.GetFormatter <HoltLinearModel>()
                                        .Deserialize(ref modelReader, formatterResolver);
                    break;

                case 4:
                    aggregation.Model = formatterResolver.GetFormatter <HoltWintersModel>()
                                        .Deserialize(ref modelReader, formatterResolver);
                    break;
                }
            }

            return(aggregation);
        }