# Storage

This page explains how iink SDK lets you organize the data it works on, store content and load it again later.

## Structure of the model

Interactive Ink SDK stores content using the following structures:

• IINKContentPackage - A Package is a container storing ink and its interpretation as an ordered collection of parts. It can be saved as a file on the file system and later reloaded or shared between users.
• IINKContentPart - A part corresponds to a standalone content unit that can be processed by iink SDK. Each part has a specific type, corresponding to the type of its root block, that can be retrieved via its type property.
The complete list of supported part types can be found here.

It is possible to get the number of parts of a given package via its partCount property and access an individual part by calling getPart:error: and pass it the 0-based index of the part to load.

Parts host the data iink SDK works on. As a result, it is required to use them even if you do not intend to persist data on the disk as part of your application workflow.

Although a content part sometimes hosts a single content block, both concepts are not equivalent. A part corresponds to a serialization unit, while a block corresponds to a semantic unit that can be manipulated.

## Working with packages

Interactive Ink SDK uses the file system to limit the amount of RAM that is required at a given point in time, as well as to store temporary files. It also provides serialization/deserialization methods to let application save/load MyScript data, either for persistence needs or to exchange it between users.

MyScript iink SDK serialization format is optimized for speed and compactness, but is not easily readable. If you want to parse the content of the interactive model, refer to the import/export section.

### Temporary folder

Even if you do not intend to explicitly save any content, MyScript iink SDK requires a read/write access to at least one folder on the file system: the temporary folder, where it will output the intermediate files it is working on.

By default, iink SDK uses the folder where the package file is located. It may however be relevant (and even mandatory on certain platforms) to choose another folder. This can be achieved by setting the value of content-package.temp-folder in the configuration of the engine.

If it does not exist, the folder will be created if you save the corresponding package. It may also be automatically created by iink SDK in case it has a need to reduce its memory usage or when handling some particular objects such as images.

To create or open packages, use the openPackage:openOption:error: method. It comes with different possible options:

• IINKPackageOpenOptionExisting to open an existing package and fail if it does not exist (default behavior).
• IINKPackageOpenOptionCreate to open an existing package or create it if it does not exist.
• IINKPackageOpenOptionCreateNew to ensure to create and open a package that did not previously exist.
• IINKPackageOpenOptionTruncateExisting to create and open a new package, overwriting any pre-existing package at the same location.

To create a new package, you can alternatively call the createPackage:error: convenience method, which is equivalent to call openPackage:openOption:error: with the IINKPackageOpenOptionCreateNew option.

Both methods take as their first parameter the name of the file corresponding to the package on the file system.

#import <iink/IINK.h>

...

NSError *error = nil;

// Create a new package
IINKContentPackage *newPackage = [engine createPackage:@"newPackage.iink" error:&error];

IINKContentPackage *existingPackage = [engine openPackage:@"existingPackage.iink" error:&error];

### Saving packages

Interactive Ink SDK provides two distinct methods to save content: saveWithError: and saveToTempWithError:, both to be called on the IINKContentPackage instance to consider.

It is important to understand the distinction between them, as they play different roles:

• saveWithError: will serialize all data into a zip archive named after the package, whether such data is on the memory or if it was off-loaded into the temporary folder. The resulting file is self-contained, and can be reloaded at a later point. Due to the compression, this method is rather slow.
• saveToTempWithError: will save the content that was loaded into the memory to the temporary folder. As it only writes the content that was in the memory at a given point in time and does not require compression, calling this method is much faster. It can let iink SDK recover such data if it was forced to exit without saving to the compressed archive.

The following diagram explains how iink SDK manages the memory, as well as the role of the different save operations:

By default, data corresponding to a content package is stored in a folder named after this package by appending the -files suffix and located in the same folder.

### Deleting packages

Use the deletePackage:error: method to remove an existing package from the disk. Make sure to first release all references to this package, including parts you opened.

## Working with parts

Parts are created and manipulated from their parent package.

### Creating parts

To create a part, call createPart:error: on the parent package and pass it a string corresponding to the content type you want to assign to its root block (it cannot be changed afterwards).

Possible options are currently “Text”, “Math”, “Drawing, “Diagram”, “Raw Content” or “Text Document” (case sensitive).

To copy a part from an existing package, call clonePart:error: on the destination package (which can be the same as the origin package if you just want to duplicate the part) and pass it a pointer to the part to copy.

To “move” a part from a package to another, first clone it into the new package and then delete the part from the original package.

### Opening parts

To open a part, call getPart:error: and pass in parameter its index in its parent package (indexes start at 0). The number of parts of a given package can be retrieved via its partCount property.

### Deleting parts

To delete a part, call removePart:error: on its parent package.

You can attach metadata to both IINKContentPart and IINKContentPackage objects, and they will be serialized with the file. This can prove useful to store client-specific parameters.

Use the metadata property to store and retrieve the metadata attached to the object.

// Retrieve the metadata from a part

// Set and Get (key, value) pairs
...

// Store the metadata back into the part
part.metadata = metadata;

The structure representing metadata is an IINKParameterSet and is manipulated the exact same way as engine configuration parameters.

## Back to the example

The calculator requires setting a package that iink SDK can use to store the content it is working on.

In addition, the user needs to be able to restore the state of the last session if he exits and relaunches the app. This can also prove useful on systems such as Android, where the content should be saved then restored when rotating the screen.

@property (nonatomic, strong) IINKContentPart *part;
@property (nonatomic, strong) IINKContentPackage *package;

NSString *const packageName = @"calculator.iink";

- (void)saveContent
{
// Save history in part metadata
[self saveHistory];
// Save the content package to the file system
[self.package saveWithError:nil];
}

- (void)openContent
{

if ([[NSFileManager defaultManager] fileExistsAtPath:packageName])
{
self.package = [self.engine openPackage:packageName error:nil];
self.part = [self.package getPartAt:0 error:nil];
}
else
{
// Create a content package to provide the SDK with a place to work
self.package = [self.engine createPackage:packageName error:nil];
// Create a Math part
self.part = [self.package createPart:@"Math" error:nil];
// Create history
self.history = [NSMutableArray array];
}
}

You can make sure to call openContent: after launching the app to always have a package to work on.

You can also use metadata to store the history (an array of LaTeX strings):

@property (nonatomic, strong) NSMutableArray<NSString *> *history;

{
NSArray<NSString *> *history = [self.part.metadata getStringArrayForKey:@"history" error:nil];
self.history = [NSMutableArray arrayWithArray:history];
}

- (void)saveHistory
{
}