CFRef.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
namespace UE4CFRef_Private
{
    template <class CFRefType>
    struct TTollFreeBridgeType;
    
#ifdef __OBJC__
    template<> struct TTollFreeBridgeType<CFArrayRef> { using Type = NSArray*; };
    template<> struct TTollFreeBridgeType<CFAttributedStringRef> { using Type = NSAttributedString*; };
    template<> struct TTollFreeBridgeType<CFBooleanRef> { using Type = NSNumber*; };
    template<> struct TTollFreeBridgeType<CFCalendarRef> { using Type = NSCalendar*; };
    template<> struct TTollFreeBridgeType<CFCharacterSetRef> { using Type = NSCharacterSet*; };
    template<> struct TTollFreeBridgeType<CFDataRef> { using Type = NSData*; };
    template<> struct TTollFreeBridgeType<CFDateRef> { using Type = NSDate*; };
    template<> struct TTollFreeBridgeType<CFDictionaryRef> { using Type = NSDictionary*; };
    template<> struct TTollFreeBridgeType<CFErrorRef> { using Type = NSError*; };
    template<> struct TTollFreeBridgeType<CFLocaleRef> { using Type = NSLocale*; };
    template<> struct TTollFreeBridgeType<CFMutableArrayRef> { using Type = NSMutableArray*; };
    template<> struct TTollFreeBridgeType<CFMutableAttributedStringRef> { using Type = NSMutableAttributedString*; };
    template<> struct TTollFreeBridgeType<CFMutableCharacterSetRef> { using Type = NSMutableCharacterSet*; };
    template<> struct TTollFreeBridgeType<CFMutableDataRef> { using Type = NSMutableData*; };
    template<> struct TTollFreeBridgeType<CFMutableDictionaryRef> { using Type = NSMutableDictionary*; };
    template<> struct TTollFreeBridgeType<CFMutableSetRef> { using Type = NSMutableSet*; };
    template<> struct TTollFreeBridgeType<CFMutableStringRef> { using Type = NSMutableString*; };
    template<> struct TTollFreeBridgeType<CFNullRef> { using Type = NSNull*; };
    template<> struct TTollFreeBridgeType<CFNumberRef> { using Type = NSNumber*; };
    template<> struct TTollFreeBridgeType<CFReadStreamRef> { using Type = NSInputStream*; };
    template<> struct TTollFreeBridgeType<CFRunLoopTimerRef> { using Type = NSTimer*; };
    template<> struct TTollFreeBridgeType<CFSetRef> { using Type = NSSet*; };
    template<> struct TTollFreeBridgeType<CFStringRef> { using Type = NSString*; };
    template<> struct TTollFreeBridgeType<CFTimeZoneRef> { using Type = NSTimeZone*; };
    template<> struct TTollFreeBridgeType<CFURLRef> { using Type = NSURL*; };
    template<> struct TTollFreeBridgeType<CFWriteStreamRef> { using Type = NSOutputStream*; };
#endif // __OBJC__
}
 
template <class CFRefType>
class TCFRef
{
public:
 
    TCFRef()
    : Ref(nullptr)
    {
    }
 
    TCFRef(CFRefType InRef)
    : Ref(InRef)
    {
    }
 
    TCFRef(const TCFRef& Other)
    {
        CFRetain(Other.Ref);
        Ref = Other.Ref;
    }
 
    TCFRef(TCFRef&& Other)
    {
        Ref = Other.Ref;
        Other.Ref = nullptr;
    }
 
    ~TCFRef()
    {
        if (Ref)
        {
            CFRelease(Ref);
        }
    }
 
    TCFRef& operator=(const TCFRef& Other)
    {
        if (this != &Other)
        {
            if (Ref != nullptr)
            {
                CFRelease(Ref);
            }
            CFRetain(Other.Ref);
            Ref = Other.Ref;
        }
        return *this;
    }
 
    TCFRef& operator=(TCFRef&& Other)
    {
        if (this != &Other)
        {
            if (Ref)
            {
                CFRelease(Ref);
            }
            Ref = Other.Ref;
            Other.Ref = nullptr;
        }
        return *this;
    }
 
    CFRefType* GetForAssignment()
    {
        if (Ref != nullptr)
        {
            CFRelease(Ref);
            Ref = nullptr;
        }
        return &Ref;
    }
 
    explicit operator bool() const
    {
        return Ref != nullptr;
    }
 
    operator CFRefType() const
    {
        return Ref;
    }
 
    template<typename T = CFRefType,
             typename = typename UE4CFRef_Private::TTollFreeBridgeType<T>::Type>
    operator typename UE4CFRef_Private::TTollFreeBridgeType<T>::Type() const
    {
        return static_cast<typename UE4CFRef_Private::TTollFreeBridgeType<T>::Type>(Ref);
    }
 
private:
    /* The Core Foundation Type. Can be nullptr. */
    CFRefType Ref;
};