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 == nullptr || mfs == nullptr)
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.
if (!hf->Open(0, fn, FILEOPEN::WRITE, FILEDIALOG::NONE))
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...
Definition: ge_autoptr.h:37
Manages file and path names.
Definition: c4d_file.h:94
void SetMemoryWriteMode(MemoryFileStruct *mfs)
maxon::Int Int
Definition: ge_sys_math.h:64
@ NONE
Never show an error dialog.
#define MAXON_SOURCE_LOCATION
Definition: memoryallocationbase.h:67

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::IllegalArgumentError(MAXON_SOURCE_LOCATION);
// 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.
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;
Definition: c4d_baseobject.h:248
@ NONE
No error.
FILEERROR WriteHyperFile(BaseDocument *doc, GeListNode *node, const Filename &filename, Int32 ident)
const char * doc
Definition: pyerrors.h:226
#define iferr_return
Definition: resultbase.h:1521
PyObject * op
Definition: object.h:520
// 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 == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
return maxon::UnknownError(MAXON_SOURCE_LOCATION);
// Insert the object(s) into the active document.
doc->InsertObject(op.Release(), nullptr, nullptr, false);
void SetMemoryReadMode(void *adr, Int size=-1, Bool transferOwnership=false)
Definition: c4d_string.h:39
PyObject * error
Definition: codecs.h:206
return OK
Definition: apibase.h:2747
#define Onull
Null.
Definition: ge_prepass.h:1074
FILEERROR ReadHyperFile(BaseDocument *doc, GeListNode *node, const Filename &filename, Int32 ident, maxon::String *warning_string)

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