// Requests.h

#ifndef NET_FS_REQUESTS_H
#define NET_FS_REQUESTS_H

#include "AttrDirInfo.h"
#include "Compatibility.h"
#include "DebugSupport.h"
#include "EntryInfo.h"
#include "NodeInfo.h"
#include "Request.h"
#include "RequestMemberArray.h"
#include "ServerInfo.h"
#include "ServerNodeID.h"

// request types
enum {
        CONNECTION_BROKEN_REQUEST       = -1,
        INIT_CONNECTION_REQUEST         = 0,
        INIT_CONNECTION_REPLY,

        MOUNT_REQUEST,
        MOUNT_REPLY,
        UNMOUNT_REQUEST,
        READ_VNODE_REQUEST,
        READ_VNODE_REPLY,
        WRITE_STAT_REQUEST,
        WRITE_STAT_REPLY,
        CREATE_FILE_REQUEST,
        CREATE_FILE_REPLY,
        OPEN_REQUEST,
        OPEN_REPLY,
        CLOSE_REQUEST,  // common for all kinds of cookies
        CLOSE_REPLY,
        READ_REQUEST,
        READ_REPLY,
        WRITE_REQUEST,
        WRITE_REPLY,
        CREATE_LINK_REQUEST,
        CREATE_LINK_REPLY,
        UNLINK_REQUEST,
        UNLINK_REPLY,
        CREATE_SYMLINK_REQUEST,
        CREATE_SYMLINK_REPLY,
        READ_LINK_REQUEST,
        READ_LINK_REPLY,
        RENAME_REQUEST,
        RENAME_REPLY,
        MAKE_DIR_REQUEST,
        MAKE_DIR_REPLY,
        REMOVE_DIR_REQUEST,
        REMOVE_DIR_REPLY,
        OPEN_DIR_REQUEST,
        OPEN_DIR_REPLY,
        READ_DIR_REQUEST,
        READ_DIR_REPLY,
        WALK_REQUEST,
        WALK_REPLY,
        MULTI_WALK_REQUEST,
        MULTI_WALK_REPLY,

        OPEN_ATTR_DIR_REQUEST,
        OPEN_ATTR_DIR_REPLY,
        READ_ATTR_DIR_REQUEST,
        READ_ATTR_DIR_REPLY,
        READ_ATTR_REQUEST,
        READ_ATTR_REPLY,
        WRITE_ATTR_REQUEST,
        WRITE_ATTR_REPLY,
        REMOVE_ATTR_REQUEST,
        REMOVE_ATTR_REPLY,
        RENAME_ATTR_REQUEST,
        RENAME_ATTR_REPLY,
        STAT_ATTR_REQUEST,
        STAT_ATTR_REPLY,

        OPEN_QUERY_REQUEST,
        OPEN_QUERY_REPLY,
        READ_QUERY_REQUEST,
        READ_QUERY_REPLY,

        // node monitoring notifications
        ENTRY_CREATED_REQUEST,
        ENTRY_REMOVED_REQUEST,
        ENTRY_MOVED_REQUEST,
        ENTRY_STAT_CHANGED_REQUEST,
        ENTRY_ATTRIBUTE_CHANGED_REQUEST,

        // server info
        SERVER_INFO_REQUEST,
};

struct ConnectionBrokenRequest;
struct InitConnectionRequest;
struct InitConnectionReply;

struct MountRequest;
struct MountReply;
struct UnmountRequest;
struct ReadVNodeRequest;
struct ReadVNodeReply;
struct WriteStatRequest;
struct WriteStatReply;
struct CreateFileRequest;
struct CreateFileReply;
struct OpenRequest;
struct OpenReply;
struct CloseRequest;
struct CloseReply;
struct ReadRequest;
struct ReadReply;
struct WriteRequest;
struct WriteReply;
struct CreateLinkRequest;
struct CreateLinkReply;
struct UnlinkRequest;
struct UnlinkReply;
struct CreateSymlinkRequest;
struct CreateSymlinkReply;
struct ReadLinkRequest;
struct ReadLinkReply;
struct RenameRequest;
struct RenameReply;
struct RemoveDirRequest;
struct RemoveDirReply;
struct MakeDirRequest;
struct MakeDirReply;
struct OpenDirRequest;
struct OpenDirReply;
struct ReadDirRequest;
struct ReadDirReply;
struct WalkRequest;
struct WalkReply;
struct MultiWalkRequest;
struct MultiWalkReply;

struct OpenAttrDirRequest;
struct OpenAttrDirReply;
struct ReadAttrDirRequest;
struct ReadAttrDirReply;
struct ReadAttrRequest;
struct ReadAttrReply;
struct WriteAttrRequest;
struct WriteAttrReply;
struct RemoveAttrRequest;
struct RemoveAttrReply;
struct RenameAttrRequest;
struct RenameAttrReply;
struct StatAttrRequest;
struct StatAttrReply;

struct OpenQueryRequest;
struct OpenQueryReply;
struct ReadQueryRequest;
struct ReadQueryReply;

struct NodeMonitoringRequest;
struct EntryCreatedRequest;
struct EntryRemovedRequest;
struct EntryMovedRequest;
struct StatChangedRequest;
struct AttributeChangedRequest;

struct ServerInfoRequest;

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

        virtual status_t                        VisitConnectionBrokenRequest(
                                                                        ConnectionBrokenRequest* request);
        virtual status_t                        VisitInitConnectionRequest(
                                                                        InitConnectionRequest* request);
        virtual status_t                        VisitInitConnectionReply(
                                                                        InitConnectionReply* request);

        virtual status_t                        VisitMountRequest(MountRequest* request);
        virtual status_t                        VisitMountReply(MountReply* request);
        virtual status_t                        VisitUnmountRequest(UnmountRequest* request);
        virtual status_t                        VisitReadVNodeRequest(
                                                                        ReadVNodeRequest* request);
        virtual status_t                        VisitReadVNodeReply(ReadVNodeReply* request);
        virtual status_t                        VisitWriteStatRequest(
                                                                        WriteStatRequest* request);
        virtual status_t                        VisitWriteStatReply(WriteStatReply* request);
        virtual status_t                        VisitCreateFileRequest(
                                                                        CreateFileRequest* request);
        virtual status_t                        VisitCreateFileReply(CreateFileReply* request);
        virtual status_t                        VisitOpenRequest(OpenRequest* request);
        virtual status_t                        VisitOpenReply(OpenReply* request);
        virtual status_t                        VisitCloseRequest(CloseRequest* request);
        virtual status_t                        VisitCloseReply(CloseReply* request);
        virtual status_t                        VisitReadRequest(ReadRequest* request);
        virtual status_t                        VisitReadReply(ReadReply* request);
        virtual status_t                        VisitWriteRequest(WriteRequest* request);
        virtual status_t                        VisitWriteReply(WriteReply* request);
        virtual status_t                        VisitCreateLinkRequest(
                                                                        CreateLinkRequest* request);
        virtual status_t                        VisitCreateLinkReply(CreateLinkReply* request);
        virtual status_t                        VisitUnlinkRequest(UnlinkRequest* request);
        virtual status_t                        VisitUnlinkReply(UnlinkReply* request);
        virtual status_t                        VisitCreateSymlinkRequest(
                                                                        CreateSymlinkRequest* request);
        virtual status_t                        VisitCreateSymlinkReply(
                                                                        CreateSymlinkReply* request);
        virtual status_t                        VisitReadLinkRequest(ReadLinkRequest* request);
        virtual status_t                        VisitReadLinkReply(ReadLinkReply* request);
        virtual status_t                        VisitRenameRequest(RenameRequest* request);
        virtual status_t                        VisitRenameReply(RenameReply* request);
        virtual status_t                        VisitMakeDirRequest(MakeDirRequest* request);
        virtual status_t                        VisitMakeDirReply(MakeDirReply* request);
        virtual status_t                        VisitRemoveDirRequest(
                                                                        RemoveDirRequest* request);
        virtual status_t                        VisitRemoveDirReply(RemoveDirReply* request);
        virtual status_t                        VisitOpenDirRequest(OpenDirRequest* request);
        virtual status_t                        VisitOpenDirReply(OpenDirReply* request);
        virtual status_t                        VisitReadDirRequest(ReadDirRequest* request);
        virtual status_t                        VisitReadDirReply(ReadDirReply* request);
        virtual status_t                        VisitWalkRequest(WalkRequest* request);
        virtual status_t                        VisitWalkReply(WalkReply* request);
        virtual status_t                        VisitMultiWalkRequest(
                                                                        MultiWalkRequest* request);
        virtual status_t                        VisitMultiWalkReply(MultiWalkReply* request);

        virtual status_t                        VisitOpenAttrDirRequest(
                                                                        OpenAttrDirRequest* request);
        virtual status_t                        VisitOpenAttrDirReply(
                                                                        OpenAttrDirReply* request);
        virtual status_t                        VisitReadAttrDirRequest(
                                                                        ReadAttrDirRequest* request);
        virtual status_t                        VisitReadAttrDirReply(
                                                                        ReadAttrDirReply* request);
        virtual status_t                        VisitReadAttrRequest(ReadAttrRequest* request);
        virtual status_t                        VisitReadAttrReply(ReadAttrReply* request);
        virtual status_t                        VisitWriteAttrRequest(
                                                                        WriteAttrRequest* request);
        virtual status_t                        VisitWriteAttrReply(WriteAttrReply* request);
        virtual status_t                        VisitRemoveAttrRequest(
                                                                        RemoveAttrRequest* request);
        virtual status_t                        VisitRemoveAttrReply(RemoveAttrReply* request);
        virtual status_t                        VisitRenameAttrRequest(
                                                                        RenameAttrRequest* request);
        virtual status_t                        VisitRenameAttrReply(RenameAttrReply* request);
        virtual status_t                        VisitStatAttrRequest(StatAttrRequest* request);
        virtual status_t                        VisitStatAttrReply(StatAttrReply* request);

        virtual status_t                        VisitOpenQueryRequest(
                                                                        OpenQueryRequest* request);
        virtual status_t                        VisitOpenQueryReply(OpenQueryReply* request);
        virtual status_t                        VisitReadQueryRequest(
                                                                        ReadQueryRequest* request);
        virtual status_t                        VisitReadQueryReply(ReadQueryReply* request);

        virtual status_t                        VisitNodeMonitoringRequest(
                                                                        NodeMonitoringRequest* request);
        virtual status_t                        VisitEntryCreatedRequest(
                                                                        EntryCreatedRequest* request);
        virtual status_t                        VisitEntryRemovedRequest(
                                                                        EntryRemovedRequest* request);
        virtual status_t                        VisitEntryMovedRequest(
                                                                        EntryMovedRequest* request);
        virtual status_t                        VisitStatChangedRequest(
                                                                        StatChangedRequest* request);
        virtual status_t                        VisitAttributeChangedRequest(
                                                                        AttributeChangedRequest* request);

        virtual status_t                        VisitServerInfoRequest(
                                                                        ServerInfoRequest* request);

        virtual status_t                        VisitAny(Request* request);
};

// ReplyRequest
struct ReplyRequest : Request {
        ReplyRequest(uint32 type) : Request(type) {}

        status_t                error;
};

// VolumeRequest
struct VolumeRequest : Request {
        VolumeRequest(uint32 type) : Request(type) {}

        int32                   volumeID;
};

// ConnectionBrokenRequest
struct ConnectionBrokenRequest : Request {
        ConnectionBrokenRequest() : Request(CONNECTION_BROKEN_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitConnectionBrokenRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }

        status_t                error;
};

// InitConnectionRequest
struct InitConnectionRequest : Request {
        InitConnectionRequest() : Request(INIT_CONNECTION_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitInitConnectionRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, bigEndian);
        }

        bool                    bigEndian;
};

// InitConnectionReply
struct InitConnectionReply : ReplyRequest {
        InitConnectionReply() : ReplyRequest(INIT_CONNECTION_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitInitConnectionReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// MountRequest
struct MountRequest : Request {
        MountRequest() : Request(MOUNT_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitMountRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, share);
                visitor->Visit(this, user);
                visitor->Visit(this, password);
                visitor->Visit(this, flags);
        }

        StringData              share;
        StringData              user;           // can be NULL, if the connection supports
        StringData              password;       // authentication; otherwise NULL means anonymous
        uint32                  flags;
};

// MountReply
struct MountReply : ReplyRequest {
        MountReply() : ReplyRequest(MOUNT_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitMountReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, volumeID);
                visitor->Visit(this, sharePermissions);
                visitor->Visit(this, nodeInfo);
                visitor->Visit(this, noPermission);
        }

        int32                   volumeID;
        uint32                  sharePermissions;
        NodeInfo                nodeInfo;
        bool                    noPermission;   // always set (just as error)
};

// UnmountRequest
struct UnmountRequest : VolumeRequest {
        UnmountRequest() : VolumeRequest(UNMOUNT_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitUnmountRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
        }
};

// ReadVNodeRequest
struct ReadVNodeRequest : VolumeRequest {
        ReadVNodeRequest() : VolumeRequest(READ_VNODE_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadVNodeRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
        }

        ServerNodeID            nodeID;
};

// ReadVNodeReply
struct ReadVNodeReply : ReplyRequest {
        ReadVNodeReply() : ReplyRequest(READ_VNODE_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadVNodeReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, nodeInfo);
        }

        NodeInfo                nodeInfo;
};

// WriteStatRequest
struct WriteStatRequest : VolumeRequest {
        WriteStatRequest() : VolumeRequest(WRITE_STAT_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitWriteStatRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, nodeInfo);
                visitor->Visit(this, mask);
        }

        ServerNodeID    nodeID;
        NodeInfo                nodeInfo;
        uint32                  mask;
};

// WriteStatReply
struct WriteStatReply : ReplyRequest {
        WriteStatReply() : ReplyRequest(WRITE_STAT_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitWriteStatReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, nodeInfo);
                visitor->Visit(this, nodeInfoValid);
        }

        NodeInfo                nodeInfo;
        bool                    nodeInfoValid;
};

// CreateFileRequest
struct CreateFileRequest : VolumeRequest {
        CreateFileRequest() : VolumeRequest(CREATE_FILE_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitCreateFileRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, directoryID);
                visitor->Visit(this, name);
                visitor->Visit(this, openMode);
                visitor->Visit(this, mode);
        }

        ServerNodeID    directoryID;
        StringData              name;
        int32                   openMode;
        uint32                  mode;
};

// CreateFileReply
struct CreateFileReply : ReplyRequest {
        CreateFileReply() : ReplyRequest(CREATE_FILE_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitCreateFileReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, entryInfo);
                visitor->Visit(this, cookie);
        }

        EntryInfo               entryInfo;
        intptr_t                cookie;
};

// OpenRequest
struct OpenRequest : VolumeRequest {
        OpenRequest() : VolumeRequest(OPEN_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitOpenRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, openMode);
        }

        ServerNodeID    nodeID;
        int32                   openMode;
};

// OpenReply
struct OpenReply : ReplyRequest {
        OpenReply() : ReplyRequest(OPEN_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitOpenReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, nodeInfo);
                visitor->Visit(this, cookie);
        }

        NodeInfo                nodeInfo;
        intptr_t                cookie;
};

// CloseRequest
struct CloseRequest : VolumeRequest {
        CloseRequest() : VolumeRequest(CLOSE_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitCloseRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, cookie);
        }

        intptr_t                cookie;
};

// CloseReply
struct CloseReply : ReplyRequest {
        CloseReply() : ReplyRequest(CLOSE_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitCloseReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }

};

// ReadRequest
struct ReadRequest : VolumeRequest {
        ReadRequest() : VolumeRequest(READ_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, cookie);
                visitor->Visit(this, pos);
                visitor->Visit(this, size);
        }

        intptr_t                cookie;
        off_t                   pos;
        int32                   size;
};

// ReadReply
struct ReadReply : ReplyRequest {
        ReadReply() : ReplyRequest(READ_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, pos);
                visitor->Visit(this, data);
                visitor->Visit(this, moreToCome);
        }

        off_t                   pos;
        Data                    data;
        bool                    moreToCome;
};

// WriteRequest
struct WriteRequest : VolumeRequest {
        WriteRequest() : VolumeRequest(WRITE_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitWriteRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, cookie);
                visitor->Visit(this, pos);
                visitor->Visit(this, data);
        }

        intptr_t                cookie;
        off_t                   pos;
        Data                    data;
};

// WriteReply
struct WriteReply : ReplyRequest {
        WriteReply() : ReplyRequest(WRITE_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitWriteReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// CreateLinkRequest
struct CreateLinkRequest : VolumeRequest {
        CreateLinkRequest() : VolumeRequest(CREATE_LINK_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitCreateLinkRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, directoryID);
                visitor->Visit(this, name);
                visitor->Visit(this, nodeID);
        }

        ServerNodeID    directoryID;
        StringData              name;
        ServerNodeID    nodeID;
};

// CreateLinkReply
struct CreateLinkReply : ReplyRequest {
        CreateLinkReply() : ReplyRequest(CREATE_LINK_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitCreateLinkReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// UnlinkRequest
struct UnlinkRequest : VolumeRequest {
        UnlinkRequest() : VolumeRequest(UNLINK_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitUnlinkRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, directoryID);
                visitor->Visit(this, name);
        }

        ServerNodeID    directoryID;
        StringData              name;
};

// UnlinkReply
struct UnlinkReply : ReplyRequest {
        UnlinkReply() : ReplyRequest(UNLINK_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitUnlinkReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// CreateSymlinkRequest
struct CreateSymlinkRequest : VolumeRequest {
        CreateSymlinkRequest() : VolumeRequest(CREATE_SYMLINK_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitCreateSymlinkRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, directoryID);
                visitor->Visit(this, name);
                visitor->Visit(this, target);
        }

        ServerNodeID    directoryID;
        StringData              name;
        StringData              target;
};

// CreateSymlinkReply
struct CreateSymlinkReply : ReplyRequest {
        CreateSymlinkReply() : ReplyRequest(CREATE_SYMLINK_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitCreateSymlinkReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// ReadLinkRequest
struct ReadLinkRequest : VolumeRequest {
        ReadLinkRequest() : VolumeRequest(READ_LINK_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadLinkRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, maxSize);
        }

        ServerNodeID    nodeID;
        int32                   maxSize;
};

// ReadLinkReply
struct ReadLinkReply : ReplyRequest {
        ReadLinkReply() : ReplyRequest(READ_LINK_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadLinkReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, nodeInfo);
                visitor->Visit(this, data);
        }

        NodeInfo                nodeInfo;
        Data                    data;
};

// RenameRequest
struct RenameRequest : VolumeRequest {
        RenameRequest() : VolumeRequest(RENAME_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitRenameRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, oldDirectoryID);
                visitor->Visit(this, oldName);
                visitor->Visit(this, newDirectoryID);
                visitor->Visit(this, newName);
        }

        ServerNodeID    oldDirectoryID;
        StringData              oldName;
        ServerNodeID    newDirectoryID;
        StringData              newName;
};

// RenameReply
struct RenameReply : ReplyRequest {
        RenameReply() : ReplyRequest(RENAME_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitRenameReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// MakeDirRequest
struct MakeDirRequest : VolumeRequest {
        MakeDirRequest() : VolumeRequest(MAKE_DIR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitMakeDirRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, directoryID);
                visitor->Visit(this, name);
                visitor->Visit(this, mode);
        }

        ServerNodeID    directoryID;
        StringData              name;
        uint32                  mode;
};

// MakeDirReply
struct MakeDirReply : ReplyRequest {
        MakeDirReply() : ReplyRequest(MAKE_DIR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitMakeDirReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// RemoveDirRequest
struct RemoveDirRequest : VolumeRequest {
        RemoveDirRequest() : VolumeRequest(REMOVE_DIR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitRemoveDirRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, directoryID);
                visitor->Visit(this, name);
        }

        ServerNodeID    directoryID;
        StringData              name;
};

// RemoveDirReply
struct RemoveDirReply : ReplyRequest {
        RemoveDirReply() : ReplyRequest(REMOVE_DIR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitRemoveDirReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// OpenDirRequest
struct OpenDirRequest : VolumeRequest {
        OpenDirRequest() : VolumeRequest(OPEN_DIR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitOpenDirRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
        }

        ServerNodeID    nodeID;
};

// OpenDirReply
struct OpenDirReply : ReplyRequest {
        OpenDirReply() : ReplyRequest(OPEN_DIR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitOpenDirReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, nodeInfo);
                visitor->Visit(this, cookie);
        }

        NodeInfo                nodeInfo;
        intptr_t                cookie;
};

// ReadDirRequest
struct ReadDirRequest : VolumeRequest {
        ReadDirRequest() : VolumeRequest(READ_DIR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadDirRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, cookie);
                visitor->Visit(this, count);
                visitor->Visit(this, rewind);
        }

        intptr_t                cookie;
        int32                   count;
        bool                    rewind;
};

// ReadDirReply
struct ReadDirReply : ReplyRequest {
        ReadDirReply() : ReplyRequest(READ_DIR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadDirReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, entryInfos);
                visitor->Visit(this, revision);
                visitor->Visit(this, done);
        }

        RequestMemberArray<EntryInfo> entryInfos;
        int64                   revision;
        bool                    done;
};

// WalkRequest
struct WalkRequest : VolumeRequest {
        WalkRequest() : VolumeRequest(WALK_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitWalkRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, name);
                visitor->Visit(this, resolveLink);
        }

        ServerNodeID    nodeID;
        StringData              name;
        bool                    resolveLink;
};

// WalkReply
struct WalkReply : ReplyRequest {
        WalkReply() : ReplyRequest(WALK_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitWalkReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, entryInfo);
                visitor->Visit(this, linkPath);
        }

        EntryInfo               entryInfo;
        StringData              linkPath;
};

// MulitWalkRequest
struct MultiWalkRequest : VolumeRequest {
        MultiWalkRequest() : VolumeRequest(MULTI_WALK_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitMultiWalkRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, names);
        }

        ServerNodeID    nodeID;
        RequestMemberArray<StringData> names;
};

// MultiWalkReply
struct MultiWalkReply : ReplyRequest {
        MultiWalkReply() : ReplyRequest(MULTI_WALK_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitMultiWalkReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, entryInfos);
        }

        RequestMemberArray<EntryInfo> entryInfos;
};

// OpenAttrDirRequest
struct OpenAttrDirRequest : VolumeRequest {
        OpenAttrDirRequest() : VolumeRequest(OPEN_ATTR_DIR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitOpenAttrDirRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
        }

        ServerNodeID    nodeID;
};

// OpenAttrDirReply
struct OpenAttrDirReply : ReplyRequest {
        OpenAttrDirReply() : ReplyRequest(OPEN_ATTR_DIR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitOpenAttrDirReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, attrDirInfo);
                visitor->Visit(this, cookie);
        }

        AttrDirInfo             attrDirInfo;
        intptr_t                cookie;
};

// ReadAttrDirRequest
struct ReadAttrDirRequest : VolumeRequest {
        ReadAttrDirRequest() : VolumeRequest(READ_ATTR_DIR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadAttrDirRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, cookie);
                visitor->Visit(this, rewind);
        }

        intptr_t                cookie;
        int32                   count;
        bool                    rewind;
};

// ReadAttrDirReply
struct ReadAttrDirReply : ReplyRequest {
        ReadAttrDirReply() : ReplyRequest(READ_ATTR_DIR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadAttrDirReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, name);
                visitor->Visit(this, count);
        }

        StringData              name;   // TODO: This should be a list.
        int32                   count;
};

// ReadAttrRequest
struct ReadAttrRequest : VolumeRequest {
        ReadAttrRequest() : VolumeRequest(READ_ATTR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadAttrRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, name);
                visitor->Visit(this, type);
                visitor->Visit(this, pos);
                visitor->Visit(this, size);
        }

        ServerNodeID    nodeID;
        StringData              name;
        uint32                  type;
        off_t                   pos;
        int32                   size;
};

// ReadAttrReply
struct ReadAttrReply : ReplyRequest {
        ReadAttrReply() : ReplyRequest(READ_ATTR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadAttrReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, pos);
                visitor->Visit(this, data);
                visitor->Visit(this, moreToCome);
        }

        off_t                   pos;
        Data                    data;
        bool                    moreToCome;
};

// WriteAttrRequest
struct WriteAttrRequest : VolumeRequest {
        WriteAttrRequest() : VolumeRequest(WRITE_ATTR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitWriteAttrRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, name);
                visitor->Visit(this, type);
                visitor->Visit(this, pos);
                visitor->Visit(this, data);
        }

        ServerNodeID    nodeID;
        StringData              name;
        uint32                  type;
        off_t                   pos;
        Data                    data;
};

// WriteAttrReply
struct WriteAttrReply : ReplyRequest {
        WriteAttrReply() : ReplyRequest(WRITE_ATTR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitWriteAttrReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// RemoveAttrRequest
struct RemoveAttrRequest : VolumeRequest {
        RemoveAttrRequest() : VolumeRequest(REMOVE_ATTR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitRemoveAttrRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, name);
        }

        ServerNodeID    nodeID;
        StringData              name;
};

// RemoveAttrReply
struct RemoveAttrReply : ReplyRequest {
        RemoveAttrReply() : ReplyRequest(REMOVE_ATTR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitRemoveAttrReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// RenameAttrRequest
struct RenameAttrRequest : VolumeRequest {
        RenameAttrRequest() : VolumeRequest(RENAME_ATTR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitRenameAttrRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, oldName);
                visitor->Visit(this, newName);
        }

        ServerNodeID    nodeID;
        StringData              oldName;
        StringData              newName;
};

// RenameAttrReply
struct RenameAttrReply : ReplyRequest {
        RenameAttrReply() : ReplyRequest(RENAME_ATTR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitRenameAttrReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
        }
};

// StatAttrRequest
struct StatAttrRequest : VolumeRequest {
        StatAttrRequest() : VolumeRequest(STAT_ATTR_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitStatAttrRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, name);
        }

        ServerNodeID    nodeID;
        StringData              name;
};

// StatAttrReply
struct StatAttrReply : ReplyRequest {
        StatAttrReply() : ReplyRequest(STAT_ATTR_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitStatAttrReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, attrInfo);
        }

        AttributeInfo   attrInfo;
};

// OpenQueryRequest
struct OpenQueryRequest : Request {
        OpenQueryRequest() : Request(OPEN_QUERY_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitOpenQueryRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, queryString);
                visitor->Visit(this, flags);
                visitor->Visit(this, port);
                visitor->Visit(this, token);
        }

        StringData              queryString;
        uint32                  flags;
        int32                   port;
        int32                   token;
};

// OpenQueryReply
struct OpenQueryReply : ReplyRequest {
        OpenQueryReply() : ReplyRequest(OPEN_QUERY_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitOpenQueryReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, cookie);
        }

        intptr_t                cookie;
};

// ReadQueryRequest
struct ReadQueryRequest : Request {
        ReadQueryRequest() : Request(READ_QUERY_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadQueryRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, cookie);
        }

        intptr_t                cookie;
        int32                   count;
};

// ReadQueryReply
struct ReadQueryReply : ReplyRequest {
        ReadQueryReply() : ReplyRequest(READ_QUERY_REPLY) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitReadQueryReply(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, error);
                visitor->Visit(this, clientVolumeIDs);
                visitor->Visit(this, dirInfo);
                visitor->Visit(this, entryInfo);
                visitor->Visit(this, count);
        }

        RequestMemberArray<int32>       clientVolumeIDs;
        NodeInfo                                        dirInfo;        // TODO: This should be a list.
        EntryInfo                                       entryInfo;      //
        int32                                           count;
};

// NodeMonitoringRequest
struct NodeMonitoringRequest : VolumeRequest {
        NodeMonitoringRequest(uint32 type) : VolumeRequest(type) {}

        int32                   opcode;
        int64                   revision;
        ServerNodeID    nodeID;
        bool                    queryUpdate;    // true, if this is a query update
        int32                   port;                   // for query updates
        int32                   token;                  //
};

// EntryCreatedRequest
struct EntryCreatedRequest : NodeMonitoringRequest {
        EntryCreatedRequest() : NodeMonitoringRequest(ENTRY_CREATED_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitEntryCreatedRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, opcode);
                visitor->Visit(this, revision);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, queryUpdate);
                visitor->Visit(this, port);
                visitor->Visit(this, token);
                visitor->Visit(this, directoryID);
                visitor->Visit(this, name);
                visitor->Visit(this, entryInfo);
                visitor->Visit(this, entryInfoValid);
        }

        ServerNodeID    directoryID;
        StringData              name;
        EntryInfo               entryInfo;
        bool                    entryInfoValid;
};

// EntryRemovedRequest
struct EntryRemovedRequest : NodeMonitoringRequest {
        EntryRemovedRequest() : NodeMonitoringRequest(ENTRY_REMOVED_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitEntryRemovedRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, opcode);
                visitor->Visit(this, revision);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, queryUpdate);
                visitor->Visit(this, port);
                visitor->Visit(this, token);
                visitor->Visit(this, directoryID);
                visitor->Visit(this, name);
        }

        ServerNodeID    directoryID;
        StringData              name;
};

// EntryMovedRequest
struct EntryMovedRequest : NodeMonitoringRequest {
        EntryMovedRequest() : NodeMonitoringRequest(ENTRY_MOVED_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitEntryMovedRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, opcode);
                visitor->Visit(this, revision);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, queryUpdate);
                visitor->Visit(this, port);
                visitor->Visit(this, token);
                visitor->Visit(this, fromDirectoryID);
                visitor->Visit(this, toDirectoryID);
                visitor->Visit(this, fromName);
                visitor->Visit(this, toName);
                visitor->Visit(this, entryInfo);
                visitor->Visit(this, entryInfoValid);
        }

        ServerNodeID    fromDirectoryID;
        ServerNodeID    toDirectoryID;
        StringData              fromName;
        StringData              toName;
        EntryInfo               entryInfo;
        bool                    entryInfoValid;
};

// StatChangedRequest
struct StatChangedRequest : NodeMonitoringRequest {
        StatChangedRequest() : NodeMonitoringRequest(ENTRY_STAT_CHANGED_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitStatChangedRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, opcode);
                visitor->Visit(this, revision);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, queryUpdate);
                visitor->Visit(this, port);
                visitor->Visit(this, token);
                visitor->Visit(this, nodeInfo);
        }

        NodeInfo                nodeInfo;
};

// AttributeChangedRequest
struct AttributeChangedRequest : NodeMonitoringRequest {
        AttributeChangedRequest()
                : NodeMonitoringRequest(ENTRY_ATTRIBUTE_CHANGED_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitAttributeChangedRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, volumeID);
                visitor->Visit(this, opcode);
                visitor->Visit(this, revision);
                visitor->Visit(this, nodeID);
                visitor->Visit(this, queryUpdate);
                visitor->Visit(this, port);
                visitor->Visit(this, token);
                visitor->Visit(this, attrDirInfo);
                visitor->Visit(this, attrInfo);
                visitor->Visit(this, valid);
                visitor->Visit(this, removed);
        }

        AttrDirInfo             attrDirInfo;
        AttributeInfo   attrInfo;
        bool                    valid;
        bool                    removed;
};

// ServerInfoRequest
struct ServerInfoRequest : Request {
        ServerInfoRequest() : Request(SERVER_INFO_REQUEST) {}
        virtual status_t Accept(RequestVisitor* visitor)
                { return visitor->VisitServerInfoRequest(this); }
        virtual void ShowAround(RequestMemberVisitor* visitor)
        {
                visitor->Visit(this, serverInfo);
        }

        ServerInfo              serverInfo;
};

#endif  // NET_FS_REQUESTS_H