cs_license.h

#pragma once
namespace sb_cs
{
    public enum class SbLicenseType :int {
        SB_LICENSE_NULL =       SB_LICENSE_NULL,        
        SB_LICENSE_DISABLED =   SB_LICENSE_DISABLED,    
        SB_LICENSE_DEMO =       SB_LICENSE_DEMO,        
        SB_LICENSE_MASTER =     SB_LICENSE_MASTER,      
        SB_LICENSE_NOT_PRESENT =SB_LICENSE_NOT_PRESENT  
    };
 
    public enum class SbLicenseConfigurationId :int {
        SB_LICENSE_PREMIUM  =   SB_LICENSE_PREMIUM,         
        SB_LICENSE_STANDARD =   SB_LICENSE_STANDARD,        
        SB_LICENSE_BASIC    =   SB_LICENSE_BASIC,           
        SB_LICENSE_CONFIGURATION_NUMBER = SB_LICENSE_CONFIGURATION_NUMBER
    };
 
    public enum class SbLicenseModuleId :int
    {
        SB_LICENSE_MODULE_NONE         = SB_LICENSE_MODULE_NONE,        
        SB_LICENSE_MODULE_RETINA       = SB_LICENSE_MODULE_RETINA,      
        SB_LICENSE_MODULE_SURFACE      = SB_LICENSE_MODULE_SURFACE,     
        SB_LICENSE_MODULE_DEEP_CORTEX  = SB_LICENSE_MODULE_DEEP_CORTEX, 
        SB_LICENSE_MODULE_DEEP_SURFACE = SB_LICENSE_MODULE_DEEP_SURFACE,
         SB_LICENSE_MODULE_NUMBER = SB_LICENSE_MODULE_NUMBER
    };
 
    public enum class SbLicenseModuleStatus :int {
        SB_LICENSE_MODULE_STATUS_NULL =     SB_LICENSE_MODULE_STATUS_NULL,      
        SB_LICENSE_MODULE_STATUS_ACTIVE =   SB_LICENSE_MODULE_STATUS_ACTIVE,    
        SB_LICENSE_MODULE_STATUS_DISABLED = SB_LICENSE_MODULE_STATUS_DISABLED,  
        SB_LICENSE_MODULE_STATUS_ERR =      SB_LICENSE_MODULE_STATUS_ERR        
    };
 
    public ref class SbLicenseConfiguration
    {
    public:
        SbLicenseConfigurationId id; 
        int num_models;                   
 
        int num_features;
 
        int num_threads;
 
        float speed_boost;    
    internal:
        SbLicenseConfiguration(const sb_t_license_configuration* const src);
        SbError CopyFromNative(const sb_t_license_configuration* const src);
    };
 
    public ref class SbLicenseModule
    {
    public:
        SbLicenseType type;
 
        SbLicenseConfiguration^ configuration;
 
        bool training;
 
        SbVersion^ version;
 
        SbTime^ time_start;
 
        SbTime^ time_end;
 
        signed long long remain;
 
        SbLicenseModuleStatus status;
 
        SbError err;
 
        String^ sn;
    internal:
        SbLicenseModule(const sb_t_license_module* const src);
        SbError CopyFromNative(const sb_t_license_module* const src);
    };
 
 
    public ref class SbLicense: SbCommon
    {
    public:
        String^ address;              
        String^ company;              
        String^ company_role;         
        String^ mail;                 
        String^ name;                 
        String^ operating_system;     
        String^ phone;                
        String^ surname;              
        String^ sector_of_interest;   
        String^ vat;                  
        String^ vendor_code;          
        String^ machine_id;
        array<SbLicenseModule^>^ module;
        SbTime^ time_create;
        SbTime^ time_modify;
        SbTime^ time_save;
 
        static SbLicense^ GetInfo();
 
        String^ FormatInfo();
 
        static String^ FormatModuleId(SbLicenseModuleId id);
 
        static String^ FormatModuleStatus(SbLicenseModuleStatus status);
 
        static String^ FormatType(SbLicenseType type);
 
        static String^ FormatConfiguration(SbLicenseConfigurationId id);
 
        static String^ GetHardwareInfo();
 
        static const int LICENSE_MODULE_NUMBER = SB_LICENSE_MODULE_NUMBER;
 
    internal:
        SbLicense();
        ~SbLicense();
        sb_t_license *sb_license;
        SbError CopyFromNative(const sb_t_license* const license);
    }; // group_cs_license // group_cs
}