haiku.git

// NodeHandle.h

#ifndef NET_FS_NODE_HANDLE_H
#define NET_FS_NODE_HANDLE_H

#include <dirent.h>

#include <Query.h>
#include <Referenceable.h>
#include <util/DoublyLinkedList.h>

#include "Lockable.h"
#include "NodeRef.h"

class Directory;
class Entry;
class Node;

// NodeHandle
class NodeHandle : public BReferenceable, public Lockable {
public:
								NodeHandle();
	virtual						~NodeHandle();

	virtual	status_t			GetStat(struct stat* st);

			void				SetCookie(int32 cookie);
			int32				GetCookie() const;

			const NodeRef&		GetNodeRef() const;

protected:
	virtual	int					GetFD() const;

protected:
			int32				fCookie;
			NodeRef				fNodeRef;
};

// FileHandle
class FileHandle : public NodeHandle {
public:
								FileHandle();
	virtual						~FileHandle();

			status_t			Open(Node* node, int openMode);
			status_t			Close();

			status_t			Read(off_t pos, void* buffer, size_t size,
									size_t* bytesRead);
			status_t			Write(off_t pos, const void* buffer,
									size_t size, size_t* bytesWritten);

 			status_t			ReadAttr(const char* name, uint32 type,
 									off_t pos, void* buffer, size_t size,
 									size_t* bytesRead);
 			status_t			WriteAttr(const char* name, uint32 type,
 									off_t pos, const void* buffer, size_t size,
 									size_t* bytesWritten);
 			status_t			RemoveAttr(const char* name);
			status_t			StatAttr(const char* name, attr_info* info);

protected:
	virtual	int					GetFD() const;

private:
			int					fFD;
};

// DirIterator
class DirIterator : public NodeHandle,
	public DoublyLinkedListLinkImpl<DirIterator> {
public:
								DirIterator();
	virtual						~DirIterator();

			bool				IsValid() const;

	virtual	Entry*				NextEntry() = 0;
	virtual	void				Rewind() = 0;


	// for Directory internal use only
	virtual	status_t			SetDirectory(Directory* directory) = 0;

	virtual	Entry*				GetCurrentEntry() const = 0;

protected:
			Directory*			fDirectory;
			bool				fValid;
};

// AttrDirIterator
class AttrDirIterator : public NodeHandle {
public:
								AttrDirIterator();
	virtual						~AttrDirIterator();

			status_t			Open(Node* node);
			status_t			Close();

	virtual	status_t			ReadDir(dirent* entry, int32 bufferSize,
									int32 count, int32* countRead, bool *done);
	virtual	status_t			RewindDir();

protected:
	virtual	int					GetFD() const;

private:
			DIR*				fDir;
};

// Query
class Query : public BQuery, public DoublyLinkedListLinkImpl<Query> {
public:
};

class QueryHandle;

// QueryListener
class QueryListener {
public:
								QueryListener();
	virtual						~QueryListener();

	virtual	void				QueryHandleClosed(QueryHandle* handle) = 0;
};

// QueryHandle
class QueryHandle : public NodeHandle {
public:
								QueryHandle(port_id remotePort,
									int32 remoteToken);
	virtual						~QueryHandle();

			void				SetQueryListener(QueryListener* listener);
			QueryListener*		GetQueryListener() const;

			void				AddQuery(Query* query);
			void				RemoveQuery(Query* query);

			port_id				GetRemotePort() const;
			int32				GetRemoteToken() const;

			status_t			Close();

			status_t			ReadDir(dirent* entry, int32 count,
									int32* countRead);
private:
			port_id				fRemotePort;
			int32				fRemoteToken;
			DoublyLinkedList<Query> fQueries;
			Query*				fCurrentQuery;
			QueryListener*		fListener;
			bool				fClosed;
};

#endif	// NET_FS_NODE_HANDLE_H