* Copyright 2002-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
* Distributed under the terms of the MIT License.
*/
#ifndef _RESOURCE_FILE_H
#define _RESOURCE_FILE_H
\file ResourceFile.h
ResourceFile interface declaration.
*/
#include <ByteOrder.h>
#include "OffsetFile.h"
struct resource_info;
struct PEFContainerHeader;
namespace BPrivate {
namespace Storage {
class Exception;
struct MemArea;
class ResourceItem;
struct resource_parse_info;
class ResourcesContainer;
\class ResourceFile
\brief Represents a file capable of containing resources.
This class provides access to the resources of a file.
Basically a ResourceFile object can be set to a file, load infos for the
resources without loading their data (InitContainer()), read the data of
one (ReadResource()) or all resources (ReadResources()) and write all
resources to the file (WriteResources()).
Note, that the object does only provide the I/O functionality, it does
not store any information about the resources -- this is done via a
ResourcesContainer. We gain flexibility using this approach, since e.g.
a certain resource may be represented by more than one ResourceItem and
we can have as many ResourcesContainers for the resources as we like.
In particular it is nice, that at any time we can write an arbitrary set
of resources to the file.
\author <a href='mailto:bonefish@users.sf.net'>Ingo Weinhold</a>
\version 0.0.0
*/
class ResourceFile {
public:
ResourceFile();
virtual ~ResourceFile();
status_t SetTo(BFile* file, bool clobber = false);
void Unset();
status_t InitCheck() const;
status_t InitContainer(ResourcesContainer& container);
status_t ReadResource(ResourceItem& resource,
bool force = false);
status_t ReadResources(ResourcesContainer& container,
bool force = false);
status_t WriteResources(ResourcesContainer& container);
private:
void _InitFile(BFile& file, bool clobber);
void _InitELFFile(BFile& file);
template<typename ElfHeader, typename ElfProgramHeader,
typename ElfSectionHeader>
void _InitELFXFile(BFile& file, uint64 fileSize);
void _InitPEFFile(BFile& file,
const PEFContainerHeader& pefHeader);
void _ReadHeader(resource_parse_info& parseInfo);
void _ReadIndex(resource_parse_info& parseInfo);
bool _ReadIndexEntry(BPositionIO& buffer,
resource_parse_info& parseInfo,
int32 index, uint32 tableOffset,
bool peekAhead);
void _ReadInfoTable(resource_parse_info& parseInfo);
bool _ReadInfoTableEnd(const void* data,
int32 dataSize);
const void* _ReadResourceInfo(
resource_parse_info& parseInfo,
const MemArea& area,
const resource_info* info, type_code type,
bool* readIndices);
status_t _WriteResources(ResourcesContainer& container);
status_t _MakeEmptyResourceFile();
inline int16 _GetInt(int16 value) const;
inline uint16 _GetInt(uint16 value) const;
inline int32 _GetInt(int32 value) const;
inline uint32 _GetInt(uint32 value) const;
inline int64 _GetInt(int64 value) const;
inline uint64 _GetInt(uint64 value) const;
private:
OffsetFile fFile;
uint32 fFileType;
bool fHostEndianess;
bool fEmptyResources;
};
inline int16
ResourceFile::_GetInt(int16 value) const
{
return fHostEndianess ? value : (int16)B_SWAP_INT16((uint16)value);
}
inline uint16
ResourceFile::_GetInt(uint16 value) const
{
return fHostEndianess ? value : B_SWAP_INT16(value);
}
inline int32
ResourceFile::_GetInt(int32 value) const
{
return fHostEndianess ? value : (int32)B_SWAP_INT32((uint32)value);
}
inline uint32
ResourceFile::_GetInt(uint32 value) const
{
return fHostEndianess ? value : B_SWAP_INT32(value);
}
inline int64
ResourceFile::_GetInt(int64 value) const
{
return fHostEndianess ? value : (int64)B_SWAP_INT64((uint64)value);
}
inline uint64
ResourceFile::_GetInt(uint64 value) const
{
return fHostEndianess ? value : B_SWAP_INT64(value);
}
};
};
#endif
