qcore_foundation.mm

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2014 Samuel Gaist <samuel.gaist@edeltech.ch>
// Copyright (C) 2014 Petroules Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <QtCore/qstring.h>
#include <QtCore/qurl.h>
#include <QtCore/qdatetime.h>
#include <QtCore/quuid.h>
#include <QtCore/qbytearray.h>
#include <QtCore/qrect.h>
 
#if QT_CONFIG(timezone) && !defined(QT_NO_SYSTEMLOCALE)
#include <QtCore/qtimezone.h>
#include <QtCore/private/qtimezoneprivate_p.h>
#include <QtCore/private/qcore_mac_p.h>
#endif
 
#import <CoreFoundation/CoreFoundation.h>
#import <Foundation/Foundation.h>
 
#if defined(QT_PLATFORM_UIKIT)
#import <CoreGraphics/CoreGraphics.h>
#endif
 
QT_BEGIN_NAMESPACE
 
QByteArray QByteArray::fromCFData(CFDataRef data)
{
    if (!data)
        return QByteArray();
 
    return QByteArray(reinterpret_cast<const char *>(CFDataGetBytePtr(data)), CFDataGetLength(data));
}
 
QByteArray QByteArray::fromRawCFData(CFDataRef data)
{
    if (!data)
        return QByteArray();
 
    return QByteArray::fromRawData(reinterpret_cast<const char *>(CFDataGetBytePtr(data)), CFDataGetLength(data));
}
 
CFDataRef QByteArray::toCFData() const
{
    return CFDataCreate(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(data()), length());
}
 
CFDataRef QByteArray::toRawCFData() const
{
    return CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(data()),
                    length(), kCFAllocatorNull);
}
 
QByteArray QByteArray::fromNSData(const NSData *data)
{
    if (!data)
        return QByteArray();
    return QByteArray(reinterpret_cast<const char *>([data bytes]), [data length]);
}
 
QByteArray QByteArray::fromRawNSData(const NSData *data)
{
    if (!data)
        return QByteArray();
    return QByteArray::fromRawData(reinterpret_cast<const char *>([data bytes]), [data length]);
}
 
NSData *QByteArray::toNSData() const
{
    return [NSData dataWithBytes:constData() length:size()];
}
 
NSData *QByteArray::toRawNSData() const
{
    // const_cast is fine here because NSData is immutable thus will never modify bytes we're giving it
    return [NSData dataWithBytesNoCopy:const_cast<char *>(constData()) length:size() freeWhenDone:NO];
}
 
// ----------------------------------------------------------------------------
 
QString QString::fromCFString(CFStringRef string)
{
    if (!string)
        return QString();
    CFIndex length = CFStringGetLength(string);
 
    // Fast path: CFStringGetCharactersPtr does not copy but may
    // return null for any and no reason.
    const UniChar *chars = CFStringGetCharactersPtr(string);
    if (chars)
        return QString(reinterpret_cast<const QChar *>(chars), length);
 
    QString ret(length, Qt::Uninitialized);
    CFStringGetCharacters(string, CFRangeMake(0, length), reinterpret_cast<UniChar *>(ret.data()));
    return ret;
}
 
CFStringRef QString::toCFString() const
{
    return QStringView{*this}.toCFString();
}
 
CFStringRef QStringView::toCFString() const
{
    return CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar *>(data()), size());
}
 
QString QString::fromNSString(const NSString *string)
{
    if (!string)
        return QString();
   QString qstring;
   qstring.resize([string length]);
   [string getCharacters: reinterpret_cast<unichar*>(qstring.data()) range: NSMakeRange(0, [string length])];
   return qstring;
}
 
NSString *QString::toNSString() const
{
    return QStringView{*this}.toNSString();
}
 
NSString *QStringView::toNSString() const
{
    return [NSString stringWithCharacters:reinterpret_cast<const UniChar*>(data()) length:size()];
}
 
// ----------------------------------------------------------------------------
 
QUuid QUuid::fromCFUUID(CFUUIDRef uuid)
{
    if (!uuid)
        return QUuid();
    const CFUUIDBytes bytes = CFUUIDGetUUIDBytes(uuid);
    return QUuid::fromRfc4122(QByteArrayView(reinterpret_cast<const char *>(&bytes), sizeof(bytes)));
}
 
CFUUIDRef QUuid::toCFUUID() const
{
    const QByteArray bytes = toRfc4122();
    return CFUUIDCreateFromUUIDBytes(0, *reinterpret_cast<const CFUUIDBytes *>(bytes.constData()));
}
 
QUuid QUuid::fromNSUUID(const NSUUID *uuid)
{
    if (!uuid)
        return QUuid();
    uuid_t bytes;
    [uuid getUUIDBytes:bytes];
    return QUuid::fromRfc4122(QByteArrayView(reinterpret_cast<const char *>(bytes), sizeof(bytes)));
}
 
NSUUID *QUuid::toNSUUID() const
{
    const QByteArray bytes = toRfc4122();
    return [[[NSUUID alloc] initWithUUIDBytes:*reinterpret_cast<const uuid_t *>(bytes.constData())] autorelease];
}
 
// ----------------------------------------------------------------------------
 
 
QUrl QUrl::fromCFURL(CFURLRef url)
{
    if (!url)
        return QUrl();
    return QUrl(QString::fromCFString(CFURLGetString(url)));
}
 
CFURLRef QUrl::toCFURL() const
{
    CFURLRef url = 0;
    CFStringRef str = toString(FullyEncoded).toCFString();
    if (str) {
        url = CFURLCreateWithString(0, str, 0);
        CFRelease(str);
    }
    return url;
}
 
QUrl QUrl::fromNSURL(const NSURL *url)
{
    if (!url)
        return QUrl();
    return QUrl(QString::fromNSString([url absoluteString]));
}
 
NSURL *QUrl::toNSURL() const
{
    return [NSURL URLWithString:toString(FullyEncoded).toNSString()];
}
 
// ----------------------------------------------------------------------------
 
 
QDateTime QDateTime::fromCFDate(CFDateRef date)
{
    if (!date)
        return QDateTime();
    CFAbsoluteTime sSinceEpoch = kCFAbsoluteTimeIntervalSince1970 + CFDateGetAbsoluteTime(date);
    return QDateTime::fromMSecsSinceEpoch(qRound64(sSinceEpoch * 1000));
}
 
CFDateRef QDateTime::toCFDate() const
{
    return CFDateCreate(kCFAllocatorDefault, (static_cast<CFAbsoluteTime>(toMSecsSinceEpoch())
                                                    / 1000) - kCFAbsoluteTimeIntervalSince1970);
}
 
QDateTime QDateTime::fromNSDate(const NSDate *date)
{
    if (!date)
        return QDateTime();
    return QDateTime::fromMSecsSinceEpoch(qRound64([date timeIntervalSince1970] * 1000));
}
 
NSDate *QDateTime::toNSDate() const
{
    return [NSDate
            dateWithTimeIntervalSince1970:static_cast<NSTimeInterval>(toMSecsSinceEpoch()) / 1000];
}
 
// ----------------------------------------------------------------------------
 
#if QT_CONFIG(timezone) && !defined(QT_NO_SYSTEMLOCALE)
QTimeZone QTimeZone::fromCFTimeZone(CFTimeZoneRef timeZone)
{
    if (!timeZone)
        return QTimeZone();
    return QTimeZone(QString::fromCFString(CFTimeZoneGetName(timeZone)).toLatin1());
}
 
CFTimeZoneRef QTimeZone::toCFTimeZone() const
{
#ifndef QT_NO_DYNAMIC_CAST
    Q_ASSERT(dynamic_cast<const QMacTimeZonePrivate *>(d.d));
#endif
    const QMacTimeZonePrivate *p = static_cast<const QMacTimeZonePrivate *>(d.d);
    return reinterpret_cast<CFTimeZoneRef>([p->nsTimeZone() copy]);
}
 
QTimeZone QTimeZone::fromNSTimeZone(const NSTimeZone *timeZone)
{
    if (!timeZone)
        return QTimeZone();
    return QTimeZone(QString::fromNSString(timeZone.name).toLatin1());
}
 
NSTimeZone *QTimeZone::toNSTimeZone() const
{
    return [static_cast<NSTimeZone *>(toCFTimeZone()) autorelease];
}
#endif
 
// ----------------------------------------------------------------------------
 
CGRect QRect::toCGRect() const noexcept
{
    return CGRectMake(x(), y(), width(), height());
}
 
CGRect QRectF::toCGRect() const noexcept
{
    return CGRectMake(x(), y(), width(), height());
}
 
QRectF QRectF::fromCGRect(CGRect rect) noexcept
{
    return QRectF(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);
}
 
// ----------------------------------------------------------------------------
 
CGPoint QPoint::toCGPoint() const noexcept
{
    return CGPointMake(x(), y());
}
 
CGPoint QPointF::toCGPoint() const noexcept
{
    return CGPointMake(x(), y());
}
 
QPointF QPointF::fromCGPoint(CGPoint point) noexcept
{
    return QPointF(point.x, point.y);
}
 
// ----------------------------------------------------------------------------
 
CGSize QSize::toCGSize() const noexcept
{
    return CGSizeMake(width(), height());
}
 
CGSize QSizeF::toCGSize() const noexcept
{
    return CGSizeMake(width(), height());
}
 
QSizeF QSizeF::fromCGSize(CGSize size) noexcept
{
    return QSizeF(size.width, size.height);
}
 
QT_END_NAMESPACE