core.hpp

/*
 * OCILIB - C Driver for Oracle (C Wrapper for Oracle OCI)
 *
 * Website: http://www.ocilib.net
 *
 * Copyright (c) 2007-2026 Vincent ROGIER <vince.rogier@ocilib.net>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <list>
#include <map>
 
#include "ocilibcpp/config.hpp"
 
 // ReSharper disable CppClangTidyCppcoreguidelinesMacroUsage
 // ReSharper disable CppClangTidyHicppSpecialMemberFunctions
 // ReSharper disable CppClangTidyCppcoreguidelinesSpecialMemberFunctions
 // ReSharper disable CppClangTidyModernizeUseNodiscard
 // ReSharper disable CppClangTidyHicppUseEqualsDefault
 // ReSharper disable CppClangTidyModernizeUseEqualsDefault
 
namespace ocilib
{
    namespace core
    {
#ifdef OCILIBPP_HAS_ENABLEIF
 
        template<bool B, class T = void>
        using EnableIf = std::enable_if<B, T>;
 
        template<class T, class U>
        using IsSame = std::is_same<T, U>;
 
#else
 
        template<bool B, class T = void>
        struct EnableIf {};
 
        template<class T>
        struct EnableIf<true, T> { typedef T type; };
 
        template<bool B>
        struct BoolConstant { static const bool value = B; };
 
        template<class T, class U>
        struct IsSame : BoolConstant<false> {};
 
        template<class T>
        struct IsSame<T, T> : BoolConstant<true> {};
 
#endif
 
#define ARG_NOT_USED(a) (a) = (a)
 
        template<class T>
        static T Check(T result);
 
        ostring MakeString(const otext* result, int size = -1);
 
        Raw MakeRaw(AnyPointer result, unsigned int size);
 
        template<class T>
        struct SupportedNumeric
        {
            typedef EnableIf<IsSame<T, short>::value ||
                IsSame<T, unsigned short>::value ||
                IsSame<T, int>::value ||
                IsSame<T, unsigned int>::value ||
                IsSame<T, big_int>::value ||
                IsSame<T, big_uint>::value ||
                IsSame<T, float>::value ||
                IsSame<T, double>::value ||
                IsSame<T, Number>::value> Type;
        };
 
        template<class T>
        struct SupportedVectorNumeric
        {
            typedef EnableIf<IsSame<T, unsigned char>::value ||
                IsSame<T, char>::value ||
                IsSame<T, float>::value ||
                IsSame<T, double>::value> Type;
        };
 
        template<class T>
        class Enum
        {
        public:
 
            typedef T Type;
 
            Enum();
            Enum(T value);
 
            T GetValue();
 
            operator T ();
            operator unsigned int() const;
 
            bool operator == (const Enum& other) const;
            bool operator != (const Enum& other) const;
 
            bool operator == (const T& other) const;
            bool operator != (const T& other) const;
 
        private:
 
            T _value;
        };
 
        template<class T>
        class Flags
        {
        public:
 
            typedef T Type;
 
            Flags();
            Flags(T flag);
            Flags(const Flags& other);
 
            Flags& operator = (const Flags& other) noexcept;
 
            Flags operator~ () const;
 
            Flags operator | (T other) const;
            Flags operator & (T other) const;
            Flags operator ^ (T other) const;
 
            Flags operator | (const Flags& other) const;
            Flags operator & (const Flags& other) const;
            Flags operator ^ (const Flags& other) const;
 
            Flags& operator |= (T other);
            Flags& operator &= (T other);
            Flags& operator ^= (T other);
 
            Flags& operator |= (const Flags& other);
            Flags& operator &= (const Flags& other);
            Flags& operator ^= (const Flags& other);
 
            bool operator == (T other) const;
            bool operator == (const Flags& other) const;
 
            unsigned int GetValues() const;
 
            bool IsSet(T other) const;
 
        private:
 
            Flags(unsigned int flags);
 
            unsigned int _flags;
        };
 
        template< typename T>
        class ManagedBuffer
        {
        public:
            ManagedBuffer();
            ManagedBuffer(size_t size);
 
            ~ManagedBuffer() noexcept;
 
            operator T* ();
 
        private:
 
            T* _buffer;
            size_t _size;
        };
 
        enum SynchronizationMode
        {
            Unsafe,
            Safe
        };
 
        class SynchronizationGuard
        {
        public:
 
            SynchronizationGuard(SynchronizationMode mode);
            virtual ~SynchronizationGuard() noexcept;
 
            void Acquire() const;
            void Release() const;
 
            void SetMode(SynchronizationMode mode);
 
        private:
 
            MutexHandle _mutex;
        };
 
        class Synchronizable
        {
        public:
 
            Synchronizable();
            virtual  ~Synchronizable() noexcept;
 
            void SetGuard(SynchronizationGuard* guard);
 
            void Acquire() const;
            void Release() const;
 
        private:
 
            SynchronizationGuard* _guard;
        };
 
        template<class K, class V>
        class ConcurrentMap : public Synchronizable
        {
        public:
 
            ConcurrentMap();
            virtual ~ConcurrentMap() noexcept;
 
            void Remove(K key);
            V Get(K key);
            void Set(K key, V value);
            void Clear();
            size_t GetSize();
 
        private:
 
            std::map<K, V> _map;
 
        };
 
        template<class T>
        class ConcurrentList : public Synchronizable
        {
        public:
 
            ConcurrentList();
            virtual ~ConcurrentList() noexcept;
 
            void Add(T value);
            void Remove(T value);
            void Clear();
            size_t GetSize();
            bool Exists(const T& value);
 
            template<class P>
            bool FindIf(P predicate, T& value);
 
            template<class A>
            void ForEach(A action);
 
        private:
 
            std::list<T> _list;
        };
 
        /* Forward declaration */
        class HandleStore;
 
        class Handle
        {
        public:
 
            virtual ~Handle() noexcept {}
            virtual ConcurrentList<Handle*>& GetChildren() = 0;
            virtual void DetachFromHolders() = 0;
            virtual void DetachFromParent() = 0;
            virtual HandleStore* GetStore() const = 0;
            virtual Handle* GetParent() const = 0;
        };
 
        class HandleStore
        {
        public:
 
            HandleStore(SynchronizationGuard* guard);
 
            template <class T>
            T Get(AnyPointer ptr);
 
            template <class T>
            void Set(AnyPointer ptr, T handle);
 
            static HandleStore& GetStoreForHandle(Handle*);
 
        private:
 
            ConcurrentMap<AnyPointer, Handle*>  _handles;
        };
 
        template<class T>
        class HandleHolder
        {
        public:
 
            bool IsNull() const;
 
            operator bool();
            operator bool() const;
 
            operator T();
            operator T() const;
 
        protected:
 
            class SmartHandle;
 
            HandleHolder(const HandleHolder& other);
            HandleHolder();
            ~HandleHolder() noexcept;
 
            HandleHolder& operator= (const HandleHolder& other) noexcept;
 
            typedef void(*SmartHandleFreeNotifyFunc)(SmartHandle* smartHandle);
 
            Handle* GetHandle() const;
 
            void AcquireAllocated(T handle, Handle* parent);
            void AcquireTransient(T handle, Handle* parent);
            void AcquireAllocatedWithNotification(T handle, Handle* parent, SmartHandleFreeNotifyFunc freeNotifyFunc);
            void Acquire(HandleHolder& other);
 
            void Acquire(T handle, bool allocated, SmartHandleFreeNotifyFunc freeNotifyFunc, Handle* parent);
            void Release();
 
            class SmartHandle : public Handle
            {
            public:
 
                SmartHandle(HandleHolder* holder, T handle, bool allocated, SmartHandleFreeNotifyFunc freeNotifyFunc, Handle* parent);
                virtual ~SmartHandle() noexcept;
 
                void Acquire(HandleHolder* holder);
                void Release(HandleHolder* holder);
 
                void Destroy();
 
                T GetHandle() const;
 
                AnyPointer GetExtraInfos() const;
                void  SetExtraInfos(AnyPointer extraInfo);
 
                ConcurrentList<Handle*>& GetChildren() override;
                void DetachFromHolders() override;
                void DetachFromParent() override;
                HandleStore* GetStore() const override;
                Handle* GetParent() const override;
 
            private:
 
                static void DeleteHandle(Handle* handle);
                static void ResetHolder(HandleHolder* holder);
                static SynchronizationMode GetSynchronizationMode();
 
                ConcurrentList<HandleHolder*> _holders;
                ConcurrentList<Handle*>  _children;
 
                SynchronizationGuard _guard;
 
                T _handle;
                bool _allocated;
                SmartHandleFreeNotifyFunc _freeNotifyFunc;
                Handle* _parent;
                AnyPointer _extraInfo;
                HandleStore* _store;
            };
 
            SmartHandle* _smartHandle;
        };
 
        class Streamable
        {
        public:
 
            virtual ~Streamable() noexcept {}
 
            operator ostring() const
            {
                return ToString();
            }
 
            virtual ostring ToString() const = 0;
 
            template<class T>
            friend T& operator << (T& lhs, const Streamable& rhs)
            {
                lhs << static_cast<ostring>(rhs);
                return lhs;
            }
        };
    }
}