haiku.git

// ShareNode.cpp

#include "ShareNode.h"

#include "ShareAttrDir.h"

// constructor
ShareDirEntry::ShareDirEntry(ShareDir* directory, const char* name,
	ShareNode* node)
	:
	BReferenceable(),
	fDirectory(directory),
	fName(name),
	fNode(node),
	fRevision(-1)
{
}

// destructor
ShareDirEntry::~ShareDirEntry()
{
}

// InitCheck
status_t
ShareDirEntry::InitCheck() const
{
	if (fName.GetLength() == 0)
		return B_NO_MEMORY;

	return B_OK;
}

// GetDirectory
ShareDir*
ShareDirEntry::GetDirectory() const
{
	return fDirectory;
}

// GetName
const char*
ShareDirEntry::GetName() const
{
	return fName.GetString();
}

// GetNode
ShareNode*
ShareDirEntry::GetNode() const
{
	return fNode;
}

// SetRevision
void
ShareDirEntry::SetRevision(int64 revision)
{
	fRevision = revision;
}

// GetRevision
int64
ShareDirEntry::GetRevision() const
{
	return fRevision;
}

// IsActualEntry
bool
ShareDirEntry::IsActualEntry() const
{
	return (fName.GetLength() > 0 && fName != "." && fName != "..");
}


// #pragma mark -

// constructor
ShareNode::ShareNode(Volume* volume, vnode_id id, const NodeInfo* nodeInfo)
	:
	Node(volume, id),
	fInfo(),
	fReferringEntries(),
	fAttrDir(NULL)
{
	if (nodeInfo) {
		fInfo = *nodeInfo;
	} else {
		// init the stat data at least a bit, if no node info is given
		fInfo.st.st_dev = -1;
		fInfo.st.st_ino = -1;
		fInfo.st.st_mode = S_IFDIR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP
			| S_IROTH | S_IXOTH;
		fInfo.st.st_nlink = 1;
		fInfo.st.st_size = 1;
		fInfo.st.st_blksize = 1024;
		fInfo.st.st_crtime = 0;
		fInfo.st.st_ctime = fInfo.st.st_mtime = fInfo.st.st_atime
			= fInfo.st.st_crtime;

		// negative revision, to make sure it is updated
		fInfo.revision = -1;
	}
}

// destructor
ShareNode::~ShareNode()
{
	delete fAttrDir;
}

// GetNodeInfo
const NodeInfo&
ShareNode::GetNodeInfo() const
{
	return fInfo;
}

// GetRemoteID
NodeID
ShareNode::GetRemoteID() const
{
	return fInfo.GetID();
}

// Update
void
ShareNode::Update(const NodeInfo& nodeInfo)
{
	if (fInfo.revision < nodeInfo.revision)
		fInfo = nodeInfo;
}

// AddReferringEntry
void
ShareNode::AddReferringEntry(ShareDirEntry* entry)
{
	if (entry)
		fReferringEntries.Insert(entry);
}

// RemoveReferringEntry
void
ShareNode::RemoveReferringEntry(ShareDirEntry* entry)
{
	if (entry)
		fReferringEntries.Remove(entry);
}

// GetFirstReferringEntry
ShareDirEntry*
ShareNode::GetFirstReferringEntry() const
{
	return fReferringEntries.GetFirst();
}

// GetNextReferringEntry
ShareDirEntry*
ShareNode::GetNextReferringEntry(ShareDirEntry* entry) const
{
	return (entry ? fReferringEntries.GetNext(entry) : NULL);
}

// GetActualReferringEntry
ShareDirEntry*
ShareNode::GetActualReferringEntry() const
{
	for (ShareDirEntry* entry = GetFirstReferringEntry();
		 entry;
		 entry = GetNextReferringEntry(entry)) {
		if (entry->IsActualEntry())
			return entry;
	}

	return NULL;
}

// SetAttrDir
void
ShareNode::SetAttrDir(ShareAttrDir* attrDir)
{
	delete fAttrDir;
	fAttrDir = attrDir;
}

// GetAttrDir
ShareAttrDir*
ShareNode::GetAttrDir() const
{
	return fAttrDir;
}


// #pragma mark -

// constructor
ShareDirIterator::ShareDirIterator()
{
}

// destructor
ShareDirIterator::~ShareDirIterator()
{
}


// #pragma mark -

// constructor
LocalShareDirIterator::LocalShareDirIterator()
	: fDirectory(NULL),
	  fCurrentEntry(NULL)
{
}

// destructor
LocalShareDirIterator::~LocalShareDirIterator()
{
	SetDirectory(NULL);
}

// SetDirectory
void
LocalShareDirIterator::SetDirectory(ShareDir* directory)
{
	// unset the old directory
	if (fDirectory)
		fDirectory->RemoveDirIterator(this);

	// set the new directory
	fDirectory = directory;
	if (fDirectory) {
		fDirectory->AddDirIterator(this);
		fCurrentEntry = fDirectory->GetFirstEntry();
	}
}

// GetCurrentEntry
ShareDirEntry*
LocalShareDirIterator::GetCurrentEntry() const
{
	return fCurrentEntry;
}

// NextEntry
void
LocalShareDirIterator::NextEntry()
{
	if (!fDirectory || !fCurrentEntry)
		return;

	fCurrentEntry = fDirectory->GetNextEntry(fCurrentEntry);
}

// Rewind
void
LocalShareDirIterator::Rewind()
{
	fCurrentEntry = (fDirectory ? fDirectory->GetFirstEntry() : NULL);
}

// IsDone
bool
LocalShareDirIterator::IsDone() const
{
	return !fCurrentEntry;
}


// #pragma mark -

// constructor
RemoteShareDirIterator::RemoteShareDirIterator()
	: fCookie(-1),
	  fCapacity(kRemoteShareDirIteratorCapacity),
	  fCount(0),
	  fIndex(0),
	  fRevision(-1),
	  fDone(false),
	  fRewind(false)
{
}

// destructor
RemoteShareDirIterator::~RemoteShareDirIterator()
{
	Clear();
}

// GetCurrentEntry
ShareDirEntry*
RemoteShareDirIterator::GetCurrentEntry() const
{
	return (!fRewind && fIndex < fCount ? fEntries[fIndex] : NULL);
}

// NextEntry
void
RemoteShareDirIterator::NextEntry()
{
	if (fIndex < fCount)
		fIndex++;
}

// Rewind
void
RemoteShareDirIterator::Rewind()
{
	fRewind = true;
	fDone = false;
}

// IsDone
bool
RemoteShareDirIterator::IsDone() const
{
	return fDone;
}

// GetCapacity
int32
RemoteShareDirIterator::GetCapacity() const
{
	return fCapacity;
}

// SetCookie
void
RemoteShareDirIterator::SetCookie(int32 cookie)
{
	fCookie = cookie;
}

// GetCookie
int32
RemoteShareDirIterator::GetCookie() const
{
	return fCookie;
}

// Clear
void
RemoteShareDirIterator::Clear()
{
	for (int32 i = 0; i < fCount; i++)
		fEntries[i]->ReleaseReference();
	fCount = 0;
	fIndex = 0;
	fDone = false;
	fRewind = false;
}

// AddEntry
bool
RemoteShareDirIterator::AddEntry(ShareDirEntry* entry)
{
	if (!entry || fCount >= fCapacity)
		return false;

	fEntries[fCount++] = entry;
	entry->AcquireReference();
	return true;
}

// SetRevision
void
RemoteShareDirIterator::SetRevision(int64 revision)
{
	fRevision = revision;
}

// GetRevision
int64
RemoteShareDirIterator::GetRevision() const
{
	return fRevision;
}

// SetDone
void
RemoteShareDirIterator::SetDone(bool done)
{
	fDone = done;
}

// GetRewind
bool
RemoteShareDirIterator::GetRewind() const
{
	return fRewind;
}


// #pragma mark -

// constructor
ShareDir::ShareDir(Volume* volume, vnode_id id, const NodeInfo* nodeInfo)
	: ShareNode(volume, id, nodeInfo),
	  fEntries(),
	  fIterators(),
	  fEntryCreatedEventRevision(-1),
	  fEntryRemovedEventRevision(-1),
	  fIsComplete(false)
{
}

// destructor
ShareDir::~ShareDir()
{
}

// UpdateEntryCreatedEventRevision
void
ShareDir::UpdateEntryCreatedEventRevision(int64 revision)
{
	if (revision > fEntryCreatedEventRevision)
		fEntryCreatedEventRevision = revision;
}

// GetEntryCreatedEventRevision
int64
ShareDir::GetEntryCreatedEventRevision() const
{
	return fEntryCreatedEventRevision;
}

// UpdateEntryRemovedEventRevision
void
ShareDir::UpdateEntryRemovedEventRevision(int64 revision)
{
	if (revision > fEntryRemovedEventRevision)
		fEntryRemovedEventRevision = revision;
}

// GetEntryRemovedEventRevision
int64
ShareDir::GetEntryRemovedEventRevision() const
{
	return fEntryRemovedEventRevision;
}

// SetComplete
void
ShareDir::SetComplete(bool complete)
{
	fIsComplete = complete;
}

// IsComplete
bool
ShareDir::IsComplete() const
{
	return fIsComplete;
}

// AddEntry
void
ShareDir::AddEntry(ShareDirEntry* entry)
{
	if (entry)
		fEntries.Insert(entry);
}

// RemoveEntry
void
ShareDir::RemoveEntry(ShareDirEntry* entry)
{
	if (entry) {
		// update the directory iterators pointing to the removed entry
		for (LocalShareDirIterator* iterator = fIterators.First();
			 iterator;
			 iterator = fIterators.GetNext(iterator)) {
			if (iterator->GetCurrentEntry() == entry)
				iterator->NextEntry();
		}

		fEntries.Remove(entry);
	}
}

// GetFirstEntry
ShareDirEntry*
ShareDir::GetFirstEntry() const
{
	return fEntries.First();
}

// GetNextEntry
ShareDirEntry*
ShareDir::GetNextEntry(ShareDirEntry* entry) const
{
	if (!entry)
		return NULL;

	return fEntries.GetNext(entry);
}

// AddDirIterator
void
ShareDir::AddDirIterator(LocalShareDirIterator* iterator)
{
	if (!iterator)
		return;

	fIterators.Insert(iterator);
}

// RemoveDirIterator
void
ShareDir::RemoveDirIterator(LocalShareDirIterator* iterator)
{
	if (!iterator)
		return;

	fIterators.Remove(iterator);
}