/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2013-2014, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "UserBreakpoint.h"

#include "Function.h"
#include "FunctionID.h"
#include "LocatableFile.h"


// #pragma mark - UserBreakpointLocation


UserBreakpointLocation::UserBreakpointLocation(FunctionID* functionID,
        LocatableFile* sourceFile, const SourceLocation& sourceLocation,
        target_addr_t relativeAddress)
        :
        fFunctionID(functionID),
        fSourceFile(sourceFile),
        fSourceLocation(sourceLocation),
        fRelativeAddress(relativeAddress)
{
        fFunctionID->AcquireReference();
        if (fSourceFile != NULL)
                fSourceFile->AcquireReference();
}


UserBreakpointLocation::UserBreakpointLocation(
        const UserBreakpointLocation& other)
        :
        fFunctionID(other.fFunctionID),
        fSourceFile(other.fSourceFile),
        fSourceLocation(other.fSourceLocation),
        fRelativeAddress(other.fRelativeAddress)
{
        fFunctionID->AcquireReference();
        if (fSourceFile != NULL)
                fSourceFile->AcquireReference();
}


UserBreakpointLocation::~UserBreakpointLocation()
{
        fFunctionID->ReleaseReference();
        if (fSourceFile != NULL)
                fSourceFile->ReleaseReference();
}


UserBreakpointLocation&
UserBreakpointLocation::operator=(
        const UserBreakpointLocation& other)
{
        other.fFunctionID->AcquireReference();
        if (other.fSourceFile != NULL)
                other.fSourceFile->AcquireReference();

        fFunctionID->ReleaseReference();
        if (fSourceFile != NULL)
                fSourceFile->ReleaseReference();

        fFunctionID = other.fFunctionID;
        fSourceFile = other.fSourceFile;
        fSourceLocation = other.fSourceLocation;
        fRelativeAddress = other.fRelativeAddress;

        return *this;
}


// #pragma mark - UserBreakpointInstance


UserBreakpointInstance::UserBreakpointInstance(UserBreakpoint* userBreakpoint,
        target_addr_t address)
        :
        fAddress(address),
        fUserBreakpoint(userBreakpoint),
        fBreakpoint(NULL)
{
}


void
UserBreakpointInstance::SetBreakpoint(Breakpoint* breakpoint)
{
        fBreakpoint = breakpoint;
}


// #pragma mark - UserBreakpoint


UserBreakpoint::UserBreakpoint(const UserBreakpointLocation& location)
        :
        fLocation(location),
        fValid(false),
        fEnabled(false),
        fHidden(false),
        fConditionExpression()
{
}


UserBreakpoint::~UserBreakpoint()
{
        for (int32 i = 0; UserBreakpointInstance* instance = fInstances.ItemAt(i);
                        i++) {
                delete instance;
        }
}


int32
UserBreakpoint::CountInstances() const
{
        return fInstances.CountItems();
}


UserBreakpointInstance*
UserBreakpoint::InstanceAt(int32 index) const
{
        return fInstances.ItemAt(index);
}


bool
UserBreakpoint::AddInstance(UserBreakpointInstance* instance)
{
        return fInstances.AddItem(instance);
}


void
UserBreakpoint::RemoveInstance(UserBreakpointInstance* instance)
{
        fInstances.RemoveItem(instance);
}


UserBreakpointInstance*
UserBreakpoint::RemoveInstanceAt(int32 index)
{
        return fInstances.RemoveItemAt(index);
}


void
UserBreakpoint::SetValid(bool valid)
{
        fValid = valid;
}


void
UserBreakpoint::SetEnabled(bool enabled)
{
        fEnabled = enabled;
}


void
UserBreakpoint::SetHidden(bool hidden)
{
        fHidden = hidden;
}


void
UserBreakpoint::SetCondition(const BString& conditionExpression)
{
        fConditionExpression = conditionExpression;
}