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

#include "CFCMutableDictionary.h"
#include "CFCString.h"
//----------------------------------------------------------------------
// CFCString constructor
//----------------------------------------------------------------------
CFCMutableDictionary::CFCMutableDictionary(CFMutableDictionaryRef s) :
    CFCReleaser<CFMutableDictionaryRef> (s)
{
}

//----------------------------------------------------------------------
// CFCMutableDictionary copy constructor
//----------------------------------------------------------------------
CFCMutableDictionary::CFCMutableDictionary(const CFCMutableDictionary& rhs) :
    CFCReleaser<CFMutableDictionaryRef> (rhs)
{
}

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

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


CFIndex
CFCMutableDictionary::GetCount() const
{
    CFMutableDictionaryRef dict = get();
    if (dict)
        return ::CFDictionaryGetCount (dict);
    return 0;
}

CFIndex
CFCMutableDictionary::GetCountOfKey(const void *key) const

{
    CFMutableDictionaryRef dict = get();
    if (dict)
        return ::CFDictionaryGetCountOfKey (dict, key);
    return 0;
}

CFIndex
CFCMutableDictionary::GetCountOfValue(const void *value) const

{
    CFMutableDictionaryRef dict = get();
    if (dict)
        return ::CFDictionaryGetCountOfValue (dict, value);
    return 0;
}

void
CFCMutableDictionary::GetKeysAndValues(const void **keys, const void **values) const
{
    CFMutableDictionaryRef dict = get();
    if (dict)
        ::CFDictionaryGetKeysAndValues (dict, keys, values);
}


const void *
CFCMutableDictionary::GetValue(const void *key) const

{
    CFMutableDictionaryRef dict = get();
    if (dict)
        return ::CFDictionaryGetValue (dict, key);
    return NULL;
}

Boolean
CFCMutableDictionary::GetValueIfPresent(const void *key, const void **value_handle) const
{
    CFMutableDictionaryRef dict = get();
    if (dict)
        return ::CFDictionaryGetValueIfPresent (dict, key, value_handle);
    return false;
}


CFMutableDictionaryRef
CFCMutableDictionary::Dictionary(bool can_create)
{
    CFMutableDictionaryRef dict = get();
    if (can_create && dict == NULL)
    {
        dict = ::CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
        reset ( dict );
    }
    return dict;
}

bool
CFCMutableDictionary::AddValue(CFStringRef key, const void *value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // Let the dictionary own the CFNumber
        ::CFDictionaryAddValue (dict, key, value);
        return true;
    }
    return false;
}

bool
CFCMutableDictionary::SetValue(CFStringRef key, const void *value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // Let the dictionary own the CFNumber
        ::CFDictionarySetValue (dict, key, value);
        return true;
    }
    return false;
}

bool
CFCMutableDictionary::AddValueSInt8(CFStringRef key, int8_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt8Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::SetValueSInt8(CFStringRef key, int8_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt8Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::AddValueSInt16(CFStringRef key, int16_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt16Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::SetValueSInt16(CFStringRef key, int16_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt16Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::AddValueSInt32(CFStringRef key, int32_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt32Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::SetValueSInt32(CFStringRef key, int32_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt32Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::AddValueSInt64(CFStringRef key, int64_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt64Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::SetValueSInt64(CFStringRef key, int64_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt64Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::AddValueUInt8(CFStringRef key, uint8_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // Have to promote to the next size type so things don't appear negative of the MSBit is set...
        int16_t sval = value;
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt16Type, &sval));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::SetValueUInt8(CFStringRef key, uint8_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // Have to promote to the next size type so things don't appear negative of the MSBit is set...
        int16_t sval = value;
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt16Type, &sval));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}


bool
CFCMutableDictionary::AddValueUInt16(CFStringRef key, uint16_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // Have to promote to the next size type so things don't appear negative of the MSBit is set...
        int32_t sval = value;
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt32Type, &sval));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::SetValueUInt16(CFStringRef key, uint16_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // Have to promote to the next size type so things don't appear negative of the MSBit is set...
        int32_t sval = value;
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt32Type, &sval));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::AddValueUInt32(CFStringRef key, uint32_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // Have to promote to the next size type so things don't appear negative of the MSBit is set...
        int64_t sval = value;
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt64Type, &sval));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::SetValueUInt32(CFStringRef key, uint32_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // Have to promote to the next size type so things don't appear negative of the MSBit is set...
        int64_t sval = value;
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt64Type, &sval));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}


bool
CFCMutableDictionary::AddValueUInt64(CFStringRef key, uint64_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // The number may appear negative if the MSBit is set in "value". Due to a limitation of
        // CFNumber, there isn't a way to have it show up otherwise as of this writing.
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt64Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}


bool
CFCMutableDictionary::SetValueUInt64(CFStringRef key, uint64_t value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // The number may appear negative if the MSBit is set in "value". Due to a limitation of
        // CFNumber, there isn't a way to have it show up otherwise as of this writing.
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberSInt64Type, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::AddValueDouble(CFStringRef key, double value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // The number may appear negative if the MSBit is set in "value". Due to a limitation of
        // CFNumber, there isn't a way to have it show up otherwise as of this writing.
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberDoubleType, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::SetValueDouble(CFStringRef key, double value, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        // The number may appear negative if the MSBit is set in "value". Due to a limitation of
        // CFNumber, there isn't a way to have it show up otherwise as of this writing.
        CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberDoubleType, &value));
        if (cf_number.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_number.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::AddValueCString(CFStringRef key, const char *cstr, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCString cf_str(cstr, kCFStringEncodingUTF8);
        if (cf_str.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionaryAddValue (dict, key, cf_str.get());
            return true;
        }
    }
    return false;
}

bool
CFCMutableDictionary::SetValueCString(CFStringRef key, const char *cstr, bool can_create)
{
    CFMutableDictionaryRef dict = Dictionary(can_create);
    if (dict != NULL)
    {
        CFCString cf_str(cstr, kCFStringEncodingUTF8);
        if (cf_str.get())
        {
            // Let the dictionary own the CFNumber
            ::CFDictionarySetValue (dict, key, cf_str.get());
            return true;
        }
    }
    return false;
}


void
CFCMutableDictionary::RemoveAllValues()
{
    CFMutableDictionaryRef dict = get();
    if (dict)
        ::CFDictionaryRemoveAllValues(dict);
}

void
CFCMutableDictionary::RemoveValue(const void *value)
{
    CFMutableDictionaryRef dict = get();
    if (dict)
        ::CFDictionaryRemoveValue(dict, value);
}
void
CFCMutableDictionary::ReplaceValue(const void *key, const void *value)
{
    CFMutableDictionaryRef dict = get();
    if (dict)
        ::CFDictionaryReplaceValue (dict, key, value);
}