//----------------------------------------------------------------------
//  This software is part of the Haiku distribution and is covered
//  by the MIT License.
//---------------------------------------------------------------------
/*!
        \file ResourcesItem.cpp
        ResourceItem implementation.
*/

#include "ResourceItem.h"

#include <stdio.h>
#include <string.h>

#include <DataIO.h>

namespace BPrivate {
namespace Storage {

// constructor
ResourceItem::ResourceItem()
                        : BMallocIO(),
                          fOffset(0),
                          fInitialSize(0),
                          fType(0),
                          fID(0),
                          fName(),
                          fIsLoaded(false),
                          fIsModified(false)
{
        SetBlockSize(1);
}

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

// WriteAt
ssize_t
ResourceItem::WriteAt(off_t pos, const void *buffer, size_t size)
{
        ssize_t result = BMallocIO::WriteAt(pos, buffer, size);
        if (result >= 0)
                SetModified(true);
        return result;
}

// SetSize
status_t
ResourceItem::SetSize(off_t size)
{
        status_t error = BMallocIO::SetSize(size);
        if (error == B_OK)
                SetModified(true);
        return error;
}

// SetLocation
void
ResourceItem::SetLocation(int32 offset, size_t initialSize)
{
        SetOffset(offset);
        fInitialSize = initialSize;
}

// SetIdentity
void
ResourceItem::SetIdentity(type_code type, int32 id, const char *name)
{
        fType = type;
        fID = id;
        fName = name;
}

// SetOffset
void
ResourceItem::SetOffset(int32 offset)
{
        fOffset = offset;
}

// Offset
int32
ResourceItem::Offset() const
{
        return fOffset;
}

// InitialSize
size_t
ResourceItem::InitialSize() const
{
        return fInitialSize;
}

// DataSize
size_t
ResourceItem::DataSize() const
{
        if (IsModified())
                return BufferLength();
        return fInitialSize;
}

// SetType
void
ResourceItem::SetType(type_code type)
{
        fType = type;
}

// Type
type_code
ResourceItem::Type() const
{
        return fType;
}

// SetID
void
ResourceItem::SetID(int32 id)
{
        fID = id;
}

// ID
int32
ResourceItem::ID() const
{
        return fID;
}

// SetName
void
ResourceItem::SetName(const char *name)
{
        fName = name;
}

// Name
const char *
ResourceItem::Name() const
{
        return fName.String();
}

// Data
void *
ResourceItem::Data() const
{
        // Since MallocIO may have a NULL buffer, if the data size is 0,
        // we return a pointer to ourselves in this case. This ensures, that
        // the resource item still can be uniquely identified by its data pointer.
        if (DataSize() == 0)
                return const_cast<ResourceItem*>(this);
        return const_cast<void*>(Buffer());
}

// SetLoaded
void
ResourceItem::SetLoaded(bool loaded)
{
        fIsLoaded = loaded;
}

// IsLoaded
bool
ResourceItem::IsLoaded() const
{
        return (BufferLength() > 0 || fIsLoaded);
}

// SetModified
void
ResourceItem::SetModified(bool modified)
{
        fIsModified = modified;
}

// IsModified
bool
ResourceItem::IsModified() const
{
        return fIsModified;
}


};      // namespace Storage
};      // namespace BPrivate