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 the User Objects subgroup of commands is selected.

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;

Performing Operations

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

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

    Sub Edit(Obj: IMetabaseObjectDescriptor);
    Begin
        //Handle the "Edit" operation
    End Sub Edit;

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

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

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

    Sub CLS1OP2(Obj: IMetabaseObjectDescriptor);
    Begin
        //Handle 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
        //Handling of the Open operation
    End Sub Open;

    Sub Edit(Obj: IMetabaseObjectDescriptor);
    Begin
        //Handling of 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 converted into parametric ones. To do so, fill the IMetabaseObjectDescriptor.Params window. 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 performing the operation the parameters input window collection. 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, the handler is called, but it gets empty parameter values.

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

Class Operations: Object     Sub Open(Obj: IMetabaseObjectDescriptor);     Begin         //Handle the "Open operation"     End Sub Open;     Sub Edit(Obj: IMetabaseObjectDescriptor);     Begin         //Handle the "Edit operation"     End Sub Edit;     Sub Delete(Obj: IMetabaseObjectDescriptor);     Begin         //Handle the "Delete operation"     End Sub Delete;     Sub Paste(Obj: IMetabaseObjectDescriptor);     Begin         //Handle the "Paste operation"     End Sub Paste;     Sub CLS1OP1(Obj: IMetabaseObjectDescriptor);     Begin         //Handle the first custom operation     End Sub CLS1OP1;     Sub CLS1OP2(Obj: IMetabaseObjectDescriptor);     Begin         //Handle the second custom operation     End Sub CLS1OP2;     //---     /For parametric objects     //---     Sub OpenWithParams(Obj: IMetabaseObjectDescriptor; Params: IMetabaseObjectParamValues);     Begin         //Handle the "Open operation" for parametric objects     End Sub OpenWithParams;     Sub EditOpenWithParams(Obj: IMetabaseObjectDescriptor; Params: IMetabaseObjectParamValues);     Begin         //Handle the "Open operation" for parametric objects     End Sub EditOpenWithParams;     Sub CLS1OP1WithParams(Obj: IMetabaseObjectDescriptor; Params: IMetabaseObjectParamValues);     Begin         //Handle the first custom operation for parametric objects     End Sub CLS1OP1WithParams;     Sub CLS1OP2WithParams(Obj: IMetabaseObjectDescriptor; Params: IMetabaseObjectParamValues);     Begin         //Handle the second custom operation for parametric objects     End Sub CLS1OP2WithParams; End Class Operations;