Esempio n. 1
0
        /// <summary>
        /// Get an access to the buffer.
        /// </summary>
        /// <param name="usage">Specifies the access usage.</param>
        /// <returns>An usage instance.</returns>
        public ObjectUsage <T> Get(UsageType usage)
        {
            switch (usage)
            {
            case UsageType.Write:

                lock (pBuffer)
                {
                    // - Find the free buffer for write
                    while (pBuffer[pWritePointer]?.Usage == UsageType.Read || pWritePointer == pFreePointer)
                    {
                        pWritePointer = (pWritePointer + 1) % 3;
                    }
                }

                // - If buffer is null instance it and set it on Write
                if (pBuffer[pWritePointer] == null)
                {
                    ObjectUsage <T> obj = new ObjectUsage <T>
                    {
                        Usage = UsageType.Write
                    };

                    obj.Action = () => Close(obj);

                    pBuffer[pWritePointer] = obj;
                }
                else
                {
                    pBuffer[pWritePointer].Usage = UsageType.Write;
                }

                return(pBuffer[pWritePointer]);

            case UsageType.Read:

                if (pFreePointer < 0)
                {
                    return(null);
                }

                lock (pBuffer)
                {
                    pReadPointer = pFreePointer;
                    pBuffer[pReadPointer].Usage = UsageType.Read;
                }

                return(pBuffer[pReadPointer]);
            }

            return(null);
        }
Esempio n. 2
0
        /// <summary>
        /// Called on usage disposition
        /// </summary>
        private void Close(ObjectUsage <T> obj)
        {
            switch (obj.Usage)
            {
            case UsageType.Read:

                lock (pBuffer)
                    pBuffer[pReadPointer].Usage = UsageType.None;

                break;

            case UsageType.Write:

                lock (pBuffer)
                {
                    pBuffer[pWritePointer].Usage = UsageType.None;
                    pFreePointer = pWritePointer;
                }

                break;
            }
        }