{

static ProjectPtr loadProject(QIODevice & a_IODevice)

{

BinaryIOStream s(a_IODevice);

auto res = std::make_shared<Project>();

res->setCommand(s.readString());

res->setTimeUnit(s.readString());

readCodeLocations(s, *(res->getCodeLocationFactory()));

readSnapshots(s, *res);

return res;

}

static void readCodeLocations(BinaryIOStream & a_IOS, CodeLocationFactory & a_CodeLocations)

{

auto numCLs = a_IOS.readUInt64();

if (numCLs >= std::numeric_limits<quint32>::max())

{

throw ProjectLoadException("Failed sanity check on CodeLocation count");

}

for (auto i = numCLs; i > 0; --i)

{

bool unused;

auto cl = a_CodeLocations.getCodeLocation(a_IOS.readUInt64(), unused);

cl->setFunctionName(a_IOS.readQString());

cl->setFileName(a_IOS.readQString());

cl->setFileLineNum(a_IOS.readUInt32());

}

}

static void readSnapshots(BinaryIOStream & a_IOS, Project & a_Project)

{

auto numSnapshots = a_IOS.readUInt64();

for (auto i = numSnapshots; i > 0; --i)

{

auto snapshot = std::make_shared<Snapshot>();

snapshot->setTimestamp(a_IOS.readUInt64());

snapshot->setHeapSize(a_IOS.readUInt64());

snapshot->setHeapExtraSize(a_IOS.readUInt64());

if (a_IOS.readBool())

{

// Allocations are present in the file, read them:

auto rootAllocation = std::make_shared<Allocation>();

readAllocation(a_IOS, *rootAllocation, *(a_Project.getCodeLocationFactory()));

snapshot->setRootAllocation(rootAllocation);

}

snapshot->updateFlatSums();

a_Project.addSnapshot(snapshot);

}

}

static void readAllocation(

BinaryIOStream & a_IOS,

Allocation & a_Allocation,

CodeLocationFactory & a_CodeLocationFactory

)

{

a_Allocation.setAllocationSize(a_IOS.readUInt64());

auto address = a_IOS.readUInt64();

if (address != 0)

{

bool unused;

a_Allocation.setCodeLocation(a_CodeLocationFactory.getCodeLocation(address, unused));

}

auto typeInt = a_IOS.readUInt32();

Allocation::Type type = Allocation::atUnknown;

switch (typeInt)

{

case Allocation::atBelowThreshold: type = Allocation::atBelowThreshold; break;

case Allocation::atRegular: type = Allocation::atRegular; break;

case Allocation::atRoot: type = Allocation::atRoot; break;

}

a_Allocation.setType(type);

auto childrenCount = a_IOS.readUInt64();

for (auto i = childrenCount; i > 0; --i)

{

auto child = a_Allocation.addChild();

readAllocation(a_IOS, *child, a_CodeLocationFactory);

}

}

{

// Check if the project file magic string is present at the beginning of the file:

char fileMagic[ARRAYCOUNT(g_ProjectFileMagic)];

auto bytesRead = a_IODevice.read(fileMagic, sizeof(fileMagic));

if (

(bytesRead != sizeof(fileMagic)) ||

(std::memcmp(fileMagic, g_ProjectFileMagic, sizeof(g_ProjectFileMagic)) != 0)

)

{

throw ProjectLoadException("File is not a VisualMassifDiff project file");

}

// Read the format version number:

BinaryIOStream s(a_IODevice);

auto versionNumber = s.readUInt32();

// Load the specific version:

switch (versionNumber)

{

case 0: return ProjectLoaderV0::loadProject(a_IODevice);

}

throw ProjectLoadException("File version is not supported");

return nullptr;

{

// Check the file magic string at the beginning of the file:

char fileMagic[ARRAYCOUNT(g_ProjectFileMagic)];

auto bytesRead = a_IODevice.read(fileMagic, sizeof(fileMagic));

if (

(bytesRead != sizeof(fileMagic)) ||

(std::memcmp(fileMagic, g_ProjectFileMagic, sizeof(g_ProjectFileMagic)) != 0)

)

{

return false;

}

// The magic string matches, consider this a project file, regardless of the version:

return true;