// $Header$

#ifndef channel_h
#define channel_h


// Channels manage a communication channel to a process.  The channel
// consists of two file descriptors, one for reading from the process
// and the other for writing to the process.
//
// The Channel class doesn't do much at the moment.  It used to do a lot
// more (providing buffering and line-oriented reads) but presently Glish
// clients use binary I/O to transmit messages, so Channel's have become
// little more than a way to bundle together two file descriptors.  We
// retain some of the Channel abstraction, however, in case in the future
// we wish to return to buffering.

// Channels have a state associated with them.  CHAN_VALID is an ordinary
// channel.  CHAN_IN_USE is a channel that is presently being read from.
// CHAN_INVALID marks a channel that would have been deleted except that
// it was "in use"; it should be deleted as soon as it is no longer being used.
//
// Note that the value of the channel status is managed *externally*,
// and not by the member functions of the class.  ChannelState() may
// be used to access and modify the internal state variable.
//
// The state is initialized to CHAN_VALID.

typedef enum { CHAN_VALID, CHAN_IN_USE, CHAN_INVALID } ChanState;


class Channel {
    public:
	// Create a new Channel with the given input and output fd's.
	Channel( int rfd, int wfd )
		{
		read_fd = rfd;
		write_fd = wfd;
		state = CHAN_VALID;
		}

	// True if data pending in channel read buf.  This is a vestigial
	// remnant from when the Channel class used to buffer its input.
	// It remains here so that if later we find we need to return to
	// buffering, we can do so easily.
	int DataInBuffer()
		{ return 0; }

	// Note we do *not* return a "const ChanState&"; the user is
	// free to modify the channel state.
	ChanState& ChannelState()	{ return state; }

	int ReadFD()	{ return read_fd; }
	int WriteFD()	{ return write_fd; }

    protected:
	ChanState state;
	int read_fd;
	int write_fd;
	};

#endif	/* channel_h */