/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "FunctionID.h"

#include <new>

#include <Message.h>


// #pragma mark - FunctionID


FunctionID::FunctionID(const BMessage& archive)
        :
        BArchivable(const_cast<BMessage*>(&archive))
{
        archive.FindString("FunctionID::path", &fPath);
        archive.FindString("FunctionID::functionName", &fFunctionName);
}


FunctionID::FunctionID(const BString& path, const BString& functionName)
        :
        fPath(path),
        fFunctionName(functionName)
{
}


FunctionID::~FunctionID()
{
}


status_t
FunctionID::Archive(BMessage* archive, bool deep) const
{
        status_t error = BArchivable::Archive(archive, deep);
        if (error != B_OK)
                return error;

        error = archive->AddString("FunctionID::path", fPath);
        if (error == B_OK)
                error = archive->AddString("FunctionID::functionName", fFunctionName);
        return error;
}


uint32
FunctionID::ComputeHashValue() const
{
        return fPath.HashValue() * 17
                + fFunctionName.HashValue();
}


bool
FunctionID::IsValid() const
{
        return fPath.Length() != 0 && fFunctionName.Length() != 0;
}


// #pragma mark - SourceFunctionID


SourceFunctionID::SourceFunctionID(const BMessage& archive)
        :
        FunctionID(archive)
{
}


SourceFunctionID::SourceFunctionID(const BString& sourceFilePath,
        const BString& functionName)
        :
        FunctionID(sourceFilePath, functionName)
{
}


SourceFunctionID::~SourceFunctionID()
{
}


/*static*/ BArchivable*
SourceFunctionID::Instantiate(BMessage* archive)
{
        if (archive == NULL)
                return NULL;

        SourceFunctionID* object = new(std::nothrow) SourceFunctionID(*archive);
        if (object == NULL)
                return NULL;

        if (!object->IsValid()) {
                delete object;
                return NULL;
        }

        return object;
}


bool
SourceFunctionID::operator==(const ObjectID& _other) const
{
        const SourceFunctionID* other = dynamic_cast<const SourceFunctionID*>(
                &_other);
        return other != NULL && fPath == other->fPath
                && fFunctionName == other->fFunctionName;
}


// #pragma mark - ImageFunctionID


ImageFunctionID::ImageFunctionID(const BMessage& archive)
        :
        FunctionID(archive)
{
}


ImageFunctionID::ImageFunctionID(const BString& imageName,
        const BString& functionName)
        :
        FunctionID(imageName, functionName)
{
}


ImageFunctionID::~ImageFunctionID()
{
}


/*static*/ BArchivable*
ImageFunctionID::Instantiate(BMessage* archive)
{
        if (archive == NULL)
                return NULL;

        ImageFunctionID* object = new(std::nothrow) ImageFunctionID(*archive);
        if (object == NULL)
                return NULL;

        if (!object->IsValid()) {
                delete object;
                return NULL;
        }

        return object;
}


bool
ImageFunctionID::operator==(const ObjectID& _other) const
{
        const ImageFunctionID* other = dynamic_cast<const ImageFunctionID*>(
                &_other);
        return other != NULL && fPath == other->fPath
                && fFunctionName == other->fFunctionName;
}