Adapter_FrontEndClass.cs

Go to the documentation of this file.

 
 
using System;
using System.Collections;
using System.Text;
using static DesignPatternExamples_csharp.DataReadWriteFunctions;
 
namespace DesignPatternExamples_csharp
{
    internal class DataReaderWriterInitException : Exception
    {
        public DataReaderWriterInitException(string msg)
            : base(msg)
        {
        }
    }
 
 
    internal class DataReaderWriterException : Exception
    {
        public DataReaderWriterException(string msg)
            : base(msg)
        {
        }
    }
 
    
    internal class DataReaderWriter : IDisposable
    {
        public enum MemoryBlockNumber
        {
            Memory_Block_0 = 0,  
            Memory_Block_1 = 1,  
            Memory_Block_2 = 2,  
        };
 
        private bool _disposed;
        private bool _initialized;
        private int _dataHandle;
        private uint _memoryBlockByteSize;
 
        public uint MemoryBlockByteSize
        {
            get { return _memoryBlockByteSize; }
        }
 
        private string _GetBlockNameForBlockNumber(MemoryBlockNumber blockNumber)
        {
            string blockName = "";
 
            switch (blockNumber)
            {
                case MemoryBlockNumber.Memory_Block_0:
                    blockName = BLOCK_NAME_0;
                    break;
 
                case MemoryBlockNumber.Memory_Block_1:
                    blockName = BLOCK_NAME_1;
                    break;
 
                case MemoryBlockNumber.Memory_Block_2:
                    blockName = BLOCK_NAME_2;
                    break;
 
                default:
                    break;
            }
 
            return blockName;
        }
 
        string _GetErrorMessage(DDR_ErrorCode errorCode)
        {
            string message = "";
 
            switch (errorCode)
            {
                case DataReadWriteFunctions.DDR_ErrorCode.DDR_ErrorCode_Success:
                    message = "Operation succeeded";
                    break;
 
                case DataReadWriteFunctions.DDR_ErrorCode.DDR_ErrorCode_Block_Already_Opened:
                    message = "Memory block is already open and cannot be opened again";
                    break;
 
                case DataReadWriteFunctions.DDR_ErrorCode.DDR_ErrorCode_Block_Not_Opened:
                    message = "Memory block is closed and cannot be accessed";
                    break;
 
                case DataReadWriteFunctions.DDR_ErrorCode.DDR_ErrorCode_Invalid_Block_Name:
                    message = "The given name is not a recognized memory block name";
                    break;
 
                case DataReadWriteFunctions.DDR_ErrorCode.DDR_ErrorCode_Invalid_Handle:
                    message = "The handle argument does not correspond to a valid open memory block";
                    break;
 
                case DataReadWriteFunctions.DDR_ErrorCode.DDR_ErrorCode_Invalid_Offset:
                    message = "The given offset is out of bounds";
                    break;
 
                case DataReadWriteFunctions.DDR_ErrorCode.DDR_ErrorCode_Null_Argument:
                    message = "The block name pointer or return handle pointer argument is NULL";
                    break;
 
                default:
                    message = "Unrecognized error code.";
                    break;
            }
 
            return message;
        }
 
        string _ConstructErrorMessage(DDR_ErrorCode errorCode, string operation)
        {
            string msg = _GetErrorMessage(errorCode);
            return String.Format("{0}: {1}", operation, msg);
        }
 
 
        public DataReaderWriter(MemoryBlockNumber blockNumber)
        {
            _initialized = false;
            _dataHandle = -1;
            string blockName = _GetBlockNameForBlockNumber(blockNumber);
            if (!String.IsNullOrEmpty(blockName))
            {
                DataReadWriteFunctions.DDR_ErrorCode errorCode =
                    DataReadWriteFunctions.DDR_OpenMemoryBlock(blockName, out _dataHandle);
                if (errorCode == DDR_ErrorCode.DDR_ErrorCode_Success)
                {
                    int memorySizeInChunks = 0;
                    errorCode = DataReadWriteFunctions.DDR_GetMemorySize(_dataHandle, out memorySizeInChunks);
                    if (errorCode != DDR_ErrorCode.DDR_ErrorCode_Success)
                    {
                        string msg = _ConstructErrorMessage(errorCode,
                            "Memory block not opened so cannot retrieve memory block size");
                        throw new DataReaderWriterInitException(msg);
                    }
                    _memoryBlockByteSize = (uint)memorySizeInChunks * sizeof(UInt32);
                    _initialized = true;
                }
                else
                {
                    string msg = _ConstructErrorMessage(errorCode, "Initializing data reader/writer");
                    throw new DataReaderWriterInitException(msg);
                }
            }
        }
 
 
        public byte[] Read(int byteOffset, uint maxBytes)
        {
            if (!_initialized)
            {
                throw new DataReaderWriterInitException("Data reader/writer is not initialized.");
            }
 
            byte[] data = new byte[maxBytes];
 
            if (maxBytes > 0)
            {
                int chunkOffset = byteOffset / (sizeof(UInt32));
                UInt32 value = 0;
                UInt32 bufferIndex = 0;
                DDR_ErrorCode errorCode = DDR_ErrorCode.DDR_ErrorCode_Success;
                errorCode = DDR_GetDataChunk(_dataHandle, chunkOffset, out value);
                if (errorCode == DDR_ErrorCode.DDR_ErrorCode_Success)
                {
                    int byteOffsetInChunk = byteOffset % (sizeof(UInt32));
                    while (bufferIndex < maxBytes)
                    {
                        data[bufferIndex] = (byte) (value & 0xff);
                        bufferIndex++;
                        value >>= 8;
                        byteOffsetInChunk++;
                        if (byteOffsetInChunk == sizeof(UInt32))
                        {
                            chunkOffset++;
                            if (chunkOffset >= DataReadWriteFunctions.DDR_MAX_OFFSET)
                            {
                                break;
                            }
                            byteOffsetInChunk = 0;
                            errorCode = DDR_GetDataChunk(_dataHandle, chunkOffset, out value);
                            if (errorCode != DDR_ErrorCode.DDR_ErrorCode_Success)
                            {
                                string msg = _ConstructErrorMessage(errorCode, "Reading memory");
                                throw new DataReaderWriterException(msg);
                            }
                        }
                    }
                }
                else
                {
                    string msg = _ConstructErrorMessage(errorCode, "Reading memory");
                    throw new DataReaderWriterException(msg);
                }
            }
 
            return data;
        }
 
        public void Write(int byteOffset, byte[] data, uint maxBytes)
        {
            if (!_initialized)
            {
                throw new DataReaderWriterInitException("Data reader/writer is not initialized.");
            }
            DDR_ErrorCode errorCode = DDR_ErrorCode.DDR_ErrorCode_Success;
            int chunkOffset = byteOffset / sizeof(UInt32);
            UInt32 value = 0;
            int byteOffsetInChunk = byteOffset % sizeof(UInt32);
            UInt32 bufferIndex = 0;
            UInt32 byteMask = (UInt32)0xff << (byteOffsetInChunk * 8);
            if (byteOffsetInChunk != 0)
            {
                errorCode = DDR_GetDataChunk(_dataHandle, chunkOffset, out value);
            }
            if (errorCode == DDR_ErrorCode.DDR_ErrorCode_Success)
            {
                while (bufferIndex < maxBytes)
                {
                    value &= ~byteMask;
                    value |= ((UInt32)data[bufferIndex]) << (byteOffsetInChunk * 8);
                    bufferIndex++;
                    byteMask <<= 8;
                    byteOffsetInChunk++;
                    if (byteOffsetInChunk == sizeof(UInt32))
                    {
                        errorCode = DDR_SetDataChunk(_dataHandle, chunkOffset, value);
                        if (errorCode == DDR_ErrorCode.DDR_ErrorCode_Success)
                        {
                            byteMask = 0xff;
                            byteOffsetInChunk = 0;
                            chunkOffset++;
                            if (chunkOffset >= DDR_MAX_OFFSET)
                            {
                                break;
                            }
                            errorCode = DDR_GetDataChunk(_dataHandle, chunkOffset, out value);
                            if (errorCode != DDR_ErrorCode.DDR_ErrorCode_Success)
                            {
                                break;
                            }
                        }
                        else
                        {
                            string msg = _ConstructErrorMessage(errorCode, "Writing memory");
                            throw new DataReaderWriterException(msg);
                        }
                    }
                }
                if (errorCode == DDR_ErrorCode.DDR_ErrorCode_Success)
                {
                    if (byteOffsetInChunk != 0)
                    {
                        errorCode = DDR_SetDataChunk(_dataHandle, chunkOffset, value);
                    }
                }
                if (errorCode != DDR_ErrorCode.DDR_ErrorCode_Success)
                {
                    string msg = _ConstructErrorMessage(errorCode, "Writing memory");
                    throw new DataReaderWriterException(msg);
                }
            }
            else
            {
                string msg = _ConstructErrorMessage(errorCode, "Reading memory in preparation to writing memory");
                throw new DataReaderWriterException(msg);
            }
        }
 
 
        public string BufferToString(byte[] data, uint maxBytes, int indent)
        {
            StringBuilder output = new StringBuilder();
            string indentSpaces = new string(' ', indent);
 
            if (data != null && maxBytes != 0)
            {
                int byteCount = (int)maxBytes;
                if (byteCount > data.Length)
                {
                    byteCount = data.Length;
                }
                int bytesPerRow = 32;
                for (int row = 0; row < maxBytes; row += bytesPerRow)
                {
                    output.AppendFormat("{0}{1:x4} --", indentSpaces, row);
                    for (int col = 0; col < bytesPerRow && (row + col) < maxBytes; ++col)
                    {
                        if (col > 0)
                        {
                            output.Append(' ');
                        }
                        output.AppendFormat("{0:x2}", data[row + col]);
                    }
                    output.Append(Environment.NewLine);
                }
            }
            return output.ToString();
        }
 
    
#region IDisposable Members
 
        public void Dispose()
        {
            if (!_disposed)
            {
                if (_initialized)
                {
                    _initialized = false;
                    DDR_ErrorCode errorCode = DataReadWriteFunctions.DDR_CloseMemoryBlock(_dataHandle);
                    _dataHandle = -1;
                    if (errorCode != 0)
                    {
                        string msg = _ConstructErrorMessage(errorCode, "Shutting down data reader/writer");
                        throw new DataReaderWriterInitException(msg);
                    }
                }
                _disposed = true;
            }
        }
 
#endregion
    }
}