About

Using MemoryFileStruct one can read/write from/into memory using a file class.

Note
The MAXON API equivalent is maxon::IoMemoryInterface.

Typical use cases:

A general example on writing into a HyperFile in memory:

// This example writes some data into memory and accesses the raw memory afterwards.
if (!hf || !mfs)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
// By setting the write mode of the filename, it will point to a file in memory.
// DO NOT use fn.SetFile() or fn.SetDirectory()
// Open a HyperFile in memory and write some data into it.
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
hf->WriteInt32(123);
hf->WriteString("foo"_s);
hf->WriteString("bar"_s);
hf->WriteInt32(456);
// Close() is explicitly needed here, as the completed file is accessed a few lines below by GetData().
hf->Close();
// Get the raw data of the HyperFile and do something with it.
void* rawData = nullptr;
Int rawDataSize = 0;
mfs->GetData(rawData, rawDataSize, false);
// ... do something with rawData...

This is how one can easily transfer an object (or a complete hierarchy) via network:

// This example demonstrates how to send an object (or a hierarchy of objects) over a network connection.
BaseObject* const op = doc->GetActiveObject();
if (op == nullptr)
return maxon::OK;
// By setting the write mode of the filename, it will point to a file in memory.
if (mfs == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
// No actual name needs to be set, switching mode is enough.
// DO NOT use fn.SetFile() or fn.SetDirectory()
// Write the object(s) into the HyperFile in memory.
if (FILEERROR::NONE != WriteHyperFile(doc, op, fn, 0))
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
// Now, get the pointer to the HyperFile in memory and its size.
void* rawData = nullptr;
Int rawDataSize = 0;
// Note: Pay special attention to the last parameter, defining the ownership of the memory block.
mfs->GetData(rawData, rawDataSize, false);
// ... Send data (rawData, rawDataSize) via for example a NetworkIpConnection...
SendToNetwork(rawData, rawDataSize) iferr_return;
// This example demonstrates how to receive an object (or a hierarchy of objects) from a network connection.
// ... receive data from an NetworkIpConnection, we get a pointer to the data and the size of the data...
void* rawData = nullptr;
Int rawDataSize = 0;
ReceiveFromNetwork(rawData, rawDataSize); // custom helper function
if (!rawData || rawDataSize == 0)
return maxon::OK; // nothing received
// By setting the read mode of the filename, it will point to a file in memory.
// No actual name needs to be set, switching mode is enough.
fn.SetMemoryReadMode(rawData, rawDataSize, false);
// DO NOT use fn.SetFile() or fn.SetDirectory()
// Read object(s) from the HyperFile in memory.
if (!op)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
String error;
if (FILEERROR::NONE != ReadHyperFile(doc, op, fn, 0, &error))
return maxon::UnknownError(MAXON_SOURCE_LOCATION);
// Insert the object(s) into the active document.
doc->InsertObject(op.Release(), nullptr, nullptr, false);

Allocation/Deallocation

MemoryFileStruct objects are created with the usual tools, see Entity Creation and Destruction Manual (Classic).

Writing Data to a File in Memory and Accessing the Raw Data

Reading Data From a File in Memory

Further Reading