/*
 * Pipe.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL++2000
#pragma once

#include <sol\Object.h>

namespace SOL {

class Pipe :public Object {
private:
    HANDLE    hReader;
    HANDLE    hWriter;
    SECURITY_ATTRIBUTES sa;

public:
    Pipe(int buffsize =1024) 
    :hReader(INVALID_HANDLE_VALUE),
    hWriter(INVALID_HANDLE_VALUE)
    {
        memset(&sa, 0, sizeof(sa));
        sa.nLength = sizeof(SECURITY_ATTRIBUTES);
        sa.bInheritHandle = TRUE;
        if (CreatePipe(&hReader, &hWriter, &sa, buffsize) == False) {
            hReader = INVALID_HANDLE_VALUE;
            hWriter = INVALID_HANDLE_VALUE;
        }
    }

public:
// Create duplicated pipe.
    Pipe(Pipe& origPipe)
    :hReader(INVALID_HANDLE_VALUE),
    hWriter(INVALID_HANDLE_VALUE)
    {
        memset(&sa, 0, sizeof(sa));
        hReader = origPipe.duplicateReaderHandle();
        hWriter = origPipe.duplicateWriterHandle();
    }


public:
// Create duplicated pipe.
    Pipe(Pipe* origPipe)
    :hReader(INVALID_HANDLE_VALUE),
    hWriter(INVALID_HANDLE_VALUE)
    {
        memset(&sa, 0, sizeof(sa));
        if (origPipe) {
            hReader = origPipe -> duplicateReaderHandle();
            hWriter = origPipe -> duplicateWriterHandle();
        }
    }

public:
    ~Pipe() 
    {
        close();
    }

public:
    void close()
    {
        closeReaderHandle();
        closeWriterHandle();
    }

public:
    void closeReaderHandle() 
    {
        if (hReader != INVALID_HANDLE_VALUE) {
            ::CloseHandle(hReader);
        }
        hReader = NULL;
    }

public:
    void closeWriterHandle() 
    {
        if (hWriter != INVALID_HANDLE_VALUE) {
            ::CloseHandle(hWriter);
        }
        hWriter = NULL;
    }


public:
    HANDLE duplicateReaderHandle()
    {
        HANDLE hReaderDup = INVALID_HANDLE_VALUE;
        if (hReader != INVALID_HANDLE_VALUE &&
            !::DuplicateHandle(GetCurrentProcess(), hReader,
                GetCurrentProcess(), &hReaderDup , 0,
                FALSE,  DUPLICATE_SAME_ACCESS)) {
            hReaderDup = INVALID_HANDLE_VALUE;
        }
        return hReaderDup;
    }

public:
    HANDLE duplicateWriterHandle()
    {
        HANDLE hWriterDup = INVALID_HANDLE_VALUE;
        if (hWriter != INVALID_HANDLE_VALUE &&
            !::DuplicateHandle(GetCurrentProcess(), hWriter,
                GetCurrentProcess(), &hWriterDup , 0,
                FALSE,  DUPLICATE_SAME_ACCESS)) {
            hWriterDup = INVALID_HANDLE_VALUE;
        }
        return hWriterDup;
    }

public:
    int read(char* buffer, int len) 
    {
        unsigned long result = 0;
        if (hReader != INVALID_HANDLE_VALUE) {
            ::ReadFile(hReader, buffer, len, &result, 0);
        }
        return (int)result;
    }

public:
    int    write(const char* buffer, int len) 
    {
        unsigned long result = 0;
        if (hWriter !=INVALID_HANDLE_VALUE) {
            ::WriteFile(hWriter, buffer, len, &result, 0);
        }
        return (int)result;
    }


    HANDLE getReaderHandle() {
        return hReader;
    }

    HANDLE getWriterHandle() {
        return hWriter;

    }
/*
    void    close();

    void    closeReaderHandle();
    void    closeWriterHandle();

    HANDLE    duplicateReaderHandle();
    HANDLE    duplicateWriterHandle();


    int        read(char* buffer, int len);
    int        write(const char* buffer, int len);
*/
};

}