FLBase.h

#pragma once
 
#include <stdint.h>
#include <type_traits>
#include <typeinfo>
 
#include "FLLibTags.h"
#include "DefinitionsBase.h"
 
namespace FLImaging
{
    namespace Base
    {
        class CFLBaseInternal;
        class CProcessingUnitBase;
        class CBroadcastMessage;
 
        class FL_EXPORT CFLBase
        {
            SupportToDuplicateAbstractObject(CFLBase);
 
        public:
            CFLBase();
 
            virtual ~CFLBase();
 
 
            void Lock() const;
 
            bool TryLock() const;
 
            void Unlock() const;
 
            virtual const CProcessingUnitBase* GetProcessingUnit() const;
 
            virtual const CResult SetProcessingUnit(const CProcessingUnitBase& pub);
 
            virtual const CResult SetProcessingUnit(const CProcessingUnitBase* pPub);
 
            virtual void ResetProcessingUnit();
 
            virtual bool IsValid() const;
 
            template <class T>
            bool IsValid(T& tValue) const;
 
            template <class T>
            bool IsValid(T* pTValue) const;
 
            template <class T>
            void GenerateMin(T& tValue) const;
 
            template <class T>
            void GenerateMin(T* pTValue) const;
 
            template <class T>
            void GenerateMinInt32(T& tValue) const;
 
            template <class T>
            void GenerateMinInt32(T* pTValue) const;
 
            template <class T>
            void GenerateMinInt31(T& tValue) const;
 
            template <class T>
            void GenerateMinInt31(T* pTValue) const;
 
            template <class T>
            void GenerateMax(T& tValue) const;
 
            template <class T>
            void GenerateMax(T* pTValue) const;
 
            template <class T>
            void GenerateMaxInt32(T& tValue) const;
 
            template <class T>
            void GenerateMaxInt32(T* pTValue) const;
 
            template <class T>
            void GenerateMaxInt31(T& tValue) const;
 
            template <class T>
            void GenerateMaxInt31(T* pTValue) const;
 
            template <class T>
            void GenerateInvalid(T& tValue) const;
 
            template <class T>
            void GenerateInvalid(T* pTValue) const;
 
            virtual void OnReceiveBroadcast(const CBroadcastMessage* pMessage);
 
            virtual int64_t GetClassType() const = 0;
 
            const char* GetClassNameWithNamespace() const;
 
            const char* GetClassNameWithoutNamespace() const;
 
            virtual uint32_t GetClassHash() const;
 
            virtual bool IsLicenseAvailable() const;
 
            const CResult ShareSynchronizationObject(const CFLBase* pSrcObject) const;
 
            bool IsSharedSynchronizationObject() const;
 
            virtual void Throw(const CResult& res, const wchar_t* pWcsExtraMessage = nullptr) const;
 
            virtual void Throw(const std::exception& res, const wchar_t* pWcsExtraMessage) const;
 
            // For CLR
            virtual size_t GetHandle() const;
            virtual void SetHandle(size_t stHandle);
 
            virtual size_t GetHandleType() const;
            virtual void SetHandleType(size_t stHandleType);
 
 
        private:
 
            volatile CFLBaseInternal* m_pInternal;
        };
    }
}