Buffer.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef KERNEL_UTILITIES_BUFFER_H
#define KERNEL_UTILITIES_BUFFER_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/ConditionVariable.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/new"

class Event;
class Semaphore;
class Thread;

template <class T, bool allowShortOperation = false>
class EXPORTED_PUBLIC Buffer
{
    friend class UnixSocket;  // to allow for calling notifyMonitors()

  public:
    Buffer(size_t bufferSize);
    ~Buffer();

    size_t write(const T *buffer, size_t count, bool block = true);

    size_t read(T *buffer, size_t count, bool block = true);

    void disableWrites();

    void disableReads();

    bool enableWrites();

    bool enableReads();

    size_t getDataSize();

    size_t getSize();

    bool canWrite(bool block);

    bool canRead(bool block);

    void wipe();

    void monitor(Thread *pThread, Event *pEvent);

    void monitor(Semaphore *pSemaphore);

    void cullMonitorTargets(Thread *pThread);

    void cullMonitorTargets(Semaphore *pSemaphore);

    void cullMonitorTargets(Event *pEvent);

  private:
    WITHOUT_IMPLICIT_CONSTRUCTORS(Buffer);

    void notifyMonitors();

    void addSegment(const T *buffer, size_t count);

    static const size_t m_SegmentSize = 32768;

    struct Segment
    {
        Segment() : data(), reader(0), size(0)
        {
        }

        T data[m_SegmentSize];

        size_t reader;

        size_t size;
    };

    struct MonitorTarget
    {
        MonitorTarget() : pThread(0), pEvent(0), pSemaphore(0)
        {
        }

        MonitorTarget(Thread *thread, Event *event)
            : pThread(thread), pEvent(event), pSemaphore(0)
        {
        }

        MonitorTarget(Semaphore *sem) : pThread(0), pEvent(0), pSemaphore(sem)
        {
        }

        Thread *pThread;
        Event *pEvent;
        Semaphore *pSemaphore;
    };

    size_t m_BufferSize;
    size_t m_DataSize;

    Mutex m_Lock;

    ConditionVariable m_WriteCondition;
    ConditionVariable m_ReadCondition;

    List<Segment *> m_Segments;
    List<MonitorTarget *> m_MonitorTargets;

    bool m_bCanRead;
    bool m_bCanWrite;
};

// Specializations are in a .cc file.
extern template class Buffer<uint8_t, false>;  // IWYU pragma: keep
extern template class Buffer<uint8_t, true>;   // IWYU pragma: keep
extern template class Buffer<char, false>;     // IWYU pragma: keep
extern template class Buffer<char, true>;      // IWYU pragma: keep
extern template class Buffer<size_t, false>;   // IWYU pragma: keep
extern template class Buffer<size_t, true>;    // IWYU pragma: keep

#endif  // KERNEL_UTILITIES_BUFFER_H