CFCString.cpp   [plain text]

//===-- CFCString.cpp -------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "CFCString.h"
#include <string>
#include <glob.h>

//----------------------------------------------------------------------
// CFCString constructor
//----------------------------------------------------------------------
CFCString::CFCString(CFStringRef s) :
    CFCReleaser<CFStringRef> (s)
{
}

//----------------------------------------------------------------------
// CFCString copy constructor
//----------------------------------------------------------------------
CFCString::CFCString(const CFCString& rhs) :
    CFCReleaser<CFStringRef> (rhs)
{

}

//----------------------------------------------------------------------
// CFCString copy constructor
//----------------------------------------------------------------------
CFCString&
CFCString::operator=(const CFCString& rhs)
{
    if (this != &rhs)
        *this = rhs;
    return *this;
}

CFCString::CFCString (const char *cstr, CFStringEncoding cstr_encoding) :
    CFCReleaser<CFStringRef> ()
{
    if (cstr && cstr[0])
    {
        reset(::CFStringCreateWithCString(kCFAllocatorDefault, cstr, cstr_encoding));
    }
}

//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
CFCString::~CFCString()
{
}

const char *
CFCString::GetFileSystemRepresentation(std::string& s)
{
    return CFCString::FileSystemRepresentation(get(), s);
}

CFStringRef
CFCString::SetFileSystemRepresentation (const char *path)
{
    CFStringRef new_value = NULL;
    if (path && path[0])
        new_value = ::CFStringCreateWithFileSystemRepresentation (kCFAllocatorDefault, path);
    reset(new_value);
    return get();
}


CFStringRef
CFCString::SetFileSystemRepresentationFromCFType (CFTypeRef cf_type)
{
    CFStringRef new_value = NULL;
    if (cf_type != NULL)
    {
        CFTypeID cf_type_id = ::CFGetTypeID(cf_type);

        if (cf_type_id == ::CFStringGetTypeID())
        {
            // Retain since we are using the existing object
            new_value = (CFStringRef)::CFRetain(cf_type);
        }
        else if (cf_type_id == ::CFURLGetTypeID())
        {
            new_value = ::CFURLCopyFileSystemPath((CFURLRef)cf_type, kCFURLPOSIXPathStyle);
        }
    }
    reset(new_value);
    return get();
}

CFStringRef
CFCString::SetFileSystemRepresentationAndExpandTilde (const char *path)
{
    std::string expanded_path;
    if (CFCString::ExpandTildeInPath(path, expanded_path))
        SetFileSystemRepresentation(expanded_path.c_str());
    else
        reset();
    return get();
}

const char *
CFCString::UTF8(std::string& str)
{
    return CFCString::UTF8(get(), str);
}

// Static function that puts a copy of the UTF8 contents of CF_STR into STR
// and returns the C string pointer that is contained in STR when successful, else
// NULL is returned. This allows the std::string parameter to own the extracted string,
// and also allows that string to be returned as a C string pointer that can be used.

const char *
CFCString::UTF8 (CFStringRef cf_str, std::string& str)
{
    if (cf_str)
    {
        const CFStringEncoding encoding = kCFStringEncodingUTF8;
        CFIndex max_utf8_str_len = CFStringGetLength (cf_str);
        max_utf8_str_len = CFStringGetMaximumSizeForEncoding (max_utf8_str_len, encoding);
        if (max_utf8_str_len > 0)
        {
            str.resize(max_utf8_str_len);
            if (!str.empty())
            {
                if (CFStringGetCString (cf_str, &str[0], str.size(), encoding))
                {
                    str.resize(strlen(str.c_str()));
                    return str.c_str();
                }
            }
        }
    }
    return NULL;
}

const char*
CFCString::ExpandTildeInPath(const char* path, std::string &expanded_path)
{
    glob_t globbuf;
    if (::glob (path, GLOB_TILDE, NULL, &globbuf) == 0)
    {
        expanded_path = globbuf.gl_pathv[0];
        ::globfree (&globbuf);
    }
    else
        expanded_path.clear();

    return expanded_path.c_str();
}

// Static function that puts a copy of the file system representation of CF_STR
// into STR and returns the C string pointer that is contained in STR when
// successful, else NULL is returned. This allows the std::string parameter
// to own the extracted string, and also allows that string to be returned as
// a C string pointer that can be used.

const char *
CFCString::FileSystemRepresentation (CFStringRef cf_str, std::string& str)
{
    if (cf_str)
    {
        CFIndex max_length = ::CFStringGetMaximumSizeOfFileSystemRepresentation (cf_str);
        if (max_length > 0)
        {
            str.resize(max_length);
            if (!str.empty())
            {
                if (::CFStringGetFileSystemRepresentation (cf_str, &str[0], str.size()))
                {
                    str.erase(::strlen(str.c_str()));
                    return str.c_str();
                }
            }
        }
    }
    str.erase();
    return NULL;
}


CFIndex
CFCString::GetLength() const
{
    CFStringRef str = get();
    if (str)
        return CFStringGetLength (str);
    return 0;
}