sopc_encodeabletype.h

Go to the documentation of this file.

/*
 * Licensed to Systerel under one or more contributor license
 * agreements. See the NOTICE file distributed with this work
 * for additional information regarding copyright ownership.
 * Systerel licenses this file to you under the Apache
 * License, Version 2.0 (the "License"); you may not use this
 * file except in compliance with the License. You may obtain
 * a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef SOPC_ENCODEABLETYPE_H_
#define SOPC_ENCODEABLETYPE_H_
 
#include <stddef.h>
#include <stdint.h>
 
#include "sopc_buffer.h"
#include "sopc_enums.h"
 
typedef void(SOPC_EncodeableObject_PfnInitialize)(void* value);
 
typedef void(SOPC_EncodeableObject_PfnClear)(void* value);
 
typedef SOPC_ReturnStatus(SOPC_EncodeableObject_PfnEncode)(const void* value,
                                                           SOPC_Buffer* buffer,
                                                           uint32_t nestedStructLevel);
 
typedef SOPC_ReturnStatus(SOPC_EncodeableObject_PfnDecode)(void* value,
                                                           SOPC_Buffer* buffer,
                                                           uint32_t nestedStructLevel);
 
typedef SOPC_ReturnStatus(SOPC_EncodeableObject_PfnCopy)(void* dest, const void* src);
 
typedef SOPC_ReturnStatus(SOPC_EncodeableObject_PfnComp)(const void* left, const void* right, int32_t* comp);
 
/*
 * \brief Description of an encodeable type field.
 *
 * This structure has been designed to be very compact and fit into 8 bytes.
 * The \c isBuiltIn field indicates whether the field type is built-in or
 * defined in the address space.  In the first case, the type index is a member
 * of the \c SOPC_BuiltinId enumeration.  In the second case, it is a member of
 * the \c SOPC_TypeInternalIndex enumeration.
 *
 * The \c isArrayLength field indicates whether this field contains the length
 * of an array.  When true, the field must be of built-in type \c Int32, and the
 * array is described by the next field.
 *
 * The \c isToEncode field indicates whether this field shall be encoded and
 * decoded.  When false, the field is only initialized and cleared.
 *
 * The \c isSameNs field indicates whether the referenced type is in the same
 * namespace than the type containing the field. When false, the \c nsIndex shall
 * be used to resolve the referenced type.
 *
 * The \c nsIndex field indicates the namespace index of the referenced type.
 * In order to could be resolved, the namespace shall have been recorded by
 * the
 * in the
 * It shall be a valid value of ::SOPC_TypeInternalIndex enum type.
 * Note: fields can only be of internal defined types for user-defined types.
 *
 * The \c typeIndex field indicates the index of type in internal types array
 * (namespaceTypesArray of encodeable type containing the field descriptor)
 * It shall be a valid value of ::SOPC_TypeInternalIndex enum type.
 * Note: fields can only be of internal defined types for user-defined types.
 *
 * Finally, the \c offset field gives the offset in bytes of the field in the
 * object structure.
 */
typedef struct SOPC_EncodeableType_FieldDescriptor
{
    bool isBuiltIn : 1;
    bool isArrayLength : 1;
    bool isToEncode : 1;
    bool isSameNs : 1;
    uint16_t nsIndex : 7;
    uint32_t typeIndex : 21;
    uint32_t offset;
} SOPC_EncodeableType_FieldDescriptor;
 
typedef const struct SOPC_EncodeableType_Struct
{
    char* TypeName;
    uint32_t TypeId;
    uint32_t BinaryEncodingTypeId;
    uint32_t XmlEncodingTypeId;
    char* NamespaceUri;      
    uint16_t NamespaceIndex; 
    size_t AllocationSize;
    SOPC_EncodeableObject_PfnInitialize* Initialize;
    SOPC_EncodeableObject_PfnClear* Clear;
    int32_t NoOfFields;
    const SOPC_EncodeableType_FieldDescriptor* Fields;
 
    const struct SOPC_EncodeableType_Struct** namespaceTypesArray;
} SOPC_EncodeableType;
 
SOPC_ReturnStatus SOPC_EncodeableType_AddUserType(SOPC_EncodeableType* encoder);
 
SOPC_ReturnStatus SOPC_EncodeableType_RemoveUserType(SOPC_EncodeableType* encoder);
 
void SOPC_EncodeableType_RemoveAllUserTypes(void);
 
SOPC_EncodeableType* SOPC_EncodeableType_GetUserType(uint16_t nsIndex, uint32_t typeId);
 
SOPC_ReturnStatus SOPC_EncodeableType_RegisterTypesArray(size_t nsTypesArrayLen, SOPC_EncodeableType** nsTypesArray);
 
SOPC_ReturnStatus SOPC_EncodeableType_UnRegisterTypesArray(size_t nsTypesArrayLen, SOPC_EncodeableType** nsTypesArray);
 
SOPC_EncodeableType* SOPC_EncodeableType_GetEncodeableType(uint16_t nsIndex, uint32_t typeId);
 
const char* SOPC_EncodeableType_GetName(SOPC_EncodeableType* encType);
 
void SOPC_EncodeableObject_Initialize(SOPC_EncodeableType* type, void* pValue);
 
void SOPC_EncodeableObject_Clear(SOPC_EncodeableType* type, void* pValue);
 
SOPC_ReturnStatus SOPC_EncodeableObject_Create(SOPC_EncodeableType* encTyp, void** encObject);
 
SOPC_ReturnStatus SOPC_EncodeableObject_Delete(SOPC_EncodeableType* encTyp, void** encObject);
 
SOPC_ReturnStatus SOPC_EncodeableObject_Encode(SOPC_EncodeableType* type,
                                               const void* pValue,
                                               SOPC_Buffer* buf,
                                               uint32_t nestedStructLevel);
 
SOPC_ReturnStatus SOPC_EncodeableObject_Decode(SOPC_EncodeableType* type,
                                               void* pValue,
                                               SOPC_Buffer* buf,
                                               uint32_t nestedStructLevel);
 
SOPC_ReturnStatus SOPC_EncodeableObject_Copy(SOPC_EncodeableType* type, void* destValue, const void* srcValue);
 
SOPC_ReturnStatus SOPC_EncodeableObject_Move(void* destObj, void* srcObj);
 
SOPC_ReturnStatus SOPC_EncodeableObject_Compare(SOPC_EncodeableType* type,
                                                const void* leftValue,
                                                const void* rightValue,
                                                int32_t* comp);
 
#endif /* SOPC_ENCODEABLETYPE_H_ */