/*
 * Copyright 2002-2011 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _NODE_H
#define _NODE_H


#include <Statable.h>


class BDirectory;
class BEntry;
class BString;
struct entry_ref;


struct node_ref {
	node_ref();
	node_ref(dev_t device, ino_t node);
	node_ref(const node_ref& other);

	bool operator==(const node_ref& other) const;
	bool operator!=(const node_ref& other) const;
	bool operator<(const node_ref& other) const;
	node_ref& operator=(const node_ref& other);

	dev_t device;
	ino_t node;
};


class BNode : public BStatable {
public:
								BNode();
								BNode(const entry_ref* ref);
								BNode(const BEntry* entry);
								BNode(const char* path);
								BNode(const BDirectory* dir, const char* path);
								BNode(const BNode& node);
	virtual						~BNode();

			status_t			InitCheck() const;

	virtual	status_t			GetStat(struct stat* st) const;

			status_t			SetTo(const entry_ref* ref);
			status_t			SetTo(const BEntry* entry);
			status_t			SetTo(const char* path);
			status_t			SetTo(const BDirectory* dir, const char* path);
			void				Unset();

			status_t			Lock();
			status_t			Unlock();

			status_t			Sync();

			ssize_t				WriteAttr(const char* name, type_code type,
									off_t offset, const void* buffer,
									size_t length);
			ssize_t				ReadAttr(const char* name, type_code type,
									off_t offset, void* buffer,
									size_t length) const;
			status_t			RemoveAttr(const char* name);
			status_t			RenameAttr(const char* oldName,
									const char* newName);
			status_t			GetAttrInfo(const char* name,
									struct attr_info* info) const;
			status_t			GetNextAttrName(char* buffer);
			status_t			RewindAttrs();
			status_t			WriteAttrString(const char* name,
									const BString* data);
			status_t			ReadAttrString(const char* name,
									BString* result) const;

			BNode&				operator=(const BNode& node);
			bool				operator==(const BNode& node) const;
			bool				operator!=(const BNode& node) const;

			int					Dup();
				// This should be "const" but R5's is not... Ugggh.

private:
	friend class BFile;
	friend class BDirectory;
	friend class BSymLink;

	virtual	void				_RudeNode1();
	virtual	void				_RudeNode2();
	virtual	void				_RudeNode3();
	virtual	void				_RudeNode4();
	virtual	void				_RudeNode5();
	virtual	void				_RudeNode6();

private:
			status_t			set_fd(int fd);
	virtual	void				close_fd();
			void				set_status(status_t newStatus);

			status_t			_SetTo(int fd, const char* path, bool traverse);
			status_t			_SetTo(const entry_ref* ref, bool traverse);

	virtual	status_t			set_stat(struct stat& stat, uint32 what);

			status_t			_GetStat(struct stat* stat) const;
	virtual	status_t			_GetStat(struct stat_beos* stat) const;
			status_t			InitAttrDir();

private:
			uint32				rudeData[4];
			int					fFd;
				// Ffile descriptor for the given node
			int					fAttrFd;
				// file descriptor for the attribute directory of the node,
				// initialized lazily
			status_t			fCStatus;
				// the node's initialization status
};


#endif	// _NODE_H