/*
 * Copyright 1999-2009 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Jeremy Friesner
 */


#include "BitFieldTesters.h"

#include <stdio.h>


#define NOTE "NotFieldTester : "
#define MINI "MinMatchFieldTester : "


BitFieldTester::BitFieldTester()
{
}


BitFieldTester::BitFieldTester(BMessage* from)
        :
        BArchivable(from)
{
}


status_t
BitFieldTester::Archive(BMessage* into, bool deep) const
{
        return BArchivable::Archive(into, deep);
}


//      #pragma mark - ConstantFieldTester


ConstantFieldTester::ConstantFieldTester(bool result)
        :
        fResult(result)
{
}


ConstantFieldTester::ConstantFieldTester(BMessage* from)
        :
        BitFieldTester(from)
{
        if (from->FindBool("ctRes", &fResult) != B_OK)
                printf("ConstantFieldTester: Error, no ctRes!\n");
}


status_t
ConstantFieldTester::Archive(BMessage* into, bool deep) const
{
        status_t result = BitFieldTester::Archive(into, deep);
        into->AddBool("ctRes", fResult);
        return result;
}


BArchivable*
ConstantFieldTester::Instantiate(BMessage* from)
{
        if (validate_instantiation(from, "ConstantFieldTester"))
                return new ConstantFieldTester(from);
        else
                return NULL;
}


bool
ConstantFieldTester::IsMatching(uint32 field)
{
        return fResult;
}


//      #pragma mark - HasBitsFieldTester


HasBitsFieldTester::HasBitsFieldTester(uint32 requiredBits,
        uint32 forbiddenBits)
        :
        fRequiredBits(requiredBits),
        fForbiddenBits(forbiddenBits)
{
}


HasBitsFieldTester::HasBitsFieldTester(BMessage* from)
        :
        BitFieldTester(from)
{
        if (from->FindInt32("rqBits", (int32*) &fRequiredBits) != B_OK)
                printf("HasBitsFieldTester: Error, no rqBits!\n");

        if (from->FindInt32("fbBits", (int32*) &fForbiddenBits) != B_OK)
                printf("HasBitsFieldTester: Error, no fbBits!\n");
}


status_t
HasBitsFieldTester::Archive(BMessage* into, bool deep) const
{
        status_t result = BitFieldTester::Archive(into, deep);
        into->AddInt32("rqBits", fRequiredBits);
        into->AddInt32("fbBits", fForbiddenBits);

        return result;
}


BArchivable*
HasBitsFieldTester::Instantiate(BMessage* from)
{
        if (validate_instantiation(from, "HasBitsFieldTester"))
                return new HasBitsFieldTester(from);
        else
                return NULL;
}


bool
HasBitsFieldTester::IsMatching(uint32 field)
{
        return ((((fRequiredBits & (~field)) == 0))
                && ((fForbiddenBits & (~field)) == fForbiddenBits));
}


//      #pragma mark - NotFieldTester


NotFieldTester::NotFieldTester(BitFieldTester* slave)
        :
        fSlave(slave)
{
}


NotFieldTester::~NotFieldTester()
{
        delete fSlave;
}


NotFieldTester::NotFieldTester(BMessage* from)
        :
        BitFieldTester(from),
        fSlave(NULL)
{
        BMessage slaveMessage;
        if (from->FindMessage("nSlave", &slaveMessage) == B_OK) {
                BArchivable* slaveObject = instantiate_object(&slaveMessage);
                if (slaveObject != NULL) {
                        fSlave = dynamic_cast<BitFieldTester*>(slaveObject);
                        if (fSlave == NULL) {
                                printf(NOTE "Error casting slaveObject to BitFieldTester!\n");
                                delete slaveObject;
                        }
                } else
                        printf(NOTE "instantiate_object returned NULL!\n");
        } else
                printf(NOTE "Couldn't unarchive NotFieldTester slave!\n");
}


status_t
NotFieldTester::Archive(BMessage* into, bool deep) const
{
        if (fSlave == NULL)
                return B_ERROR;

        status_t result = BitFieldTester::Archive(into, deep);
        if (result == B_OK) {
                BMessage message;
                result = fSlave->Archive(&message, deep);
                into->AddMessage("nSlave", &message);
        }

        return result;
}


BArchivable*
NotFieldTester::Instantiate(BMessage* from)
{
        if (validate_instantiation(from, "NotFieldTester"))
                return new NotFieldTester(from);
        else
                return NULL;
}


bool
NotFieldTester::IsMatching(uint32 field)
{
        return fSlave ? (!fSlave->IsMatching(field)) : false;
}


//      #pragma mark - MinMatchFieldTester


MinMatchFieldTester::MinMatchFieldTester(int32 minNum, bool deleteSlaves)
        :
        fMinNum(minNum),
        fDeleteSlaves(deleteSlaves) // fDeleteSlaves state not archived!
{
}


MinMatchFieldTester::~MinMatchFieldTester()
{
        if (fDeleteSlaves) {
                int32 last = fSlaves.CountItems();
                for (int32 i = 0; i < last; i++)
                        delete ((BitFieldTester*) fSlaves.ItemAt(i));
        }
}


MinMatchFieldTester::MinMatchFieldTester(BMessage* from)
        :
        BitFieldTester(from),
        fDeleteSlaves(true)
{
        int32 i = 0;
        BMessage slaveMessage;
        while (from->FindMessage("mSlave", i++, &slaveMessage) == B_OK) {
                BArchivable* slaveObject = instantiate_object(&slaveMessage);
                if (slaveObject) {
                        BitFieldTester* nextSlave = dynamic_cast<BitFieldTester*>(slaveObject);
                        if (nextSlave)
                                fSlaves.AddItem(nextSlave);
                        else {
                                printf(MINI "Error casting slaveObject to BitFieldTester!\n");
                                delete slaveObject;
                        }
                } else
                        printf(MINI "instantiate_object returned NULL!\n");
        }

        if (from->FindInt32("mMin", (int32*)&fMinNum) != B_OK)
                puts(MINI "Error getting mMin!");
}


// (slave) should be allocated with new, becomes property of this object.
void
MinMatchFieldTester::AddSlave(const BitFieldTester* slave)
{
        fSlaves.AddItem((void*) slave);
}


status_t
MinMatchFieldTester::Archive(BMessage* into, bool deep) const
{
        status_t result = BitFieldTester::Archive(into, deep);
        if (result == B_OK) {
                int32 last = fSlaves.CountItems();
                for (int32 i = 0; i < last; i++) {
                        BMessage msg;
                        result = ((BitFieldTester*)fSlaves.ItemAt(i))->Archive(&msg, deep);
                        if (result != B_OK)
                                return result;

                        into->AddMessage("mSlave", &msg);
                }
        }
        into->AddInt32("mMin", fMinNum);

        return result;
}


BArchivable*
MinMatchFieldTester::Instantiate(BMessage* from)
{
        if (validate_instantiation(from, "MinMatchFieldTester"))
                return new MinMatchFieldTester(from);
        else
                return NULL;
}


// Returns true if at least (fMinNum) slaves return true.
bool
MinMatchFieldTester::IsMatching(uint32 field)
{
        int32 last = fSlaves.CountItems();
        if (fMinNum == 0 && last == 0) {
                // 0 >= 0, so this should return true
                return true;
        }

        int32 count = 0;

        for (int32 i = 0; i < last; i++) {
                if ((((BitFieldTester*)fSlaves.ItemAt(i))->IsMatching(field))
                                && (++count >= fMinNum)) {
                        return true;
                }
        }

        return false;
}