PolyType.hpp

Go to the documentation of this file.

#ifndef FW_POLY_TYPE_HPP
#define FW_POLY_TYPE_HPP
 
#include <FpConfig.hpp>
#include <Fw/Cfg/SerIds.hpp>
#include <Fw/Types/Serializable.hpp>
#include <Fw/Types/StringType.hpp>
 
namespace Fw {
 
class PolyType : public Serializable {
  public:
    PolyType(U8 val);             
    operator U8();                
    void get(U8& val);            
    bool isU8();                  
    PolyType& operator=(U8 val);  
 
    PolyType(I8 val);             
    operator I8();                
    void get(I8& val);            
    bool isI8();                  
    PolyType& operator=(I8 val);  
 
#if FW_HAS_16_BIT
    PolyType(U16 val);             
    operator U16();                
    void get(U16& val);            
    bool isU16();                  
    PolyType& operator=(U16 val);  
 
    PolyType(I16 val);             
    operator I16();                
    void get(I16& val);            
    bool isI16();                  
    PolyType& operator=(I16 val);  
#endif
#if FW_HAS_32_BIT
    PolyType(U32 val);             
    operator U32();                
    void get(U32& val);            
    bool isU32();                  
    PolyType& operator=(U32 val);  
 
    PolyType(I32 val);             
    operator I32();                
    void get(I32& val);            
    bool isI32();                  
    PolyType& operator=(I32 val);  
#endif
#if FW_HAS_64_BIT
    PolyType(U64 val);             
    operator U64();                
    void get(U64& val);            
    bool isU64();                  
    PolyType& operator=(U64 val);  
 
    PolyType(I64 val);             
    operator I64();                
    void get(I64& val);            
    bool isI64();                  
    PolyType& operator=(I64 val);  
#endif
 
#if FW_HAS_F64
    PolyType(F64 val);             
    operator F64();                
    void get(F64& val);            
    bool isF64();                  
    PolyType& operator=(F64 val);  
#endif
    PolyType(F32 val);             
    operator F32();                
    void get(F32& val);            
    bool isF32();                  
    PolyType& operator=(F32 val);  
 
    PolyType(bool val);             
    operator bool();                
    void get(bool& val);            
    bool isBool();                  
    PolyType& operator=(bool val);  
 
    PolyType(void* val);             
    operator void*();                
    void get(void*& val);            
    bool isPtr();                    
    PolyType& operator=(void* val);  
 
    PolyType();                          
    PolyType(const PolyType& original);  
    virtual ~PolyType();                 
 
#if FW_SERIALIZABLE_TO_STRING || BUILD_UT
    void toString(StringBase& dest, bool append) const;  
    void toString(StringBase& dest) const;               
#endif
 
    PolyType& operator=(const PolyType& src);                      
    bool operator<(const PolyType& other) const;                   
    bool operator>(const PolyType& other) const;                   
    bool operator>=(const PolyType& other) const;                  
    bool operator<=(const PolyType& other) const;                  
    bool operator==(const PolyType& other) const;                  
    bool operator!=(const PolyType& other) const;                  
    SerializeStatus serialize(SerializeBufferBase& buffer) const;  
    SerializeStatus deserialize(SerializeBufferBase& buffer);      
 
  PRIVATE:
    typedef enum {
        TYPE_NOTYPE,  // !< No type stored yet
        TYPE_U8,      // !< U8 type stored
        TYPE_I8,      // !< I8 type stored
#if FW_HAS_16_BIT
        TYPE_U16,  // !< U16 type stored
        TYPE_I16,  // !< I16 type stored
#endif
#if FW_HAS_32_BIT
        TYPE_U32,  // !< U32 type stored
        TYPE_I32,  // !< I32 type stored
#endif
#if FW_HAS_64_BIT
        TYPE_U64,  // !< U64 type stored
        TYPE_I64,  // !< I64 type stored
#endif
        TYPE_F32,  // !< F32 type stored
#if FW_HAS_F64
        TYPE_F64,  // !< F64 type stored
#endif
        TYPE_BOOL,  // !< bool type stored
        TYPE_PTR    // !< pointer type stored
    } Type;
 
    Type m_dataType;  
 
    union PolyVal {
        U8 u8Val;  
        I8 i8Val;  
#if FW_HAS_16_BIT
        U16 u16Val;  
        I16 i16Val;  
#endif
#if FW_HAS_32_BIT
        U32 u32Val;  
        I32 i32Val;  
#endif
#if FW_HAS_64_BIT
        U64 u64Val;  
        I64 i64Val;  
#endif
#if FW_HAS_F64
        F64 f64Val;  
#endif
        F32 f32Val;    // !< F32 data storage
        void* ptrVal;  // !< pointer data storage
        bool boolVal;  // !< bool data storage
    } m_val;           // !< stores data value
 
  public:
    enum {
        SERIALIZED_TYPE_ID = FW_TYPEID_POLY,                         
        SERIALIZED_SIZE = sizeof(FwEnumStoreType) + sizeof(PolyVal)  
    };
};
 
}  // namespace Fw
 
#endif