Glossary
========

.. glossary::

    ABI
        Application Binary Interface

        The binary interface used by the linker process, to link compiled libraries. Either defined by the compiler or by a *standard* agreed to by multiple compilers.

        Not to be confused with **API**, which is the interface used *before* the code is compiled.

    API
        Application Programming Interface

        Exposed by libraries to compile source code against. Not to be confused with **ABI**, which is the interface used by the linker - after compilation.

    Bonjour
        Zero-configuration networking, enabling automatic discovery of devices on a local network.

    Camera Property Model
        A pre-defined set of properties and/or values for a camera.

    CameraSDK
        The SDK mediating communication with the camera. One of the SDKs offered from Phase One.

    declspec
    _P1_SDK_STATIC
        Microsoft's Visual C++ compiler requires functions that are imported from an external *dynamically linked* library, to be declared using the keyword: ``__declspec(dllimport)``. This tells the linker that function will be present at runtime, in a external dynamically loaded library.

        In our SDK's we use the predefine ``_P1_SDK_STATIC`` to *not* prefix library functions with with any ``declspec`` in our header files. Thereby enabling static linking.

    Debayering
    Demosaic
    Demosaicing
        Conversion from raw Bayer data to RGB data. Demosaicing is also known as "debayering" or "raw conversion".

    Dynamic loader
        An OS mechanism that loads dynamic libraries into memory, when the application uses ``dlopen`` / ``LoadLibrary`` like functionality.
    
    Dynamic linker
        An OS service that runs just before an application is launched, automatically resolving all its dynamic library dependencies.

    Exceptions
        Errors; all error handling in the SDKs is done through exceptions.

    Garbage Collector
        A runtime mechanism that automatically manages memory allocation and deallocation. Programming languages can include such a mechanism, to free the developer from the task of handling memory.

        Notably C, C++ does not have a garbage collector. C# does, however.

    Host computer
        The user's computer.

    Host system
        The operating system on the host computer.

    ImageSDK
        The SDK relating to processing images. One of the SDKs offered from Phase One.

    IQP
        IQ protocol - the protocol used to communicate between the camera and the CameraSDK.

    Property
        A variable in the camera, which can either be read or set atomically through the CameraSDK. E.g. ISO, shutter-time or the serial number.

    Property Specification
        A description of a property, containing e.g. the property's name, ID and type.

    SDK
        Software Development Kit
    
    SONAME
        Meta-data field in the ELF file format. Used by shared object files (``.so``) to state their :term:`ABI` compatibility and alias name.

        In executables the *SONAME* is used to reference the dynamic libraries.
    
    RPATH
        Field in ELF formatted executables (as used on Linux), that directs the :term:`dynamic linker` where to look for dependent libraries.

    Unmanaged code
        Code or runtime that does not include a garbage collector or an intermediate representation, used by an execution engine (interpreter or JIT). Examples of unmanaged code are C and C++.

        Is the oppersite of *managed code* which has intermediate representation and / or a garbage collector. Examples are C# (.NET), Python and Java.

    Target Build System
        *In relation to CMake*

        CMake is a *build system compiler*, meaning that it translates its ``CMakeLists.txt`` files into project files for popular build systems. Such as: *Visual Studio C++ projects* (``.vcxproj``), *Unix Makefiles*, *XCode projects*, *Ninja* etc.
        
        When CMake creates *Makefiles* from your ``CMakeLists.txt``, *Makefiles* is then the *target build system*. CMake hands off the actual building process to this target system - also known as the *generator* in CMake lingo.