DatalayerSystem.cs

using Datalayer.Internal;
using System;
using System.Collections.Generic;
 
namespace Datalayer
{
    public class DatalayerSystem : IDatalayerSystem, INative
    {
        private unsafe void* _nativePtr;
 
        private Factory _factory;
        private Converter _converter;
 
        private readonly string _ipcPath;
 
        private bool _disposedValue;
        private bool _isStarted;
 
        private readonly List<Client> _clients = new List<Client>();
        private readonly List<Provider> _providers = new List<Provider>();
 
        public DatalayerSystem(string ipcPath = "")
        {
            _ipcPath = ipcPath ?? throw new ArgumentNullException(nameof(ipcPath));
 
            var ipcPathBuffer = StringBuffer.FromString(_ipcPath);
            unsafe
            {
                _nativePtr = NativeMethods.Datalayer.DLR_systemCreate(ipcPathBuffer.ToNativePtr());
            }
        }
 
        unsafe void* INative.NativePtr => _nativePtr;
 
        internal List<Client> Clients => _clients;
 
        internal List<Provider> Providers => _providers;
 
        #region Disposing
 
        public bool IsDisposed => _disposedValue;
 
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposedValue)
            {
                if (disposing)
                {
                    // dispose managed state (managed objects)
                }
 
                // free unmanaged resources (unmanaged objects) and override finalizer
                Delete();
                //  set large fields to null
                _disposedValue = true;
            }
        }
 
        ~DatalayerSystem()
        {
            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
            Dispose(disposing: false);
        }
 
        public void Dispose()
        {
            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
 
        private void Delete()
        {
            unsafe
            {
                if (_nativePtr == null)
                {
                    return;
                }
 
                //Stop implicitly, first
                if (!IsDisposed)
                {
                    Stop();
                }
 
                NativeMethods.Datalayer.DLR_systemDelete(_nativePtr);
                _isStarted = false;
                _nativePtr = null;
                _disposedValue = true;
            }
        }
 
        private void DeleteChildren()
        {
            //Delete clients
            foreach (var client in _clients)
            {
                client.Delete();
            }
            _clients.Clear();
 
            //Delete providers
            foreach (var provider in _providers)
            {
                provider.Delete();
            }
            _providers.Clear();
 
            //Delete Factory / Converter and force recreation on next access.
            if (_factory != null)
            {
                _factory.Delete();
                _factory = null;
            }
            
            if (_converter != null)
            {
                _converter.Delete();
                _converter = null;
            }      
        }
        #endregion
 
        #region Public Consts
 
        public static readonly int DefaultClientPort = 2069;
 
        public static readonly int DefaultProviderPort = 2070;
 
        public static readonly string ProtocolSchemeTcp = "tcp://";
 
        public static readonly string ProtocolSchemeIpc = "ipc://";
 
        #endregion
 
        #region Public Properties
 
        public string IpcPath
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return _ipcPath;
            }
        }
 
        public bool IsStarted
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return _isStarted;
            }
        }
 
        public string BfbsPath
        {
            set
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(value));
                }
 
                var valueBuffer = StringBuffer.FromString(value);
                unsafe
                {
 
                    NativeMethods.Datalayer.DLR_systemSetBfbsPath(_nativePtr, valueBuffer.ToNativePtr());
                }
            }
        }
 
        #endregion
 
        #region Public Methods
 
        public void Start(bool startBroker = false)
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            unsafe
            {
                NativeMethods.Datalayer.DLR_systemStart(_nativePtr, Convert.ToByte(startBroker));
            }
            _isStarted = true;
        }
 
        public void Stop()
        {
            //If the system has been stopped, it's completely useless
 
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            //We have to delete the children BEFORE stopping, else stop never returns (hang)
            DeleteChildren();
 
            unsafe
            {
                NativeMethods.Datalayer.DLR_systemStop(_nativePtr, Convert.ToByte(true));              
            }
            _isStarted = false;
        }
 
        public IFactory Factory
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                if (_factory == null)
                {
                    //System has to be started to get valid factory pointer
                    if (!_isStarted)
                    {
                        throw new InvalidOperationException("DatalayerSystem not started");
                    }
 
                    unsafe
                    {
                        void* factoryPtr = NativeMethods.Datalayer.DLR_systemFactory(_nativePtr);
                        _factory = new Factory(this, factoryPtr);
                    }
                }
                return _factory;
            }
        }
 
        public IConverter Converter
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                if (_converter == null)
                {
                    unsafe
                    {
                        void* converterPtr = NativeMethods.Datalayer.DLR_systemJsonConverter(_nativePtr);
                        _converter = new Converter(this, converterPtr);
                    }
                }
                return _converter;
            }
        }
 
        #endregion
    }
}