Reading ontologies

Readers 

Ontologies can be read from files, memory buffers or input streams (see UIStream) through the CowlManager object. Cowl can attempt ontology deserialization via multiple readers, and you can control which reader is used in a number of ways:

At compile-time: readers included in the compiled library can be selected by setting the COWL_READERS CMake variable. Built-in readers are exposed through cowl_reader_*() functions.
At run-time, globally: you can set the default reader by calling cowl_set_reader().
At run-time, locally: you can specify which reader you want CowlManager to use via cowl_manager_set_reader().

You can integrate additional readers by providing suitably populated CowlReader instances. When implementing one, use the provided CowlIStream object to handle detected OWL constructs. If you need to manage prefixed IRIs, you can do so through the CowlSymTable instance available by calling cowl_istream_get_sym_table(). Refer to the built-in readers if you need guidance.

struct CowlReader

Defines a reader.

Public Members

char const *name: Name of the reader.

void *ctx: Reader context.

cowl_ret (*read)(void *ctx, UIStream *istream, CowlIStream *stream)

Pointer to a function that reads an ontology from an input stream.

Note

This member is mandatory.

Param ctx:: Reader context.
Param istream:: Input stream.
Param stream:: Ontology input stream.
Return:: Return code.

void (*free)(void *ctx)

Pointer to a function that frees the reader context.

Note

This member is optional. If not set, the reader context will not be freed.

Param ctx:: Reader context.

void cowl_reader_free_ctx(CowlReader *reader)

Frees the reader context.

Parameters:

reader – The reader.

CowlReader cowl_reader_functional(void)

Returns the functional syntax reader.

Returns:: Functional syntax reader.

CowlReader cowl_reader_default(void)

Returns the default reader.

Returns:: Default reader.

Handling imports 

Cowl delegates locating and loading imported ontologies to the end user via the CowlImportResolver interface. Import resolvers can be provided to CowlManager instances via cowl_manager_set_import_resolver(). By default, CowlManager will attempt to resolve imports based on the IRIs of ontologies it is currently responsible for, i.e. those that have been loaded or created through it.

struct CowlImportResolver

Provides a mechanism for generic handling of ontology imports.

The resolve_import function should return the ontology associated to the specified CowlIRI. Imports retrieval and loading is deliberately left to the implementor.

Public Members

void *ctx: Resolver context, can be anything.

CowlOntology *(*resolve_import)(void *ctx, CowlIRI *iri)

Pointer to a function that returns the ontology associated to the specified IRI.

Note

The returned ontology must be retained.

Param ctx:: Resolver context.
Param iri:: The IRI.
Return:: Imported ontology, or NULL on error.

void (*free)(void *ctx)

Pointer to a function that frees the resolver context.

Note

This member is optional. If not set, the resolver context will not be freed.

Param ctx:: Resolver context.

void cowl_import_resolver_free_ctx(CowlImportResolver *resolver)

Frees the import resolver context.

Parameters:

resolver – The resolver.

CowlOntology *cowl_import_resolver_resolve_import(CowlImportResolver const *resolver, CowlIRI *iri)

Returns the ontology associated to the specified IRI.

Note

You must release the returned object via cowl_release().

Parameters:

resolver – The resolver.
iri – The IRI.

Returns:

Imported ontology, or NULL on error.

CowlImportResolver cowl_import_resolver_default(CowlManager *manager)

Default import resolver, which looks for the ontology with the specified IRI in the manager’s ontologies.

Note

The manager is set as the resolver context, but it is not retained.

Parameters:

manager – The manager.

Returns:

Default import resolver.