MetadataBuilder.cs

using comm.datalayer;
using Google.FlatBuffers;
using System.Collections.Generic;
 
namespace Datalayer
{
    public class MetadataBuilder
    {
        private readonly FlatBufferBuilder _builder;
 
        private readonly List<Offset<Reference>> _references;
 
        private readonly List<Offset<Extension>> _extensions;
 
        private readonly List<Offset<LocaleText>> _displayNames;
 
        private readonly List<Offset<LocaleText>> _descriptions;
 
        private StringOffset _descriptionOffset;
 
        private StringOffset _descriptionUrlOffset;
 
        private NodeClass _nodeClass = NodeClass.Node;
 
        private StringOffset _displayNameOffset;
 
        private DisplayFormat _displayFormat = DisplayFormat.Auto;
 
        private StringOffset _unitOffset;
 
        private Offset<AllowedOperations> _allowedOperationsOffset;
 
        public MetadataBuilder(AllowedOperationFlags allowedOperationFlags, string description = "",
            string descriptionUrl = "")
        {
            _builder = new FlatBufferBuilder(Variant.DefaultFlatbuffersInitialSize);
            _references = new List<Offset<Reference>>();
            _extensions = new List<Offset<Extension>>();
            _displayNames = new List<Offset<LocaleText>>();
            _descriptions = new List<Offset<LocaleText>>();
 
            // Set mandatory fields in constructor
            _allowedOperationsOffset = AllowedOperations.CreateAllowedOperations(_builder,
                (allowedOperationFlags & AllowedOperationFlags.Read) == AllowedOperationFlags.Read,
                (allowedOperationFlags & AllowedOperationFlags.Write) == AllowedOperationFlags.Write,
                (allowedOperationFlags & AllowedOperationFlags.Create) == AllowedOperationFlags.Create,
                (allowedOperationFlags & AllowedOperationFlags.Delete) == AllowedOperationFlags.Delete,
                (allowedOperationFlags & AllowedOperationFlags.Browse) == AllowedOperationFlags.Browse);
            _descriptionOffset = _builder.CreateString(description);
            _descriptionUrlOffset = _builder.CreateString(descriptionUrl);
        }
 
        public MetadataBuilder SetNodeClass(NodeClass nodeClass)
        {
            _nodeClass = nodeClass;
            return this;
        }
 
        public MetadataBuilder SetDisplayName(string displayName)
        {
            _displayNameOffset = _builder.CreateString(displayName);
            return this;
        }
 
        public MetadataBuilder SetDisplayFormat(DisplayFormat displayFormat)
        {
            _displayFormat = displayFormat;
            return this;
        }
 
        public MetadataBuilder SetUnit(string unit)
        {
            _unitOffset = _builder.CreateString(unit);
            return this;
        }
 
        public MetadataBuilder AddReference(ReferenceType type, string targetAddress)
        {
            _references.Add(Reference.CreateReference(_builder, _builder.CreateString(type.Value), _builder.CreateString(targetAddress)));
            return this;
        }
 
        public MetadataBuilder AddExtension(string key, string value)
        {
            _extensions.Add(Extension.CreateExtension(_builder, _builder.CreateString(key), _builder.CreateString(value)));
            return this;
        }
 
        public MetadataBuilder AddDisplayName(string localeId, string text)
        {
            _displayNames.Add(LocaleText.CreateLocaleText(_builder, _builder.CreateString(localeId), _builder.CreateString(text)));
            return this;
        }
 
        public MetadataBuilder AddDescription(string localeId, string text)
        {
            _descriptions.Add(LocaleText.CreateLocaleText(_builder, _builder.CreateString(localeId), _builder.CreateString(text)));
            return this;
        }
 
        public Variant Build()
        {
            var referencesVector = _references.Count == 0
                ? new VectorOffset(0)
                : Reference.CreateSortedVectorOfReference(_builder, _references.ToArray());
            var extensionsVector = _extensions.Count == 0
                ? new VectorOffset(0)
                : Extension.CreateSortedVectorOfExtension(_builder, _extensions.ToArray());
            var descriptionsVector = _descriptions.Count == 0
                ? new VectorOffset(0)
                : LocaleText.CreateSortedVectorOfLocaleText(_builder, _descriptions.ToArray());
            var displayNamesVector = _displayNames.Count == 0
                ? new VectorOffset(0)
                : LocaleText.CreateSortedVectorOfLocaleText(_builder, _displayNames.ToArray());
 
            var offsetMetadata = Metadata.CreateMetadata(_builder,
                _nodeClass,
                _allowedOperationsOffset,
                _descriptionOffset,
                _descriptionUrlOffset,
                _displayNameOffset,
                _displayFormat,
                _unitOffset,
                extensionsVector,
                referencesVector,
                descriptionsVector,
                displayNamesVector);
 
            Metadata.FinishMetadataBuffer(_builder, offsetMetadata);
            return new Variant(_builder);
        }
    }
}