SubscriptionPropertiesBuilder.cs

using comm.datalayer;
using Google.FlatBuffers;
using System.Collections.Generic;
 
namespace Datalayer
{
    public class SubscriptionPropertiesBuilder
    {
        private readonly FlatBufferBuilder _builder;
 
        private readonly List<Offset<Property>> _rules;
 
 
 
#if NETSTANDARD2_0
        private uint _errorIntervalMillis = Subscription.DefaultErrorIntervalMillis;
#else
        private uint _errorIntervalMillis = ISubscription.DefaultErrorIntervalMillis;
#endif
 
        private StringOffset _idOffset;
 
#if NETSTANDARD2_0
        private uint _keepAliveIntervalMillis = Subscription.DefaultKeepaliveIntervalMillis;
#else
        private uint _keepAliveIntervalMillis = ISubscription.DefaultKeepaliveIntervalMillis;
#endif
 
#if NETSTANDARD2_0
        private uint _publishIntervalMillis = Subscription.DefaultPublishIntervalMillis;
#else
        private uint _publishIntervalMillis = ISubscription.DefaultPublishIntervalMillis;
#endif
 
        public SubscriptionPropertiesBuilder(string id)
        {
            _builder = new FlatBufferBuilder(Variant.DefaultFlatbuffersInitialSize);
            _rules = new List<Offset<Property>>();
 
            // Set mandatory fields in constructor
            SetId(id);
        }
 
        private void SetId(string id)
        {
            _idOffset = _builder.CreateString(id);
        }
 
        public SubscriptionPropertiesBuilder SetKeepAliveIntervalMillis(uint keepAliveIntervalMillis)
        {
            _keepAliveIntervalMillis = keepAliveIntervalMillis;
            return this;
        }
 
        public SubscriptionPropertiesBuilder SetPublishIntervalMillis(uint publishIntervalMillis)
        {
            _publishIntervalMillis = publishIntervalMillis;
            return this;
        }
 
        public SubscriptionPropertiesBuilder SetErrorIntervalMillis(uint errorIntervalMillis)
        {
            _errorIntervalMillis = errorIntervalMillis;
            return this;
        }
 
        public SubscriptionPropertiesBuilder SetSamplingIntervalMillis(ulong samplingIntervalMillis)
        {
            var samplingIntervalMicros = samplingIntervalMillis * 1000;
            var sampling = Sampling.CreateSampling(_builder, samplingIntervalMicros);
            var samplingProperty = Property.CreateProperty(_builder, Properties.Sampling, sampling.Value);
            _rules.Add(samplingProperty);
            return this;
        }
 
        public SubscriptionPropertiesBuilder SetSamplingIntervalMicros(ulong samplingIntervalMicros)
        {
            var sampling = Sampling.CreateSampling(_builder, samplingIntervalMicros);
            var samplingProperty = Property.CreateProperty(_builder, Properties.Sampling, sampling.Value);
            _rules.Add(samplingProperty);
            return this;
        }
 
        public SubscriptionPropertiesBuilder SetDataChangeFilter(float deadbandValue)
        {
            var dataChangeFilter = DataChangeFilter.CreateDataChangeFilter(_builder, deadbandValue);
            var dataChangeFilterProperty =
                Property.CreateProperty(_builder, Properties.DataChangeFilter, dataChangeFilter.Value);
            _rules.Add(dataChangeFilterProperty);
            return this;
        }
 
        public SubscriptionPropertiesBuilder SetChangeEvents(DataChangeTrigger dataChangeTrigger,
            bool browselistChange = false, bool metadataChange = false)
        {
            var changeEvents =
                ChangeEvents.CreateChangeEvents(_builder, dataChangeTrigger, browselistChange, metadataChange);
            var changeEventsProperty = Property.CreateProperty(_builder, Properties.ChangeEvents, changeEvents.Value);
            _rules.Add(changeEventsProperty);
            return this;
        }
 
        public SubscriptionPropertiesBuilder SetQueueing(uint queueSize, QueueBehaviour queueBehaviour)
        {
            var queuing = Queueing.CreateQueueing(_builder, queueSize, queueBehaviour);
            var queuingProperty = Property.CreateProperty(_builder, Properties.Queueing, queuing.Value);
            _rules.Add(queuingProperty);
            return this;
        }
 
        public SubscriptionPropertiesBuilder SetCounting(bool countSubscriptions)
        {
            var counting = Counting.CreateCounting(_builder, countSubscriptions);
            var countingProperty = Property.CreateProperty(_builder, Properties.Counting, counting.Value);
            _rules.Add(countingProperty);
            return this;
        }
 
        public Variant Build()
        {
            var rulesOffset = _rules.Count == 0
                ? new VectorOffset(0)
                : SubscriptionProperties.CreateRulesVector(_builder, _rules.ToArray());
            var propertiesOffset = SubscriptionProperties.CreateSubscriptionProperties(_builder,
                _idOffset,
                _keepAliveIntervalMillis,
                _publishIntervalMillis,
                rulesOffset,
                _errorIntervalMillis);
 
            SubscriptionProperties.FinishSubscriptionPropertiesBuffer(_builder, propertiesOffset);
            return new Variant(_builder);
        }
    }
}