// ServerInfo.cpp

#include "RequestFlattener.h"
#include "RequestUnflattener.h"
#include "ServerInfo.h"

// VisitString
static
void
VisitString(RequestMember* member, RequestMemberVisitor* visitor,
        HashString& string)
{
        StringData stringData;
        stringData.SetTo(string.GetString());
        visitor->Visit(member, stringData);
}


// #pragma mark -
// #pragma mark ----- ShareInfo -----

// constructor
ShareInfo::ShareInfo()
        : FlattenableRequestMember(),
          fShareName()
{
}

// IsValid
bool
ShareInfo::IsValid() const
{
        return (fShareName.GetLength() > 0);
}

// ShowAround
void
ShareInfo::ShowAround(RequestMemberVisitor* visitor)
{
        VisitString(this, visitor, fShareName);
}

// Flatten
status_t
ShareInfo::Flatten(RequestFlattener* flattener)
{
        return flattener->WriteString(fShareName.GetString());
}

// Unflatten
status_t
ShareInfo::Unflatten(RequestUnflattener* unflattener)
{
        return unflattener->ReadString(fShareName);
}

// SetShareName
status_t
ShareInfo::SetShareName(const char* shareName)
{
        return (fShareName.SetTo(shareName) ? B_OK : B_NO_MEMORY);
}

// GetShareName
const char*
ShareInfo::GetShareName() const
{
        return fShareName.GetString();
}


// #pragma mark -
// #pragma mark ----- ServerInfo -----

// constructor
ServerInfo::ServerInfo()
        : FlattenableRequestMember(),
          fServerName(),
          fConnectionMethod(),
          fShareInfos()
{
}

// constructor
ServerInfo::ServerInfo(const ServerInfo& other)
        : FlattenableRequestMember(),
          fServerName(),
          fConnectionMethod(),
          fShareInfos()
{
        (*this) = other;
}

// ShowAround
void
ServerInfo::ShowAround(RequestMemberVisitor* visitor)
{
        VisitString(this, visitor, fServerName);
        VisitString(this, visitor, fConnectionMethod);
        int32 count = fShareInfos.Count();
        visitor->Visit(this, count);
        for (int32 i = 0; i < count; i++)
                visitor->Visit(this, fShareInfos.ElementAt(i));
}

// Flatten
status_t
ServerInfo::Flatten(RequestFlattener* flattener)
{
        flattener->WriteString(fServerName.GetString());
        flattener->WriteString(fConnectionMethod.GetString());

        int32 count = fShareInfos.Count();
        flattener->WriteInt32(count);
        for (int32 i = 0; i < count; i++)
                flattener->Visit(this, fShareInfos.ElementAt(i));

        return flattener->GetStatus();
}

// Unflatten
status_t
ServerInfo::Unflatten(RequestUnflattener* unflattener)
{
        unflattener->ReadString(fServerName);
        unflattener->ReadString(fConnectionMethod);

        int32 count;
        if (unflattener->ReadInt32(count) != B_OK)
                return unflattener->GetStatus();

        for (int32 i = 0; i < count; i++) {
                ShareInfo info;
                unflattener->Visit(this, info);
                if (info.IsValid())
                        AddShare(info.GetShareName());
        }

        return unflattener->GetStatus();
}

// SetServerName
status_t
ServerInfo::SetServerName(const char* serverName)
{
        return (fServerName.SetTo(serverName) ? B_OK : B_NO_MEMORY);
}

// GetServerName
const char*
ServerInfo::GetServerName() const
{
        return fServerName.GetString();
}

// SetConnectionMethod
status_t
ServerInfo::SetConnectionMethod(const char* connectionMethod)
{
        return (fConnectionMethod.SetTo(connectionMethod) ? B_OK : B_NO_MEMORY);
}

// GetConnectionMethod
const char*
ServerInfo::GetConnectionMethod() const
{
        return fConnectionMethod.GetString();
}

// AddShare
status_t
ServerInfo::AddShare(const char* shareName)
{
        ShareInfo shareInfo;
        status_t error = shareInfo.SetShareName(shareName);
        if (error == B_OK)
                error = fShareInfos.PushBack(shareInfo);
        return error;
}

// CountShares
int32
ServerInfo::CountShares() const
{
        return fShareInfos.Count();
}

// ShareInfoAt
const ShareInfo&
ServerInfo::ShareInfoAt(int32 index) const
{
        return fShareInfos.ElementAt(index);
}

// =
ServerInfo&
ServerInfo::operator=(const ServerInfo& other)
{
        fServerName = other.fServerName;
        fConnectionMethod = other.fConnectionMethod;
        fShareInfos.MakeEmpty();
        int32 count = other.fShareInfos.Count();
        for (int32 i = 0; i < count; i++)
                fShareInfos.PushBack(other.fShareInfos.ElementAt(i));
        return *this;
}