cel_license.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_license_h_
#define _cel_license_h_

#include "cel_types.h"
#include "cel_referable.h"
#include "cel_lockable.h"
#include "cel_memory.h"
#include "cel_string.h"
#include "cel_time.h"
#include <map>

namespace Celartem
{
    namespace License
    {
        enum Feature
        {
            PixelLiveImaging = 0, 
            VFZEncode = 1, 
            MrSIDEncode = 2, 
            JPEG2000Encode = 3, 
            GenuineFractals = 4, 
            DjVuDecode = 5, 
            DjVuEncode = 6, 
            SecureDjVuDecode = 7, 
            SecureDjVuEncode = 8, 
            PerformOCR = 9, 
            Feature10, 
            Feature11, 
            Feature12, 
            Feature13, 
            Feature14, 
            Feature15, 
            Feature16, 
            Feature17, 
            Feature18, 
            Feature19, 
            Feature20, 
            Feature21, 
            Feature22, 
            Feature23, 
            Feature24, 
            Feature25, 
            Feature26, 
            Feature27, 
            Feature28, 
            Feature29, 
            Feature30, 
            Feature31, 
        };
        
        enum {MAX_FEATURES = 32};
        
        enum ActivationScheme
        {
            Disabled = 0, 
            Unlimited = 1, 
            ByCartridge = 2, 
            Development = 3, 
            ActivationServer = 4, 
        };

        struct ProductStatus;

        class LicenseManager
        {
        public:
            static LicenseManager& getLicenseManager();
            
            virtual void setLicenseScript(const String& inLicense) = 0;
            
            virtual void setLicenseTarget(void* target, const String& inCookie) = 0;
            
            virtual String getLicenseScript() const = 0;
            
            virtual String getProductId() const = 0;
            
            virtual String getProductDescription() const = 0;

            virtual ActivationScheme getActivationScheme(Feature inFeature) const = 0;
            
            virtual String getMachineId() const = 0;
            
            virtual String getStatusString(
                bool inHumanReadable,
                const String& inProductId = NullString) const = 0;

            static String getStatusStringFromProductStatus(
                bool inHumanReadable,
                const String& inMachineId,
                const ProductStatus& inProductStatus);
            
            static String getProductStatusFromString(
                const String& inStatusString,
                ProductStatus& outProductStatus);

            virtual void setActivationServerUrl(
                const String& inActivationServerUrl) = 0;

            virtual String getActivationServerUrl() const = 0;

            static String createLicenseScript(
                const String& inUnencryptedScript);
            
            static String getFeatureName(Feature inFeature);

#if CEL_ENV_POSIX

            static void setLicenseDbDirectory(
                const String& inLicenseDbDirectory);
#endif

        protected:
            virtual ~LicenseManager() {}
        };
        
        struct FeatureInfo
        {
            ActivationScheme actScheme;
            
            size_t count;
            
            size_t altCount;
            
            Time expiry;
            
            static const size_t ficUnlimited = 0xffffffff;
            
            FeatureInfo() : actScheme(Disabled), count(0), altCount(0) {}
        };
        
        struct ProductStatus
        {
            String productId;
            
            String productDescription;
            
            SimpleArray<FeatureInfo> featureStatus;
        };
        
        class CartridgeManager
        {
        public:
            static CartridgeManager& getCartridgeManager();
            
            virtual void getActivatedProducts(SimpleArray<String>& outProductIds) = 0;
            
            virtual void getProductStatus(
                ProductStatus& outProductStatus,
                const String& inProductId = NullString) = 0;

            virtual String reserve(Feature inFeature, size_t inCount) = 0;
            
            virtual void commit(const String& inGuid) = 0;
            
            virtual void revert(const String& inGuid) = 0;
            
            virtual void installCartridge(const String& inCartridgeScript) = 0;

            static String createCartridge(
                const String& inUnencryptedScript);
            
            virtual void reinitializeDataBase() = 0;

        protected:
            virtual ~CartridgeManager() {}
        };

        class CartridgeConsumer
        {
        public:
            CartridgeConsumer();
            
            ~CartridgeConsumer();
            
            void reserve(Feature inFeature, size_t inCount);
            
            void commit();
            
            void revert();
        
        private:
            void* m_reserved;
        };
    }
}

#endif // _cel_license_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.