kUtils.h

Go to the documentation of this file.

#include <kApi/kApiDef.h>         //--inclusion order controlled by kApiDef

#ifndef K_API_UTILS_H
#define K_API_UTILS_H

#include <kApi/Utils/kUtils.x.h>

kInlineFx(kStatus) kDestroyRef(kObject* object)
{
    kStatus result = kObject_Destroy(*object);     

    *object = kNULL; 

    return result; 
}

kInlineFx(kStatus) kDisposeRef(kObject* object)
{
    kStatus result = kObject_Dispose(*object);     

    *object = kNULL; 

    return result; 
}

kInlineFx(kStatus) kShareRef(kObject* object, kObject source)
{
    if (!kIsNull(source))
    {
        kCheck(kObject_Share(source)); 

        if (!kIsNull(object))
        {
            *object = source; 
        }
    }
    else
    {
        *object = kNULL; 
    }

    return kOK; 
}

kInlineFx(kStatus) kReplaceRef(kObject* object, kObject source)
{
    kCheck(kDisposeRef(object)); 

    kCheck(kShareRef(object, source)); 

    return kOK; 
}

kFx(kStatus) kZeroItems(kType type, void* items, kSize count); 

kInlineFx(kStatus) kCopyItems(kType type, void* dest, const void* src, kSize count)
{
    return xkCopyItems(type, dest, src, count);
}

#if defined (K_CPP)
kInlineFx(kStatus) kCopyItems(kType type, kAlloc destAlloc, void* dest, kAlloc srcAlloc, const void* src, kSize count, kObject context)
{
    return xkCopyItemsEx(type, destAlloc, dest, srcAlloc, src, count, context);
}
#endif

kInlineFx(kStatus) kCloneItems(kType type, void* dest, const void* src, kSize count, kAlloc allocator)
{
    return xkCloneItems(type, dest, src, count, allocator);
}

#if defined (K_CPP)
kInlineFx(kStatus) kCloneItems(kType type, kAlloc destAlloc, void* dest, kAlloc srcAlloc, const void* src, kSize count, kObject context, kAlloc destObjectAlloc, kAlloc destValueAlloc)
{
    return xkCloneItemsEx(type, destAlloc, dest, srcAlloc, src, count, context, destObjectAlloc, destValueAlloc);
}
#endif

kFx(kStatus) kDisposeItems(kType type, void* items, kSize count); 

kFx(kStatus) kShareItems(kType type, void* items, kSize count); 

kFx(kSize) kMeasureItems(kType type, const void* items, kSize count); 

kFx(kBool) kHasSharedItems(kType type, const void* items, kSize count); 

kFx(kBool) kEnumerateAllocTraits(kType type, const void* items, kSize count);

kFx(kStatus) kLoad5(kObject* object, const kChar* fileName, kAlloc allocator); 

kFx(kStatus) kSave5(kObject object, const kChar* fileName); 

kFx(kStatus) kSaveCompressed5(kObject object, const kChar* fileName, kCompressionType algorithm, k32s level); 

kFx(kStatus) kLoad6(kObject* object, const kChar* fileName, kAlloc allocator); 

kFx(kStatus) kSave6(kObject object, const kChar* fileName); 

kFx(kStatus) kSaveCompressed6(kObject object, const kChar* fileName, kCompressionType algorithm, k32s level); 

kFx(kStatus) kMemAlloc(kSize size, void* mem);

kFx(kStatus) kMemAllocZero(kSize size, void* mem);

kFx(kStatus) kMemFree(void* mem); 

kFx(kStatus) kMemFreeRef(void* mem); 

kFx(kStatus) kMemSet(void* dest, kByte fill, kSize size);

kInlineFx(kStatus) kMemZero(void* dest, kSize size)
{
    return kMemSet(dest, 0, size);
}

kFx(kStatus) kMemCopy(void* dest, const void* src, kSize size);

kFx(kStatus) kMemMove(void* dest, const void* src, kSize size);

kFx(kStatus) kMemReverseCopy(void* dest, const void* src, kSize size);

kFx(kStatus) kMemReverse(void* buffer, kSize size);

kInlineFx(kBool) kMemEquals(const void* a, const void* b, kSize size)
{
    return (memcmp(a, b, size) == 0); 
}

kFx(kStatus) kStrCopy(kChar* dest, kSize capacity, const kChar* src); 

kFx(kStatus) kStrCat(kChar* dest, kSize capacity, const kChar* src); 

kFx(kStatus) kStrToLower(kChar* str); 

kFx(kBool) kStrEquals(const kChar* a, const kChar* b); 

kFx(kBool) kStrnEquals(const kChar* a, const kChar* b, kSize maxCount);

kFx(k32s) kStrCompare(const kChar* a, const kChar* b); 

kFx(k32s) kStrCompareN(const kChar* a, const kChar* b, kSize maxCount);

kFx(k32s) kStrCompareLower(const kChar* a, const kChar* b); 

kFx(kSize) kStrLength(const kChar* str); 

kFx(const kChar*) kStrFindFirst(const kChar* str, const kChar* subStr); 

kFx(const kChar*) kStrFindLast(const kChar* str, const kChar* subStr); 

#if defined (K_CPP)
kFx(kBool) kStrSplit(const kChar* input, const kChar* delimiterList, const kChar** tokenStart, const kChar** tokenEnd, kChar* context, kBool discardEmpty = kFALSE);
#endif

kFx(kStatus) kStrPrintf(kChar* dest, kSize capacity, const kChar* format, ...); 

kFx(kStatus) kStrPrintvf(kChar* dest, kSize capacity, const kChar* format, kVarArgList argList); 

kFx(kStatus) kLogvf(const kChar* format, kVarArgList argList);

#if defined(K_CPP)
kInlineFx(kStatus) kLogvf(kLogOption options, const kChar* source, const kChar* format, kVarArgList argList)
{
    return xkLogvf(options, source, format, argList);
}
#endif

kFx(kStatus) kLogf(const kChar* format, ...);

#if defined(K_CPP)
kInlineFx(kStatus) kLogf(kLogOption options, const kChar* source, const kChar* format, ...)
{
    kVarArgList argList;
    kStatus status;

    kVarArgList_Start(argList, format);
    {
        status = kLogvf(options, source, format, argList); 
    }
    kVarArgList_End(argList);

    return status;
}
#endif

kFx(kStatus) kLog(const kChar* message);

#if defined(K_CPP)
kInlineFx(kStatus) kLog(kLogOption options, const kChar* source, const kChar* message)
{
    return kLogf(options, source, "%s", message);
}
#endif

kFx(kStatus) kLogBackTrace(kSize skip);

#if defined(K_CPP)
kInlineFx(kStatus) kLogBackTrace(kLogOption options, const kChar* source, kSize skip)
{
    return xkLogBackTrace(options, source, skip);
}
#endif

kFx(k32u) kRandom32u();

kFx(k64u) kRandom64u();

kFx(kSize) kRandomSize();

kFx(kStatus) kRandomBytes(void* data, kSize length);

kFx(kStatus) kBase64Encode(const void* buffer, kSize size, kString base64String);

#if defined(K_CPP)

kFx(kStatus) kInvokeProcess(const kChar* path,
    kArrayList arguments=kNULL,
    kCallbackFx outStdOut=kNULL,
    kCallbackFx outStdErr=kNULL,
    kPointer receiver=kNULL,
    kBool isShell=kFALSE,
    k64u timeout=kINFINITE);
#endif

#endif