FileHandle.h

Go to the documentation of this file.

//=============================================================================
//  Computational Process Networks class library
//  Copyright (C) 1997-2006  Gregory E. Allen and The University of Texas
//
//  This library is free software; you can redistribute it and/or modify it
//  under the terms of the GNU Library General Public License as published
//  by the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Library General Public License for more details.
//
//  The GNU Public License is available in the file LICENSE, or you
//  can write to the Free Software Foundation, Inc., 59 Temple Place -
//  Suite 330, Boston, MA 02111-1307, USA, or you can find it on the
//  World Wide Web at http://www.fsf.org.
//=============================================================================
#ifndef FILEHANDLE_H
#define FILEHANDLE_H
#pragma once
#include <cpn/common.h>
#include <cpn/threading/PthreadMutex.h>
#include <cpn/utils/AutoLock.h>
#include <cpn/utils/IteratorRef.h>
// for the iovec struct
#include <sys/uio.h>

class FileHandle {
public:
    typedef AutoLock<PthreadMutex> ALock;

    static int Poll(IteratorRef<FileHandle*> begin, IteratorRef<FileHandle*> end, double timeout);

    FileHandle();

    FileHandle(int filed);
    
    virtual ~FileHandle();

    int Poll(double timeout);

    bool Readable(bool r) { ALock al(file_lock); return readable = r; }
    bool Readable() const { ALock al(file_lock); return readable; }
    bool Writeable(bool w) { ALock al(file_lock); return writeable = w; }
    bool Writeable() const { ALock al(file_lock); return writeable; }

    int FD() const { ALock al(file_lock); return fd; }
    int FD(int filed) { ALock al(file_lock); return fd = filed; }

    bool Eof() const { ALock al(file_lock); return eof; }
    bool Eof(bool e) { ALock al(file_lock); return eof = e; }
    bool Good() const { ALock al(file_lock); return !(eof || fd == -1); }
    bool Closed() const { ALock al(file_lock); return fd == -1; }

    void SetBlocking(bool blocking);
    static void SetBlocking(int fd, bool blocking);
    bool IsBlocking() const;
    static bool IsBlocking(int fd);

    void Reset();

    void Close();

    unsigned Read(void *ptr, unsigned len);
    unsigned Readv(const iovec *iov, int iovcnt);
    unsigned Write(const void *ptr, unsigned len);
    unsigned Writev(const iovec *iov, int iovcnt);

    void Flush();
protected:
    virtual void OnReadable() { Readable(true); }
    virtual void OnWriteable() { Writeable(true); }
    mutable PthreadMutex file_lock;
    int fd;
    bool readable;
    bool writeable;
    bool eof;
private:
    FileHandle(const FileHandle&);
    FileHandle &operator=(const FileHandle&);
};
#endif