libCZI_StreamsLib.h

// SPDX-FileCopyrightText: 2023 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include "ImportExport.h"
#include <cstdint>
#include <string>
#include <map>
#include <memory>
#include <functional>
#include <stdexcept>
 
namespace libCZI
{
    class IStream;
 
    class LIBCZI_API StreamsFactory
    {
    public:
        struct LIBCZI_API Property
        {
        public:
            enum class Type
            {
                Invalid,    
                Int32,      
                Float,      
                Double,     
                Boolean,    
                String      
            };
 
            Property() : type(Type::Invalid)
            {
            }
 
            explicit Property(std::int32_t v)
            {
                this->SetInt32(v);
            }
 
            explicit Property(double v)
            {
                this->SetDouble(v);
            }
 
            explicit Property(float v)
            {
                this->SetFloat(v);
            }
 
            explicit Property(bool v)
            {
                this->SetBool(v);
            }
 
            explicit Property(const std::string& v)
            {
                this->SetString(v);
            }
 
            explicit Property(const char* string)
            {
                this->SetString(string);
            }
 
            void SetInt32(std::int32_t v)
            {
                this->type = Type::Int32;
                this->int32Value = v;
            }
 
            void SetDouble(double v)
            {
                this->type = Type::Double;
                this->doubleValue = v;
            }
 
            void SetFloat(float v)
            {
                this->type = Type::Float;
                this->floatValue = v;
            }
 
            void SetBool(bool v)
            {
                this->type = Type::Boolean;
                this->boolValue = v;
            }
 
            void SetString(const std::string& v)
            {
                this->type = Type::String;
                this->stringValue = v;
            }
 
            std::int32_t GetAsInt32OrThrow() const
            {
                this->ThrowIfTypeIsUnequalTo(Type::Int32);
                return this->int32Value;
            }
 
            double GetAsDoubleOrThrow() const
            {
                this->ThrowIfTypeIsUnequalTo(Type::Double);
                return this->doubleValue;
            }
 
            float GetAsFloatOrThrow() const
            {
                this->ThrowIfTypeIsUnequalTo(Type::Float);
                return this->floatValue;
            }
 
            bool GetAsBoolOrThrow() const
            {
                this->ThrowIfTypeIsUnequalTo(Type::Boolean);
                return this->boolValue;
            }
 
            std::string GetAsStringOrThrow() const
            {
                this->ThrowIfTypeIsUnequalTo(Type::String);
                return this->stringValue;
            }
 
            Type GetType() const
            {
                return this->type;
            }
 
        private:
            Type type;   
 
            union
            {
                std::int32_t int32Value;
                float floatValue;
                double doubleValue;
                bool boolValue;
            };
 
            std::string stringValue;
 
            void ThrowIfTypeIsUnequalTo(Type typeToCheck) const
            {
                if (this->type != typeToCheck)
                {
                    throw std::runtime_error("Unexpected type encountered.");
                }
            }
        };
 
        class StreamProperties
        {
        public:
            enum
            {
                kCurlHttp_Proxy = 100, 
 
                kCurlHttp_UserAgent = 101, 
 
                kCurlHttp_Timeout = 102, 
 
                kCurlHttp_ConnectTimeout = 103, 
 
                kCurlHttp_Xoauth2Bearer = 104, 
 
                kCurlHttp_Cookie = 105, 
 
                kCurlHttp_SslVerifyPeer = 106, 
 
                kCurlHttp_SslVerifyHost = 107, 
 
                kCurlHttp_FollowLocation = 108, 
 
                kCurlHttp_MaxRedirs = 109, 
 
                kCurlHttp_CaInfo = 110, 
 
                kCurlHttp_CaInfoBlob = 111, 
 
                kAzureBlob_AuthenticationMode = 200,
            };
        };
 
        struct LIBCZI_API CreateStreamInfo
        {
            std::string class_name; 
 
            std::map<int, Property> property_bag; 
        };
 
        struct StreamPropertyBagPropertyInfo
        {
            const char* property_name;              
            int property_id;                        
            Property::Type property_type;           
        };
 
        static const StreamPropertyBagPropertyInfo* GetStreamPropertyBagPropertyInfo(int* count);
 
        static void Initialize();
 
        static std::shared_ptr<libCZI::IStream> CreateStream(const CreateStreamInfo& stream_info, const std::string& file_identifier);
 
        static std::shared_ptr<libCZI::IStream> CreateStream(const CreateStreamInfo& stream_info, const std::wstring& file_identifier);
 
        struct LIBCZI_API StreamClassInfo
        {
            std::string class_name;                         
            std::string short_description;                  
 
            std::function<std::string()> get_build_info;
 
            std::function<Property(const char* property_name)> get_property;
        };
 
        static bool GetStreamInfoForClass(int index, StreamClassInfo& stream_info);
 
        static int GetStreamClassesCount();
 
        static std::shared_ptr<libCZI::IStream> CreateDefaultStreamForFile(const char* filename);
 
        static std::shared_ptr<libCZI::IStream> CreateDefaultStreamForFile(const wchar_t* filename);
 
        static const char* kStreamClassInfoProperty_CurlHttp_CaInfo;
 
        static const char* kStreamClassInfoProperty_CurlHttp_CaPath;
    };
}