ConOpSys_Variant.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
//! @file       ConOpSys_Variant.h
//! @brief      ConOpSys variant class header file.
//! @copyright  (C) 2004-2020 ANVILEX LLC
//! @attention  No special attention requered.
//!             $HeadURL: https://192.168.3.4:8443/svn/P004_07/ConOpSys/Common/ConOpSys_Variant.h $
//!             $Revision: 2944 $
//!             $Date: 2022-02-26 10:45:42 +0500 (Sa, 26 Feb 2022) $
//!             $Author: minch $
//------------------------------------------------------------------------------
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of ANVILEX nor the names of its contributors may be
//    used to endorse or promote products derived from this software without
//    specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//------------------------------------------------------------------------------
 
#pragma once
 
//------------------------------------------------------------------------------
// System includes
//------------------------------------------------------------------------------
 
#include "Defines.h"
#include "ConOpSys_Variant_Data_Type.h"
 
//#if CONOPSYS_TARGET == CONOPSYS_TARGET_DEVICE
//#include "Application_Resource_Configuration.h"
//#endif
 
#include "Application_Resource_Configuration.h"
 
//------------------------------------------------------------------------------
// VDC tool related includes
//------------------------------------------------------------------------------
 
#if CONOPSYS_TARGET == CONOPSYS_TARGET_VDC
#include <System.hpp>
#endif
 
//------------------------------------------------------------------------------
// Class definitions
//------------------------------------------------------------------------------
/*
//! @brief Variant data type enumeration
enum class TConOpSys_Variant_Data_Type : U8
{
 
  //! @brief Unassigned data type marker
  enum_Unassigned = 0,
 
  //! @brief Unknown data type marker
  enum_Unknown = 255,
 
  //! @brief Variant contains value of boolean data type
  enum_BOOL = 1,
 
  //! @brief Variant contains pointer to value of boolean data type
  enum_PBOOL = 2,
 
  //! @brief Variant contains pointer to array of values of boolean data type
  enum_ABOOL = 108,
 
  //! @brief Variant contains value of U8 data type
  enum_U8 = 3,
 
  //! @brief Variant contains pointer to value of U8 data type
  enum_PU8 = 4,
 
  //! @brief Variant contains pointer to array of values of U8 data type
  enum_AU8 = 109,
 
  //! @brief Variant contains value of I8 data type
  enum_I8 = 5,
 
  //! @brief Variant contains pointer to value of I8 data type
  enum_PI8 = 6,
 
  //! @brief Variant contains pointer to array of values of I8 data type
  enum_AI8 = 110,
 
  //! @brief Variant contains value of U16 data type
  enum_U16 = 7,
 
  //! @brief Variant contains pointer to value of U16 data type
  enum_PU16 = 8,
 
  //! @brief Variant contains pointer to array of values of U16 data type
  enum_AU16 = 111,
 
  //! @brief Variant contains value of I16 data type
  enum_I16 = 9,
 
  //! @brief Variant contains pointer to value of I16 data type
  enum_PI16 = 10,
 
  //! @brief Variant contains pointer to array of values of I16 data type
  enum_AI16 = 112,
 
  //! @brief Variant contains value of U32 data type
  enum_U32 = 11,
 
  //! @brief Variant contains pointer to value of U32 data type
  enum_PU32 = 12,
 
  //! @brief Variant contains pointer to array of values of U32 data type
  enum_AU32 = 113,
 
  //! @brief Variant contains value of I32 data type
  enum_I32 = 13,
 
  //! @brief Variant contains pointer to value of I32 data type
  enum_PI32 = 14,
 
  //! @brief Variant contains pointer to array of values of I32 data type
  enum_AI32 = 114,
 
  //! @brief Variant contains value of U64 data
  enum_U64 = 15,
 
  //! @brief Variant contains pointer to value of U64 data type
  enum_PU64 = 16,
 
  //! @brief Variant contains pointer to array of values of U64 data type
  enum_AU64 = 115,
 
  //! @brief Variant contains value of I64 data type
  enum_I64 = 17,
 
  //! @brief Variant contains pointer to value of I64 data type
  enum_PI64 = 18,
 
  //! @brief Variant contains pointer to array of values of I64 data type
  enum_AI64 = 116,
 
  //! @brief Variant contains value of U128 data
  //! @note PU128 data type reserved for future use
  enum_U128 = 19,
 
  //! @brief Variant contains pointer to value of U128 data type
  //! @note PU128 data type reserved for future use
  enum_PU128 = 20,
 
  //! @brief Variant contains pointer to array of values of U128 data type
  //! @note AU128 data type reserved for future use
  enum_AU128 = 117,
 
  //! @brief Variant contains value of I128 data
  //! @note I128 data type reserved for future use
  enum_I128 = 21,
 
  //! @brief Variant contains pointer to value of I128 data type
  //! @note PI128 data type reserved for future use
  enum_PI128 = 22,
 
  //! @brief Variant contains pointer to array of values of I128 data type
  //! @note AI128 data type reserved for future use
  enum_AI128 = 118,
 
  //! @brief Variant contains value of U256 data
  //! @note U256 data type reserved for future use
  enum_U256 = 23,
 
  //! @brief Variant contains pointer to value of U256 data type
  //! @note PU256 data type reserved for future use
  enum_PU256 = 24,
 
  //! @brief Variant contains pointer to array of values of U256 data type
  //! @note AU256 data type reserved for future use
  enum_AU256 = 119,
 
  //! @brief Variant contains value of I256 data
  //! @note PI256 data type reserved for future use
  enum_I256 = 25,
 
  //! @brief Variant contains pointer to value of I256 data type
  //! @note PI256 data type reserved for future use
  enum_PI256 = 26,
 
  //! @brief Variant contains pointer to array of values of I256 data type
  enum_AI256 = 120,
 
  //! @brief Variant contains value of F16 data
  //! @note F16 data type reserved for future use
  enum_F16 = 27,
 
  //! @brief Variant contains pointer to value of F16 data type
  //! @note PF16 data type reserved for future use
  enum_PF16 = 28,
      
  //! @brief Variant contains pointer to array of values of F16 data type
  //! @note F16 data type reserved for future use
  enum_AF16 = 121,
 
  //! @brief Variant contains value of F32 data
  enum_F32 = 29,
      
  //! @brief Variant contains pointer to value of F32 data type
  enum_PF32 = 30,
 
  //! @brief Variant contains pointer to array of values of F32 data type
  enum_AF32 = 122,
      
  //! @brief Variant contains value of F64 data
  enum_F64 = 31,
      
  //! @brief Variant contains pointer to value of F64 data type
  enum_PF64 = 32,
 
  //! @brief Variant contains pointer to array of values of F64 data type
  enum_AF64 = 123,
 
  // Test for F80 datatype supported
  #if ( PARAMETER_DATATYPE_F80_SUPPORT == (true) )
 
  //! @brief Variant contains value of F80 data
  //! @note F80 data type reserved for future use
  enum_F80 = 33,    // Reserved
 
  //! @brief Variant contains pointer to value of F80 data type
  //! @note PF80 data type reserved for future use
  enum_PF80 = 34,   // Reserved
 
  //! @brief Variant contains pointer to array of values of F80 data type
  //! @note AF80 data type reserved for future use
  enum_AF80 = 124,
 
  #endif
 
  //! @brief Variant contains value of F128 data
  //! @note F128 data type reserved for future use
  enum_F128 = 35,
  
  //! @brief Variant contains pointer to value of F128 data type
  //! @note PF128 data type reserved for future use
  enum_PF128 = 36,
  
  //! @brief Variant contains pointer to array of values of F128 data type
  //! @note AF128 data type reserved for future use
  enum_AF128 = 125,
      
  //! @brief Variant contains value of F256 data
  //! @note F256 data type reserved for future use
  enum_F256 = 37,
  
  //! @brief Variant contains pointer to value of F256 data type
  //! @note PF256 data type reserved for future use
  enum_PF256 = 38,
  
  //! @brief Variant contains pointer to array of values of F256 data type
  //! @note AF256 data type reserved for future use
  enum_AF256 = 126,
 
  // Fixed point data types
  enum_IQ1 = 39,
  enum_PIQ1 = 40,
      
  enum_IQ2 = 41,
  enum_PIQ2 = 42,
      
  enum_IQ3 = 43,
  enum_PIQ3 = 44,
      
  enum_IQ4 = 45,
  enum_PIQ4 = 46,
      
  enum_IQ5 = 47,
  enum_PIQ5 = 48,
      
  enum_IQ6 = 49,
  enum_PIQ6 = 50,
      
  enum_IQ7 = 51,
  enum_PIQ7 = 52,
      
  enum_IQ8 = 53,
  enum_PIQ8 = 54,
      
  enum_IQ9 = 55,
  enum_PIQ9 = 56,
      
  enum_IQ10 = 57,
  enum_PIQ10 = 58,
      
  enum_IQ11 = 59,
  enum_PIQ11 = 60,
      
  enum_IQ12 = 61,
  enum_PIQ12 = 62,
      
  enum_IQ13 = 63,
  enum_PIQ13 = 64,
      
  enum_IQ14 = 65,
  enum_PIQ14 = 66,
      
  enum_IQ15 = 67,
  enum_PIQ15 = 68,
      
  enum_IQ16 = 69,
  enum_PIQ16 = 70,
      
  enum_IQ17 = 71,
  enum_PIQ17 = 72,
      
  enum_IQ18 = 73,
  enum_PIQ18 = 74,
      
  enum_IQ19 = 75,
  enum_PIQ19 = 76,
      
  enum_IQ20 = 77,
  enum_PIQ20 = 78,
      
  enum_IQ21 = 79,
  enum_PIQ21 = 80,
      
  enum_IQ22 = 81,
  enum_PIQ22 = 82,
      
  enum_IQ23 = 83,
  enum_PIQ23 = 84,
      
  enum_IQ24 = 85,
  enum_PIQ24 = 86,
      
  enum_IQ25 = 87,
  enum_PIQ25 = 88,
      
  enum_IQ26 = 89,
  enum_PIQ26 = 90,
      
  enum_IQ27 = 91,
  enum_PIQ27 = 92,
      
  enum_IQ28 = 93,
  enum_PIQ28 = 94,
      
  enum_IQ29 = 95,
  enum_PIQ29 = 96,
      
  enum_IQ30 = 97,
  enum_PIQ30 = 98,
      
  enum_IQ31 = 99,
  enum_PIQ31 = 100,
      
  enum_IQ32 = 101,
  enum_PIQ32 = 102,
 
  //! @brief String data types
  enum_DS = 103,
 
  //! @brief Date and time
  //! @note Reserved
  enum_DT    = 104,
 
  //! @brief
  //! @note Reserved
  enum_LDT64 = 105,
 
  //! @brief Compressed data and time
  //! @note Reserved
  enum_CDT64 = 106,
 
  //! @brief Record datatype
  enum_R32 = 107,
 
  //! @brief Virtual machine program data type
  enum_VMP = 127,
  
  // NOTE: Last number 128
 
};
*/
//------------------------------------------------------------------------------
 
//! @brief ConOpSys variant data storage structure
//! @note Structure must be aligned to 8 byte in memory.
typedef union TConOpSys_Variant_Data
{
 
  //! @brief Generic data buffer
  union
  {
 
    //! @brief Nibble parsing struct
    struct
    {
 
      //! @brief Low nibble
      U8 u8_Low:4;
 
      //! @brief High nibble
      U8 u8_High:4;
 
    } struct_Nibble;
 
    //! @brief Data storage
    U8 u8_Byte;
 
  } u8_Buffer[ CONOPSYS_VARIANT_DATA_SIZE ];
 
  //! @brief U16 data buffer as bits
  struct
  {
    
    //! @brief Data storage U16, bit 0
    U16 b1_Bit_0:1;
    
    //! @brief Data storage U16, bit 1
    U16 b1_Bit_1:1;
    
    //! @brief Data storage U16, bit 2
    U16 b1_Bit_2:1;
    
    //! @brief Data storage U16, bit 3
    U16 b1_Bit_3:1;
    
    //! @brief Data storage U16, bit 4
    U16 b1_Bit_4:1;
    
    //! @brief Data storage U16, bit 5
    U16 b1_Bit_5:1;
    
    //! @brief Data storage U16, bit 6
    U16 b1_Bit_6:1;
    
    //! @brief Data storage U16, bit 7
    U16 b1_Bit_7:1;
    
    //! @brief Data storage U16, bit 8
    U16 b1_Bit_8:1;
    
    //! @brief Data storage U16, bit 9
    U16 b1_Bit_9:1;
    
    //! @brief Data storage U16, bit 10
    U16 b1_Bit_10:1;
    
    //! @brief Data storage U16, bit 11
    U16 b1_Bit_11:1;
    
    //! @brief Data storage U16, bit 12
    U16 b1_Bit_12:1;
    
    //! @brief Data storage U16, bit 13
    U16 b1_Bit_13:1;
    
    //! @brief Data storage U16, bit 14
    U16 b1_Bit_14:1;
    
    //! @brief Data storage U16, bit 15
    U16 b1_Bit_15:1;
    
  } u16_Bits;
  
  //! @brief Data storage for boolean value
  BOOL bool_Value;
 
  //! @brief Data storage for 8 bit unsigned integer value
  U8 u8_Value;
 
  //! @brief Data storage for 8 bit signed integer value
  I8 i8_Value;
 
  //! @brief Data storage for 16 bit unsigned integer value
  U16 u16_Value;
 
  //! @brief Data storage for 16 bit signed integer value
  I16 i16_Value;
 
  //! @brief Data storage for 32 bit unsigned integer value
  U32 u32_Value;
 
  //! @brief Data storage for 32 bit signed integer value
  I32 i32_Value;
 
  //! @brief Data storage for 64 bit unsigned integer value
  U64 u64_Value;
 
  //! @brief Data storage for 64 bit signed integer value
  I64 i64_Value;
 
//      //! @brief Data storage for 128 bit unsigned integer value
//      U128 u128_Value;
 
//      //! @brief Data storage for 128 bit signed integer value
//      I128 i128_Value;
 
//      //! @brief Data storage for 256 bit unsigned integer value
//      U256 u256_Value;
 
//      //! @brief Data storage for 256 bit signed integer value
//      I256 i256_Value;
 
//      //! @brief Data storage for 16 bit floating point number value
//      F16 f16_Value;
 
  //! @brief Data storage for 32 bit floating point number value
  F32 f32_Value;
 
  //! @brief Data storage for 64 bit floating point number value
  F64 f64_Value;
 
  // Test for F80 datatype supported
  #if ( PARAMETER_DATATYPE_F80_SUPPORT == (true) )
 
  //! @brief Data storage for 80 bit floating point number value
  F80 f80_Value;
 
  #endif
 
  // Test for F128 datatype supported
  #if ( PARAMETER_DATATYPE_F128_SUPPORT == (true) )
 
  //! @brief Data storage for 128 bit floating point number value
  F128 f128_Value;
 
  #endif
 
  // Test for F256 datatype supported
  #if ( PARAMETER_DATATYPE_F256_SUPPORT == (true) )
  
  //! @brief Data storage for 256 bit floating point number value
  F256 f256_Value;
 
  #endif
  
  // Test for IQ datatype supported
  #if ( PARAMETER_DATATYPE_IF_SUPPORT == (true) )
 
  //! @brief Data storage for 32 bit fixed point integer value in Q.1 format
  IQ1 iq1_Value;
 
  //! @brief Data storage for 32 bit fixed point integer value in Q.2 format
  IQ2 iq2_Value;
 
  //! @brief Data storage for 32 bit fixed point integer value in Q.3 format
  IQ3 iq3_Value;
 
  //! @brief Data storage for 32 bit fixed point integer value in Q.4 format
  IQ4 iq4_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.5 format
  IQ5 iq5_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.6 format
  IQ6 iq6_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.7 format
  IQ7 iq7_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.8 format
  IQ8 iq8_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.9 format
  IQ9 iq9_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.10 format
  IQ10 iq10_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.11 format
  IQ11 iq11_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.12 format
  IQ12 iq12_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.13 format
  IQ13 iq13_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.14 format
  IQ14 iq14_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.15 format
  IQ15 iq15_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.16 format
  IQ16 iq16_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.17 format
  IQ17 iq17_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.18 format
  IQ18 iq18_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.19 format
  IQ19 iq19_Value;
  
  //! @brief Data storage for 32 bit fixed point integer value in Q.20 format
  IQ20 iq20_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.21 format
  IQ21 iq21_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.22 format
  IQ22 iq22_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.23 format
  IQ23 iq23_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.24 format
  IQ24 iq24_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.25 format
  IQ25 iq25_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.26 format
  IQ26 iq26_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.27 format
  IQ27 iq27_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.28 format
  IQ28 iq28_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.29 format
  IQ29 iq29_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.30 format
  IQ30 iq30_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.31 format
  IQ31 iq31_Value;
      
  //! @brief Data storage for 32 bit fixed point integer value in Q.32 format
  IQ32 iq32_Value;
 
  #endif
 
  //! @brief Data storage for 64 bit data and time CDT64 value
  CDT64 cdt64_Value;
 
  // Record values
  R32 r32_Value;
 
  //----------------------------------------------------------------------------
  // Pointers to the data storages
  //----------------------------------------------------------------------------
 
// ANVILEX KM: Not required ==> To remove
//      U8 *pu8_Raw_Data[];
 
  // Pointer to the boolean value
  BOOL *pbool_Value;
 
  // Pointer to the 8 bit character values
  U8 *pu8_Value;
  I8 *pi8_Value;
 
  // Pointer to the 16 bit integer values
  U16 *pu16_Value;
  I16 *pi16_Value;
 
  // Pointer to the 32 bit integer values
  U32 *pu32_Value;
  I32 *pi32_Value;
 
  // Pointer to the 64 bit integer values
  U64 *pu64_Value;
  I64 *pi64_Value;
 
  // Pointer to the 128 bit integer values
  
  // Test for U128 datatype supported
  #if ( PARAMETER_DATATYPE_U128_SUPPORT == (true) )
  U128 *pu128_Value;
  #endif
  
  // Test for I128 datatype supported
  #if ( PARAMETER_DATATYPE_I128_SUPPORT == (true) )
  I128 *pi128_Value;
  #endif
 
  // Pointer to the 256 bit integer values
  
  // Test for U256 datatype supported
  #if ( PARAMETER_DATATYPE_U256_SUPPORT == (true) )
  U256 *pu256_Value;
  #endif
  
  // Test for I256 datatype supported
  #if ( PARAMETER_DATATYPE_I256_SUPPORT == (true) )
  I256 *pi256_Value;
  #endif
  
  // Pointer to the Floating point values
//      F16 *pf16_Value;
  F32 *pf32_Value;
  F64 *pf64_Value;
 
  #if ( PARAMETER_DATATYPE_F80_SUPPORT == (true) )
  F80 *pf80_Value;
  #endif
 
  // Test for F128 datatype supported
  #if ( PARAMETER_DATATYPE_F128_SUPPORT == (true) )
  F128 *pf128_Value;
  #endif
  
  // Test for F256 datatype supported
  #if ( PARAMETER_DATATYPE_F256_SUPPORT == (true) )
  F256 *pf256_Value;
  #endif
 
  // Pointer to fixed point values
  
  // Test for IQ datatype supported
  #if ( PARAMETER_DATATYPE_IQ_SUPPORT == (true) )
  IQ1 *piq1_Value;
  IQ2 *piq2_Value;
  IQ3 *piq3_Value;
  IQ4 *piq4_Value;
  IQ5 *piq5_Value;
  IQ6 *piq6_Value;
  IQ7 *piq7_Value;
  IQ8 *piq8_Value;
  IQ9 *piq9_Value;
  IQ10 *piq10_Value;
  IQ11 *piq11_Value;
  IQ12 *piq12_Value;
  IQ13 *piq13_Value;
  IQ14 *piq14_Value;
  IQ15 *piq15_Value;
  IQ16 *piq16_Value;
  IQ17 *piq17_Value;
  IQ18 *piq18_Value;
  IQ19 *piq19_Value;
  IQ20 *piq20_Value;
  IQ21 *piq21_Value;
  IQ22 *piq22_Value;
  IQ23 *piq23_Value;
  IQ24 *piq24_Value;
  IQ25 *piq25_Value;
  IQ26 *piq26_Value;
  IQ27 *piq27_Value;
  IQ28 *piq28_Value;
  IQ29 *piq29_Value;
  IQ30 *piq30_Value;
  IQ31 *piq31_Value;
  IQ32 *piq32_Value;
  #endif
  
  // Pointer to data and time values
  CDT64 *pcdt64_Value;
 
  // Pointer to the array of values
//  BOOL *abool_Value;
 
  VOID *pvoid_Value;
 
  //----------------------------------------------------------------------------
  
  struct
  {
    union
    {
      TConOpSys_Variant_Data *vd_Value;
//      TConOpSys_Variant_Data *vd_Value;
      BOOL *abool_Value;
      I8 *ai8_Value;
      U8 *au8_Value;
      I16 *ai16_Value;
      U16 *au16_Value;
      I32 *ai32_Value;
      U32 *au32_Value;
      I64 *ai64_Value;
      U64 *au64_Value;
      F32 *af32_Value;
      F64 *af64_Value;
      U64 *avmp_Value;
    };
    U32 u32_Size;
  };
  
  //----------------------------------------------------------------------------
  
  //! @brief Virtual machine program
  U64 vmp_Value;
 
  //! @brief VM command raw
  U64 u64_VM_Command;
 
  struct
  {
 
    //! @brief result data index
    U16 u16_Result_Index;
 
    //! @brief operand 1 data index
    U16 u16_Operand_1_Index;
 
    //! @brief operand 2 data index
    U16 u16_Operand_2_Index;
 
    union 
    {
 
      //! @brief Opcode payload
      U16 u16_Opcode;
 
      struct
      {
 
        //! @brief Operand 1 type
        U16 bit2_Operand_1_Type:2;
 
        //! @brief Operand 2 type
        U16 bit2_Operand_2_Type:2;
 
        //! @brief Result 1 type
        U16 bit2_Result_Type:2;
 
        //! @brief Command opcode
        U16 bit10_Command:10;
 
      } /*TOpcode_Struct*/;
 
    };
 
  } struct_VM_Command;
 
} TConOpSys_Variant_Data;
 
//------------------------------------------------------------------------------
 
//! @brief ConOpSys variant class
class TConOpSys_Variant
{
 
  //----------------------------------------------------------------------------
  // Public defines, methods and variables
  //----------------------------------------------------------------------------
 
  public:
 
    //!-------------------------------------------------------------------------
    //! @brief     Class constructor method
    //! @note      The method create application object.
    //! @return    None
    //! \par       Override
    //!            Not allowed
    //! @attention Don't call this method directly.
    //! \par       UML diagram
    //! @dotfile   TConOpSys_Variant__TConOpSys_Variant.dt
    //--------------------------------------------------------------------------
    
    TConOpSys_Variant();
  
    //!-------------------------------------------------------------------------
    //! @brief     Class constructor method
    //! @note      The method create application object.
    //! @param     [in] enum_New_Type - Stored by variant datatype enumerator
    //! @return    None
    //! \par       Override
    //!            Not allowed
    //! @attention Don't call this method directly.
    //! \par       UML diagram
    //! @dotfile   TConOpSys_Variant__TConOpSys_Variant.dt
    //--------------------------------------------------------------------------
 
    TConOpSys_Variant( TConOpSys_Variant_Data_Type enum_New_Type );
/*
    //!-------------------------------------------------------------------------
    //! @brief     Class destructor method
    //! @note      None
    //! @return    None
    //! \par       Override
    //!            Not allowed
    //! @attention Don't call this method directly.
    //! \par       UML diagram
    //! @dotfile   TConOpSys_Variant___TConOpSys_Variant.dt
    //--------------------------------------------------------------------------
 
    ~TConOpSys_Variant(); //!< Class destructor method
*/
    BOOL Set_Type( TConOpSys_Variant_Data_Type enum_New_Type, TConOpSys_Variant_Data *struct_Array, U32 u32_Size );
 
    // Variant data type management related methods
    BOOL Set_Type( TConOpSys_Variant_Data_Type enum_New_Type ); //!< Set datatype
    
    #if CONOPSYS_TARGET == CONOPSYS_TARGET_VDC
    BOOL __fastcall Set_Type( UnicodeString ucs_Type_Name ); //!< Set datatype referenced by the datatype name
    #endif
    
    TConOpSys_Variant_Data_Type Get_Type(); //!< Get assigned variant datatype
    
    #if CONOPSYS_TARGET == CONOPSYS_TARGET_VDC
    UnicodeString __fastcall Get_Type_As_UCS();
    #endif
    
    TConOpSys_Variant_Data_Type Get_Storage_Type();
  
  // ANVILEX KM: Depricated ==> To remove after the test  
//    TConOpSys_Datatype Get_ConOpSys_Type(); //!< Get assigned ConOpSys datatype
    
    U32 Get_Size(); //!< Get value size in bytes
 
    BOOL Is_Assignable_From( TConOpSys_Variant_Data_Type enum_Type );
    BOOL Is_Pointer_Type();
    BOOL Is_Storage_Type();
 
    BOOL Set_Random_Value(); //!< Set random value. Used for debug purpoise only
    BOOL Encode_Momentum_Datatype(); //!< Customer specific data encoding
    BOOL Decode_Momentum_Datatype(); //!< Customer specific data decoding
 
    // Value converstion related methods
    BOOL Precheck_Value_As_Decimal_String( C8 *s8_Value ); //!< Precheck value from decimal string
    BOOL Set_Value_As_Decimal_String( C8 *s8_Value ); //!< Set value from decimal string
    BOOL Set_Value_As_Hex_String( C8 *s8_Value ); //!< Set value from hexal string
    BOOL Set_Value_As_BOOL( BOOL bool_Value ); //! Set value from BOOL value
    BOOL Set_Value_As_U8( U8 u8_Value ); //! Set value from U8 value
    BOOL Set_Value_As_I8( I8 i8_Value ); //! Set value from I8 value
    BOOL Set_Value_As_U16( U16 u16_Value ); //! Set value from U16 value
    BOOL Set_Value_As_I16( I16 i16_Value ); //! Set value from I16 value
    BOOL Set_Value_As_U32( U32 u32_Value ); //! Set value from U32 value
    BOOL Set_Value_As_I32( I32 i32_Value ); //! Set value from I32 value
    BOOL Set_Value_As_U64( U64 u64_Value ); //! Set value from U64 value
    BOOL Set_Value_As_I64( I64 i64_Value ); //! Set value from I64 value
    BOOL Set_Value_As_F32( F32 f32_Value ); //! Set value from F32 value
    BOOL Set_Value_As_F64( F64 f64_Value ); //! Set value from F64 value
    BOOL Set_Value_U64_As_VMP( U64 u64_VMP_Value ); //! Set value from VMP value
 
//    BOOL Set_Value_As_Variant( TConOpSys_Variant *object_Variant_Value, U32 u32_Element_Index );
    BOOL Set_Value_As_Variant( TConOpSys_Variant_Data *object_Variant_Value );
    BOOL Set_Value_As_Variant( TConOpSys_Variant_Data *object_Variant_Value, U32 u32_Element_Index );
        
    VOID Get_Value_As_Decimal_String( C8 *s8_Value, U32 u32_Buffer_Size ); //!< Get value as decimal string
    VOID Get_Value_As_Hex_String( C8 *s8_Value, U32 u32_Buffer_Size ); //!< Get value as hexal string
    VOID Get_Value_As_F64( F64 *f64_Value ); //!< Get value as F64
 
    BOOL Get_Value_As_Variant( TConOpSys_Variant_Data *object_Variant_Value, U32 u32_Element_Index );
 
    VOID Assign( TConOpSys_Variant *object_Value_To_Assign ); //!< Assign variant to variant
 
    //!-------------------------------------------------------------------------
    //! @brief     Clear variant data buffer method
    //! @note      Fills variant data buffer with zeros
    //! @return    None
    //! \par       Override
    //!            Not allowed
    //! @attention None
    //! \par       UML diagram
    //! @dotfile   TConOpSys_Variant__Clear.dt
    //--------------------------------------------------------------------------
 
    VOID Clear();
 
    //--------------------------------------------------------------------------
    // Public operatirs
    //--------------------------------------------------------------------------
 
    //! @brief Assign operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator=.dt
    TConOpSys_Variant& operator=( TConOpSys_Variant const &rhs ); 
    
    //! @brief Assign operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator=.dt
    TConOpSys_Variant& operator=( TConOpSys_Variant_Data const &rhs );
 
//    //! @brief Index operator overload     
//    //! \par       UML diagram
//    //! @dotfile TConOpSys_Variant__operator[].dt
//    TConOpSys_Variant& operator[]( U32 u32_Index );
 
    //! @brief Equal operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator==.dt
    BOOL operator==( TConOpSys_Variant const &rhs ); 
    
    //! @brief Equal operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator==.dt
    BOOL operator==( TConOpSys_Variant_Data const &rhs ); 
    
    //! @brief Not equal operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator!=.dt
    BOOL operator!=( TConOpSys_Variant const &rhs ); 
    
    //! @brief Not equal operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator!=.dt
    BOOL operator!=( TConOpSys_Variant_Data const &rhs ); 
    
    //! @brief Less operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator<.dt
    BOOL operator<( TConOpSys_Variant const &rhs ); 
    
    //! @brief Less operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator<.dt
    BOOL operator<( TConOpSys_Variant_Data const &rhs ); 
    
    //! @brief Less or queal operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator<=.dt
    BOOL operator<=( TConOpSys_Variant const &rhs ); 
    
    //! @brief Less or queal operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator<=.dt
    BOOL operator<=( TConOpSys_Variant_Data const &rhs ); 
    
    //! @brief Grater operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator>.dt
    BOOL operator>( TConOpSys_Variant const &rhs ); 
    
    //! @brief Grater operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator>.dt
    BOOL operator>( TConOpSys_Variant_Data const &rhs ); 
    
    //! @brief Grater or queal operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator>=.dt
    BOOL operator>=( TConOpSys_Variant const &rhs ); 
    
    //! @brief Grater or queal operator overload
    //! \par       UML diagram
    //! @dotfile TConOpSys_Variant__operator>=.dt
    BOOL operator>=( TConOpSys_Variant_Data const &rhs ); 
 
    //--------------------------------------------------------------------------
    // Public variables
    //--------------------------------------------------------------------------
 
    //! @brief Variant data storage
    TConOpSys_Variant_Data struct_Data;
 
    #if CONOPSYS_TARGET == CONOPSYS_TARGET_VDC
    //! @brief Variant data storage for strings
    UnicodeString ds_Data;
    #endif
 
  //----------------------------------------------------------------------------
  // Protected defines, methods and variables
  //----------------------------------------------------------------------------
 
  protected:
 
  //----------------------------------------------------------------------------
  // Private defines, methods and variables
  //----------------------------------------------------------------------------
 
  private:
 
    //--------------------------------------------------------------------------
    // Private variables
    //--------------------------------------------------------------------------
 
  // ANVILEX : To implement storage as private variable
//    TConOpSys_Variant_Data struct_Data; //!< Variant data storage
 
    //! @brief By the variant storage carried data type
    TConOpSys_Variant_Data_Type enum_Type;
 
};
 
//------------------------------------------------------------------------------
// Datatype names definition
//------------------------------------------------------------------------------
 
#if CONOPSYS_TARGET == CONOPSYS_TARGET_VDC
extern US us_Datatype_Names[ 256 ];
#endif
 
//------------------------------------------------------------------------------
// End of file
//------------------------------------------------------------------------------