moduleEntryPoint.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef _STRUS_MODULE_HEADER_HPP_INCLUDED
#define _STRUS_MODULE_HEADER_HPP_INCLUDED
#include "strus/versionModule.hpp"
#include <cstring>

namespace strus {

struct ModuleEntryPoint
{
        enum Type
        {
                Analyzer,                       
                Storage,                        
                Trace                           
        };
        enum
        {
                ErrorNone=0,                    
                ErrorUnknownModuleType=1,       
                ErrorSignature=11,              
                ErrorModMinorVersion=12,        
                ErrorCompMajorVersion=21,       
                ErrorCompMinorVersion=22,       
                ErrorOpenModule=31,
                ErrorNoEntryPoint=32
        };

        char signature[ 8];                     
        Type type;                              
        unsigned short modversion_minor;        
        unsigned short compversion_major;       
        unsigned short compversion_minor;       
        unsigned int _reserved[6];              
        const char* version_3rdparty;           
        const char* license_3rdparty;           

        explicit ModuleEntryPoint( Type type_, unsigned short version_major, unsigned short version_minor, const char* version_3rdparty_=0, const char* license_3rdparty_=0)
                :type(type_),modversion_minor(STRUS_MODULE_VERSION_MINOR),version_3rdparty(version_3rdparty_),license_3rdparty(license_3rdparty_)
        {
                const char* declaration_signature = STRUS_MODULE_SIGNATURE;
                //... signature contains major version number in it
                std::memset( signature, 0, sizeof(signature));
                std::memcpy( signature, declaration_signature, std::strlen( declaration_signature));
                std::memset( _reserved, 0, sizeof(_reserved));
                compversion_major = version_major;
                compversion_minor = version_minor;
        }

        struct Status
        {
                Status()
                        :errorcode(0)
                {
                        errormsg[0] = '\0';
                }

                bool ok() const         {return errorcode==0;}

                int errorcode;
                char errormsg[ 256];
        };

        typedef void* Handle;
        static void closeHandle( Handle& hnd);

private:
        ModuleEntryPoint( const ModuleEntryPoint&){}    //< non copyable
        ModuleEntryPoint(){}                            //< no implicit construction without data
};

typedef bool (*MatchModuleVersionFunc)( const ModuleEntryPoint* entryPoint, int& errorcode);
const ModuleEntryPoint* loadModuleEntryPoint( const char* modfilename, ModuleEntryPoint::Status& status, ModuleEntryPoint::Handle& hnd, MatchModuleVersionFunc);

}//namespace
#endif