client.h

Go to the documentation of this file.

 
#ifndef MATHWORKS_MPS_CLIENT
#define MATHWORKS_MPS_CLIENT
 
#define MPS_CLIENT_1_0 0x00010000
#define MPS_CLIENT_1_1 0x00010001
 
#ifndef MPS_MAX_VER
#define MPS_MAX_VER MPS_CLIENT_1_1
#endif
 
#ifdef _MSC_VER
  #define MPS_DLL_EXPORT_SYM __declspec(dllexport)
  #define MPS_DLL_IMPORT_SYM __declspec(dllimport)
#elif __GNUC__ >= 4
  #define MPS_DLL_EXPORT_SYM __attribute__ ((visibility("default")))
  #define MPS_DLL_IMPORT_SYM __attribute__ ((visibility("default")))
#else
  #define MPS_DLL_EXPORT_SYM
  #define MPS_DLL_IMPORT_SYM
#endif
 
#if defined(BUILDING_MPSCLIENT)
#define MPSCLIENT_PUBLISHED_API MPS_DLL_EXPORT_SYM
#else
#define MPSCLIENT_PUBLISHED_API MPS_DLL_IMPORT_SYM
#endif
 
#ifdef __cplusplus
#define MPSCLIENT_PUBLISHED_API_EXTERN_C extern "C"  MPSCLIENT_PUBLISHED_API
#else
#define MPSCLIENT_PUBLISHED_API_EXTERN_C extern  MPSCLIENT_PUBLISHED_API
#endif
 
#include <limits.h>
 
#ifdef _MSC_VER
typedef unsigned __int64 uint64;
#else
#include <stddef.h>
#include <stdint.h>
typedef uint64_t uint64;
#endif
 
typedef uint64 mpsSize;
 
typedef uint64 mpsIndex;
 
typedef struct mpsArray mpsArray;
 
typedef struct mpsClientConfig mpsClientConfig;
 
typedef struct mpsClientContext mpsClientContext;
 
#ifndef TMW_BITS_PER_INT
# if   INT_MAX  == 0x7FL
#  define TMW_BITS_PER_INT 8
# elif INT_MAX  == 0x7FFFL
#  define TMW_BITS_PER_INT 16
# elif INT_MAX  == 0x7FFFFFFFL
#  define TMW_BITS_PER_INT 32
# else
#  define TMW_BITS_PER_INT -1
# endif
#endif
 
#ifndef TMW_BITS_PER_LONG
# if   LONG_MAX  == 0x7FL
#  define TMW_BITS_PER_LONG 8
# elif LONG_MAX  == 0x7FFFL
#  define TMW_BITS_PER_LONG 16
# elif LONG_MAX  == 0x7FFFFFFFL
#  define TMW_BITS_PER_LONG 32
# else
#  define TMW_BITS_PER_LONG -1
# endif
#endif
 
#ifndef TMW_BITS_PER_SCHAR
# if   SCHAR_MAX  == 0x7FL
#  define TMW_BITS_PER_SCHAR 8
# elif SCHAR_MAX  == 0x7FFFL
#  define TMW_BITS_PER_SCHAR 16
# elif SCHAR_MAX  == 0x7FFFFFFFL
#  define TMW_BITS_PER_SCHAR 32
# else
#  define TMW_BITS_PER_SCHAR -1
# endif
#endif
 
#ifndef TMW_BITS_PER_SHRT
# if   SHRT_MAX  == 0x7FL
#  define TMW_BITS_PER_SHRT 8
# elif SHRT_MAX  == 0x7FFFL
#  define TMW_BITS_PER_SHRT 16
# elif SHRT_MAX  == 0x7FFFFFFFL
#  define TMW_BITS_PER_SHRT 32
# else
#  define TMW_BITS_PER_SHRT -1
# endif
#endif
 
#ifndef UINT16_T
# if   TMW_BITS_PER_INT   == 16
#  define  UINT16_T unsigned int
# elif TMW_BITS_PER_LONG  == 16
#  define  UINT16_T unsigned long
# elif TMW_BITS_PER_SCHAR == 16
#  define  UINT16_T unsigned char
# elif TMW_BITS_PER_SHRT  == 16
#  define  UINT16_T unsigned short
# endif
#endif
 
/* +0 because of a doxygen bug */
#if (defined(__cplusplus) && (__cplusplus+0 >= 201103L)) || (defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT)
typedef char16_t CHAR16_T;
#elif defined(_MSC_VER)
typedef wchar_t CHAR16_T;
#else
typedef UINT16_T CHAR16_T;
#endif
 
typedef CHAR16_T mpsChar;
 
#if !defined(__cplusplus)
 
typedef unsigned char bool;
 
#ifndef false
#define false (0)
#endif
#ifndef true 
#define true (1)
#endif
 
#endif
 
typedef bool mpsLogical;
 
typedef enum mpsErrorInfoType {
 
    MPS_HTTP_ERROR_INFO,
 
    MPS_MATLAB_ERROR_INFO,
 
    MPS_GENERIC_ERROR_INFO
 
} mpsErrorInfoType;
 
 
typedef struct mpsErrorInfoHTTP {
 
    unsigned int responseCode;
 
    const char* responseMessage;
 
} mpsErrorInfoHTTP;
 
 
typedef struct matlabStackFrame {
 
    const char* file;
 
    const char* function;
 
    int line;
 
} matlabStackFrame;
 
 
typedef struct mpsErrorInfoMATLAB {
 
    const char* message;
 
    const char* identifier;
 
    const matlabStackFrame* matlabStack;
 
    size_t matlabStackDepth;
 
} mpsErrorInfoMATLAB;
 
typedef struct mpsErrorInfoGeneric {
    
    const char* genericErrorMsg;
 
} mpsErrorInfoGeneric;
 
 
typedef struct mpsErrorInfo {
 
    mpsErrorInfoType type;
 
    char const* message;
 
    union {
        mpsErrorInfoHTTP http;
 
        mpsErrorInfoMATLAB matlab;
 
        mpsErrorInfoGeneric general;
    } details;
 
} mpsErrorInfo;
 
typedef enum mpsStatus {
 
    MPS_OK,
 
    MPS_FAILURE
 
} mpsStatus;
 
typedef enum mpsComplexity {
    mpsREAL,
    mpsCOMPLEX
} mpsComplexity;
 
typedef enum mpsClassID {
    mpsUINT8_CLASS,
    mpsINT8_CLASS,
    mpsUINT16_CLASS,
    mpsINT16_CLASS,
    mpsUINT32_CLASS,
    mpsINT32_CLASS,
    mpsUINT64_CLASS,
    mpsINT64_CLASS,
    mpsSINGLE_CLASS,
    mpsDOUBLE_CLASS,
    mpsLOGICAL_CLASS,
    mpsCHAR_CLASS,
    mpsSTRUCT_CLASS,
    mpsCELL_CLASS
} mpsClassID;
 
typedef struct mpsClientRuntime {
 
    mpsStatus (*createConfig) (mpsClientConfig** config);
 
    void (*destroyConfig) (mpsClientConfig* config);
 
    void (*setResponseTimeOutSec) (mpsClientConfig* config, unsigned long value);
 
    unsigned long (*getResponseTimeOutSec)(const mpsClientConfig* config);
 
    void (*setResponseSizeLimit) (mpsClientConfig* config, unsigned int value);
 
    unsigned int (*getResponseSizeLimit)(const mpsClientConfig* config);
 
    mpsStatus (*createContext)(mpsClientContext** context, const mpsClientConfig* config);
 
    void (*destroyContext) (mpsClientContext* context);
 
    void (*getLastErrorInfo) (mpsClientContext const* context, mpsErrorInfo* errorInfo);
 
    void (*destroyLastErrorInfo) (mpsErrorInfo* errorInfo);
 
    mpsStatus (*feval)( mpsClientContext* context, const char* url, int nlhs, mpsArray *plhs[], int nrhs, const mpsArray *prhs[] );
 
#if MPS_MAX_VER >= MPS_CLIENT_1_1
 
    void (*setClientCertFile) (mpsClientConfig* config, const char* certFile);
 
    const char* (*getClientCertFile) (const mpsClientConfig* config);
 
    void (*setPrivateKeyFile) (mpsClientConfig* config, const char* pkFile);
 
    const char* (*getPrivateKeyFile) (const mpsClientConfig* config);
 
    void (*setPrivateKeyPasswd) (mpsClientConfig* config, const char* passwd);
 
    const char* (*getPrivateKeyPasswd) (const mpsClientConfig* config);
 
    void (*setCAFile) (mpsClientConfig* config, const char* caFile);
 
    const char* (*getCAFile) (const mpsClientConfig* config);
 
    void (*setRevocationListFile) (mpsClientConfig* config, const char* crlFile);
 
    const char* (*getRevocationListFile) (const mpsClientConfig* config);
 
    void (*setVerifyHost) (mpsClientConfig* config, mpsLogical verifyHost);
 
    mpsLogical (*getVerifyHost) (const mpsClientConfig* config);
 
    void (*setVerifyPeer) (mpsClientConfig* config, mpsLogical verifyPeer);
 
    mpsLogical (*getVerifyPeer) (const mpsClientConfig* config);
 
#endif
 
} mpsClientRuntime;
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsClientRuntime* mpsInitialize(void);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsClientRuntime* mpsInitializeEx(int version);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsTerminate(void);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C const char* mpsGetInitializationErrorMessage(void);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsDouble(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsSingle(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsComplex(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsNumeric(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsInt64(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsUint64(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsInt32(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsUint32(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsInt16(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsUint16(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsInt8(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsUint8(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsChar(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsLogical(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsLogicalScalar(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsLogicalScalarTrue(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsStruct(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsCell(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsClass(const mpsArray* mlArr, const char* classname);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsEmpty(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C bool mpsIsSparse(const mpsArray* mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateDoubleMatrix(mpsSize m, mpsSize n, mpsComplexity complexFlag);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateDoubleScalar(double value);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateNumericMatrix(mpsSize m, mpsSize n, mpsClassID classid, mpsComplexity complexFlag);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateNumericArray(mpsSize ndim, const mpsSize *dims, 
                                                                 mpsClassID classid, mpsComplexity complexFlag);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateString(const char* str);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateCharMatrixFromStrings(mpsSize rows, const char **str);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateCharArray(mpsSize ndim, const mpsSize *dims);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateLogicalScalar(mpsLogical value);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateLogicalMatrix(mpsSize m, mpsSize n);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateLogicalArray(mpsSize ndim, const mpsSize *dims);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateStructMatrix(mpsSize m, mpsSize n, int nfields, const char **fieldnames);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateStructArray(mpsSize ndim, const mpsSize *dims, int nfields, const char **fieldnames);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateCellMatrix(mpsSize m, mpsSize n);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateCellArray(mpsSize ndim, const mpsSize *dims);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateSparse(mpsSize m, mpsSize n, mpsSize nzmax, mpsComplexity complexFlag);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray* mpsCreateSparseLogicalMatrix(mpsSize m, mpsSize n, mpsSize nzmax);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsDestroyArray(mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray *mpsDuplicateArray(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsFree(void *data);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsSize mpsGetNumberOfDimensions(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C size_t mpsGetElementSize(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C const mpsSize *mpsGetDimensions(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C int mpsSetDimensions(mpsArray *mlArr, const mpsSize *dims, mpsSize ndim);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C size_t mpsGetNumberOfElements(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsIndex mpsCalcSingleSubscript(const mpsArray *mlArr, mpsSize nsubs, mpsIndex *subs);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C size_t mpsGetM(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsSetM(mpsArray *mlArr, mpsSize m);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C size_t mpsGetN(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsSetN(mpsArray *mlArr, mpsSize n);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C double mpsGetScalar(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C double *mpsGetPr(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C double *mpsGetPi(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void *mpsGetData(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void *mpsGetImagData(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsChar *mpsGetChars(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C int mpsGetString(const mpsArray* mlArr, char* str, mpsSize len);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C char *mpsArrayToString(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsClassID mpsGetClassID(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C const char *mpsGetClassName(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsLogical *mpsGetLogicals(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray *mpsGetField(const mpsArray *mlArr, mpsIndex index, const char *fieldname);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsSetField(mpsArray *mlArr, mpsIndex index, const char *fieldname, mpsArray *pvalue);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C int mpsGetNumberOfFields(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C int mpsGetFieldNumber(const mpsArray *mlArr, const char *fieldname);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C const char *mpsGetFieldNameByNumber(const mpsArray *mlArr, int fieldnumber);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray *mpsGetFieldByNumber(const mpsArray *mlArr, mpsIndex index, int fieldnumber);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsSetFieldByNumber(mpsArray *mlArr, mpsIndex index, int fieldnumber, mpsArray *pvalue);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C int mpsAddField(mpsArray *mlArr, const char *fieldname);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsRemoveField(mpsArray *mlArr, int fieldnumber);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsArray *mpsGetCell(const mpsArray *mlArr, mpsIndex index);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsSetCell(mpsArray *mlArr, mpsIndex index, mpsArray *value);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsSize mpsGetNzmax(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C void mpsSetNzmax(mpsArray *mlArr, mpsSize nzmax);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsIndex *mpsGetIr(const mpsArray *mlArr);
 
MPSCLIENT_PUBLISHED_API_EXTERN_C mpsIndex *mpsGetJc(const mpsArray *mlArr);
 
#endif