kInfo.h

Go to the documentation of this file.

#ifndef K_FIRESYNC_INFO_H
#define K_FIRESYNC_INFO_H

#include <kFireSync/kFsDef.h>

typedef k32s kViolation; 

#define kVIOLATION_NONE                 (0x00)     
#define kVIOLATION_BOUNDS               (0x01)     
#define kVIOLATION_GRANULARITY          (0x02)     
#define kVIOLATION_UNIQUENESS           (0x04)     
#define kVIOLATION_EXISTENCE            (0x08)     
#define kVIOLATION_GROUP                (0x10)     
#define kVIOLATION_INVALID              (0x20)     

typedef k32s kAdjust; 

#define kADJUST_NONE                (0x00)                          
#define kADJUST_RELATIVE_FLOOR      (0x01)                          
#define kADJUST_RELATIVE_CEIL       (0x02)                          
#define kADJUST_ABSOLUTE_FLOOR      (0x04)                          
#define kADJUST_ABSOLUTE_CEIL       (0x08)                          
#define kADJUST_AUTO                kADJUST_RELATIVE_FLOOR          

#include <kFireSync/Utils/kInfo.x.h>

typedef struct kInfo
{
    kBool isReadOnly;               
    kBool isGrouped;                
    kViolation violations;          
} kInfo;        

kFsFx(kStatus) kInfo_Init(kInfo* info); 
    
kFsFx(kStatus) kInfo_AppendErrors(const kInfo* info, kArrayList list, const kChar* source, const kChar* field);

typedef struct kInfo32u                         
{
    k32u absoluteMin;               
    k32u absoluteMax;               
    k32u relativeMin;               
    k32u relativeMax;               
    k32u granularity;               
    kBool isReadOnly;               
    kBool isGrouped;                
    kViolation violations;          
    k64f accurate;                  
} kInfo32u;

kFsFx(kStatus) kInfo32u_Init(kInfo32u* info, k32u min, k32u max, k32u granularity); 

kFsFx(kStatus) kInfo32u_Validate(kInfo32u* info, k32u value); 

kInlineFx(k32u) kInfo32u_Adjust(kInfo32u* info, k32u value, kAdjust style)
{
    return xkAdjustInfoValue(*info, value, style);
}

kFsFx(kStatus) kInfo32u_AppendErrors(const kInfo32u* info, kArrayList list, const kChar* source, const kChar* field, k32u value); 

typedef struct kInfo32s                         
{
    k32s absoluteMin;               
    k32s absoluteMax;               
    k32s relativeMin;               
    k32s relativeMax;               
    k32s granularity;               
    kBool isReadOnly;               
    kBool isGrouped;                
    kViolation violations;          
    k64f accurate;                  
} kInfo32s;

kFsFx(kStatus) kInfo32s_Init(kInfo32s* info, k32s min, k32s max, k32s granularity);            

kFsFx(kStatus) kInfo32s_Validate(kInfo32s* info, k32s value); 

kInlineFx(k32s) kInfo32s_Adjust(kInfo32s* info, k32s value, kAdjust style)
{
    return xkAdjustInfoValue(*info, value, style);
}

kFsFx(kStatus) kInfo32s_AppendErrors(const kInfo32s* info, kArrayList list, const kChar* source, const kChar* field, k32s value); 

typedef struct kInfo64u
{
    k64u absoluteMin;               
    k64u absoluteMax;               
    k64u relativeMin;               
    k64u relativeMax;               
    k64u granularity;               
    kBool isReadOnly;               
    kBool isGrouped;                
    kViolation violations;          
    k64f accurate;                  
} kInfo64u;
                      
kFsFx(kStatus) kInfo64u_Init(kInfo64u* info, k64u min, k64u max, k64u granularity); 

kFsFx(kStatus) kInfo64u_Validate(kInfo64u* info, k64u value); 

kInlineFx(k64u) kInfo64u_Adjust(kInfo64u* info, k64u value, kAdjust style)
{
    return xkAdjustInfoValue(*info, value, style);
}

kFsFx(kStatus) kInfo64u_AppendErrors(const kInfo64u* info, kArrayList list, const kChar* source, const kChar* field, k64u value); 

typedef struct kInfo64s
{
    k64s absoluteMin;               
    k64s absoluteMax;               
    k64s relativeMin;               
    k64s relativeMax;               
    k64s granularity;               
    kBool isReadOnly;               
    kBool isGrouped;                
    kViolation violations;          
    k64f accurate;                  
} kInfo64s;

kFsFx(kStatus) kInfo64s_Init(kInfo64s* info, k64s min, k64s max, k64s granularity); 

kFsFx(kStatus) kInfo64s_Validate(kInfo64s* info, k64s value); 

kInlineFx(k64s) kInfo64s_Adjust(kInfo64s* info, k64s value, kAdjust style)
{
    return xkAdjustInfoValue(*info, value, style);
}

kFsFx(kStatus) kInfo64s_AppendErrors(const kInfo64s* info, kArrayList list, const kChar* source, const kChar* field, k64s value); 
             
typedef struct kInfoSize                         
{
    kSize absoluteMin;              
    kSize absoluteMax;              
    kSize relativeMin;              
    kSize relativeMax;              
    kSize granularity;              
    kBool isReadOnly;               
    kBool isGrouped;                
    kViolation violations;          
    k64f accurate;                  
} kInfoSize;

kFsFx(kStatus) kInfoSize_Init(kInfoSize* info, kSize min, kSize max, kSize granularity); 

kFsFx(kStatus) kInfoSize_Validate(kInfoSize* info, kSize value); 

kInlineFx(kSize) kInfoSize_Adjust(kInfoSize* info, kSize value, kAdjust style)
{
    return xkAdjustInfoValue(*info, value, style);
}

kFsFx(kStatus) kInfoSize_AppendErrors(const kInfoSize* info, kArrayList list, const kChar* source, const kChar* field, kSize value); 

typedef struct kInfo64f
{
    k64f absoluteMin;               
    k64f absoluteMax;               
    k64f relativeMin;               
    k64f relativeMax;               
    k64f granularity;               
    k64f previous;                  
    k64f next;                      
    kBool isReadOnly;               
    kBool isGrouped;                
    kViolation violations;          
    k64f accurate;                  
} kInfo64f;

kFsFx(kStatus) kInfo64f_Init(kInfo64f* info, k64f min, k64f max); 

kFsFx(kStatus) kInfo64f_Validate(kInfo64f* info, k64f value); 

kFsFx(kStatus) kInfo64f_AppendErrors(const kInfo64f* info, kArrayList list, const kChar* source, const kChar* field, k64f value); 

typedef struct kInfoBool
{
    kBool absoluteMin;              
    kBool absoluteMax;              
    kBool relativeMin;              
    kBool relativeMax;              
    kBool isReadOnly;               
    kBool isGrouped;                
    kViolation violations;          
} kInfoBool;

kFsFx(kStatus) kInfoBool_Init(kInfoBool* info, kBool min, kBool max); 

kFsFx(kStatus) kInfoBool_Validate(kInfoBool* info, kBool value); 

kFsFx(kStatus) kInfoBool_AppendErrors(const kInfoBool* info, kArrayList list, const kChar* source, const kChar* field, kBool value); 

typedef struct kInfoBits                        
{
    k32u absoluteOptions;           
    k32u relativeOptions;           
    kBool isReadOnly;               
    kBool isGrouped;                
    kViolation violations;          
} kInfoBits;

kFsFx(kStatus) kInfoBits_Init(kInfoBits* info, k32u options); 

kFsFx(kStatus) kInfoBits_ValidateOne(kInfoBits* info, k32u option); 

kFsFx(kStatus) kInfoBits_ValidateAtLeastOne(kInfoBits* info, k32u options); 

kFsFx(kStatus) kInfoBits_AppendErrors(const kInfoBits* info, kArrayList list, const kChar* source, const kChar* field, k32u value); 

#include <kFireSync/Utils/kInfo.x.h>

#endif