WSoftwareVersion.h

#pragma once
#include <SoftwareVersion.h>
 
 
using namespace WEnumerations;
 
namespace WUtils {
    public ref class WSoftwareVersion
    {
    public:
        WSoftwareVersion() {
            _softVer = new SoftwareVersion();
        }
 
        WSoftwareVersion(WSoftwareVersion^ toCopy) {
            _softVer = new SoftwareVersion();
            Version = toCopy->Version;
            Revision = toCopy->Revision;
            Prototype = toCopy->Prototype;
            HardwareVersion = toCopy->HardwareVersion;
            CanNumber = toCopy->CanNumber;
            PartNumber = toCopy->PartNumber;
        }
 
        ~WSoftwareVersion() {
            delete(_softVer);
        }
 
        property int Version {
            int get() {
                return _softVer->GetVersion();
            }
            void set(int x) {
                _softVer->SetVersion(x);
            }
        }
        property int Revision {
            int get() {
                return _softVer->GetRevision();
            }
            void set(int x) {
                _softVer->SetRevision(x);
            }
        }
        property int Prototype {
            int get() {
                return _softVer->GetPrototype();
            }
            void set(int x) {
                _softVer->SetPrototype(x);
            }
        }
 
        property unsigned long CanNumber {
            unsigned long get() {
                return _softVer->GetCanNumber();
            }
            void set(unsigned long x) {
                _softVer->SetCanNumber(x);
            }
        }
        property unsigned int HardwareVersion {
            unsigned int get() {
                return _softVer->GetHardwareVersion();
            }
            void set(unsigned int x) {
                _softVer->SetHardwareVersion(x);
            }
        }
 
        property long PartNumber {
            long get() {
                return _softVer->GetPartNumber();
            }
            void set(long x) {
                _softVer->SetPartNumber(x);
            }
        }
 
        property ProductIdentification ProductTypeIdentification {
            ProductIdentification get() {
                unsigned int productType = _softVer->GetProductIdentification();
 
                switch (productType) {
                case UNKNOWN_PRODUCT:
                    return ProductIdentification::Unknown;
                case RAW_DATA:
                    return ProductIdentification::RawData;
                case ANTI_COLLISION:
                    return ProductIdentification::AntiCollision;
                case NAVIGATION:
                    return ProductIdentification::Navigation;
                case ROD_120:
                    return ProductIdentification::Rod120;
                case ROD_130:
                    return ProductIdentification::Rod130;
                case ROD_300:
                    return ProductIdentification::Rod300;
                case ROD_500:
                    return ProductIdentification::Rod500;
                }
            }
            void set(ProductIdentification x) {
                _softVer->SetProductIdentification(x.GetHashCode());
            }
        }
 
        static bool operator== (WSoftwareVersion^ pComp1, WSoftwareVersion^ pComp2) {
            if (System::Object::ReferenceEquals(pComp1, pComp2))
                return true;
 
            if (System::Object::ReferenceEquals(pComp1, nullptr) ||
                System::Object::ReferenceEquals(pComp2, nullptr)) {
                return false;
            }
            return pComp1->Version == pComp2->Version &&
                pComp1->Revision == pComp2->Revision &&
                pComp1->Prototype == pComp2->Prototype &&
                pComp1->HardwareVersion == pComp2->HardwareVersion &&
                pComp1->CanNumber == pComp2->CanNumber &&
                pComp1->PartNumber == pComp2->PartNumber &&
                pComp1->ProductTypeIdentification == pComp2->ProductTypeIdentification;
        }
 
        static bool operator!= (WSoftwareVersion^ pComp1, WSoftwareVersion^ pComp2) {
            return !(pComp1 == pComp2);
        }
    private:
        SoftwareVersion* _softVer;
    };
}