Working with Custom Class Objects

Custom class objects are created in the object navigator as other repository objects. To do this, in the navigator's context menu of the New Object button in the Create group on the Home ribbon tab select the User Objects subgroup of commands.

The further work with custom class objects is fully done via the Fore language. Properties and methods of accessing a custom class object are contained in the IMetabaseCustomObject interface of the Metabase assembly. A custom class object can contain any data. Consider simple examples for writing data to a custom class object and reading data from it. Data will be read or written from or to file:

Sub WriteCustomObject;
Var
    MB: IMetabase;
    CustomObject: IMetabaseCustomObject;
    CustomWriter: IMetabaseCustomObjectWriter;
Begin
    MB := MetabaseClass.Active;
    //Open custom class object for edit
    CustomObject := MB.ItemById("OBJ_CUSTOM").Edit As IMetabaseCustomObject;
    //Create object to write data
    CustomWriter := CustomObject.CreateWriter;
    //Read data from file
    CustomWriter.WriteFromFile("c:\Data.txt");
    //Save changes in custom class object
    CustomWriter.Save;
    //Save changes to repository base
    (CustomObject As IMetabaseObject).Save;
End Sub WriteCustomObject;

Sub ReadCustomObject;
Var
    MB: IMetabase;
    CustomObject: IMetabaseCustomObject;
    CustomReader: IMetabaseCustomObjectReader;
Begin
    MB := MetabaseClass.Active;
    //Open custom class object in read mode
    CustomObject := MB.ItemById("OBJ_CUSTOM").Bind As IMetabaseCustomObject;
    //Create object for reading data
    CustomReader := CustomObject.CreateReader;
    //Load data from repository base to computer memory
    CustomReader.Load;
    //Write data to file
    CustomReader.ReadToFile("c:\OutData.txt");
End Sub ReadCustomObject;

Executing Operations

In order the working with custom class objects in the object navigator matches working with other repository objects, create a list of operations in class settings and specify the handler that contains class with implementation of operations. For example, the class implementation that is used to handle standard operations Open, Edit and two more operations is the following:

Class Operations: Object
    Sub Open(Obj: IMetabaseObjectDescriptor);
    Begin
        //Process the Open operation
    End Sub Open;

    Sub Edit(Obj: IMetabaseObjectDescriptor);
    Begin
        //Process creation of custom class object or the Edit operation
    End Sub Edit;

    Sub Delete(Obj: IMetabaseObjectDescriptor);
    Begin
        //Process the Delete operation
    End Sub Delete;

    Sub Paste(Obj: IMetabaseObjectDescriptor);
    Begin
        //Process the Insert operation
    End Sub Paste;

    Sub CLS1OP1(Obj: IMetabaseObjectDescriptor);
    Begin
        //Process the first custom operation
    End Sub CLS1OP1;

    Sub CLS1OP2(Obj: IMetabaseObjectDescriptor);
    Begin
        //Process the second custom operation
    End Sub CLS1OP2;
End Class Operations;

To write or read data in custom class objects, the above mentioned operations can be written to events handlers:

Class Operations: Object
    Sub Open(Obj: IMetabaseObjectDescriptor);
    Begin
        //Handle the Open operation
    End Sub Open;

    Sub Edit(Obj: IMetabaseObjectDescriptor);
    Begin
        //Handle creating a custom class object or the Edit operation
    End Sub Edit;

    //Write data to custom class object
    Sub CLS1OP1(Obj: IMetabaseObjectDescriptor);
    Var
        CustomObject: IMetabaseCustomObject;
        CustomWriter: IMetabaseCustomObjectWriter;
    Begin
        CustomObject := Obj.Edit As IMetabaseCustomObject;
        CustomWriter := CustomObject.CreateWriter;
        CustomWriter.WriteFromFile("c:\Data.txt");
        CustomWriter.Save;
        (CustomObject As IMetabaseObject).Save;
    End Sub CLS1OP1;

    //Read data from custom class object and write it to file
    Sub CLS1OP2(Obj: IMetabaseObjectDescriptor);
    Var
        CustomObject: IMetabaseCustomObject;
        CustomReader: IMetabaseCustomObjectReader;
    Begin
        CustomObject := Obj.Bind As IMetabaseCustomObject;
        CustomReader := CustomObject.CreateReader;
        CustomReader.Load;
        CustomReader.ReadToFile("c:\OutData.txt");
    End Sub CLS1OP2;

End Class Operations;

Parametric Custom Class Objects

If required, custom class objects can be converted into parametric ones. To do so, via Fore fill in the IMetabaseObjectDescriptor.Params collection. The following code can be used to create parameters:

Sub CreateParams;
Var
 MB: IMetabase;
 MObj: IMetabaseObject;
 Params: IMetabaseObjectParams;
 Param: IMetabaseObjectParam;
Begin
 MB := MetabaseClass.Active;
 MObj := MB.ItemById("Parameter ID").Edit;
 Params := MObj.Params;
 //Clear list of parameters
 Params.Clear;
 //Create parameter and set up its properties
 Param := Params.Add;
 Param.DataType := DbDataType.Integer;
 Param.Name := "<Parameter name>";
 //...
 //Create other parameters
 //...
 MObj.Save;
End Sub CreateParams;

Before executing the operation the parameters input dialog box opens for parametric object. After the values are entered and the OK button is clicked, the corresponding handler method is called. If the Cancel button is clicked in the dialog box, the handler is called but it passes empty parameter values.

The corresponding handlers must be implemented to handle operations of parametric objects:

Class Operations: Object     Sub Open(Obj: IMetabaseObjectDescriptor);     Begin         //Process the Open "operation"     End Sub Open;     Sub Edit(Obj: IMetabaseObjectDescriptor);     Begin         //Process creation of custom class object or the Edit "operation"     End Sub Edit;     Sub Delete(Obj: IMetabaseObjectDescriptor);     Begin         //Process the Delete "operation"     End Sub Delete;     Sub Paste(Obj: IMetabaseObjectDescriptor);     Begin         //Process the Insert "operation"     End Sub Paste;     Sub CLS1OP1(Obj: IMetabaseObjectDescriptor);     Begin         //Process the first custom operation     End Sub CLS1OP1;     Sub CLS1OP2(Obj: IMetabaseObjectDescriptor);     Begin         //Process the second custom operation     End Sub CLS1OP2;     //----------------------------     //For parameteric objects     //----------------------------     Sub OpenWithParams(Obj: IMetabaseObjectDescriptor; Params: IMetabaseObjectParamValues);     Begin         //Process the Open "Operation" for parametric objects     End Sub OpenWithParams;     Sub CLS1OP1WithParams(Obj: IMetabaseObjectDescriptor; Params: IMetabaseObjectParamValues);     Begin         //Process the first custom operation for parametric objects     End Sub CLS1OP1WithParams;     Sub CLS1OP2WithParams(Obj: IMetabaseObjectDescriptor; Params: IMetabaseObjectParamValues);     Begin         //Process the second custom operation for parametric objects     End Sub CLS1OP2WithParams; End Class Operations;