hashtable.c

labwindow 编程的toolbox例程。

            errChk (SetCtrlAttribute(gPanel, PANEL_SHRINK_LOAD, ATTR_DIMMED, !enable));
            errChk (UpdateDistributionGraph());
            break;
    }
Error:
    handleError;
    return 0;
}

/// HIFN    Callback function for the grow load numeric
int CVICALLBACK GrowLoadChange (int gPanel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int     error   = 0;
    double  load;

    switch (event)
    {
        case EVENT_COMMIT:
            errChk (GetCtrlVal(gPanel, PANEL_GROW_LOAD, &load));
            errChk (HashTableSetAttribute(gHashTable, ATTR_HT_GROW_LOAD, load));
            errChk (UpdateDistributionGraph());
            break;
    }
Error:
    return 0;
}

/// HIFN    Callback function for the shrink load numeric
int CVICALLBACK ShrinkLoadChange (int gPanel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int     error   = 0;
    double  load;

    switch (event)
    {
        case EVENT_COMMIT:
            errChk (GetCtrlVal(gPanel, PANEL_SHRINK_LOAD, &load));
            errChk (HashTableSetAttribute(gHashTable, ATTR_HT_SHRINK_LOAD, load));
            errChk (UpdateDistributionGraph());
            break;
    }
Error:
    handleError;
    return 0;
}

/// HIFN    Callback function for the "Value Type" ring. Dims the "Value Size" ring if the type is not String.
int CVICALLBACK ValTypeChange (int gPanel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int error = 0,
        type;
    
    switch (event)
    {
        case EVENT_COMMIT:
            errChk (GetCtrlVal(gPanel, control, &type));
            errChk (SetCtrlAttribute(gPanel, PANEL_VAL_SIZE, ATTR_DIMMED, (type != VAL_STRING)));
            break;
    }
Error:
    handleError;
    return 0;
}

/// HIFN    Panel callback. Quits the UI when the close button ([X]) is pressed.
int CVICALLBACK PanelCallback (int gPanel, int event, void *callbackData,
        int eventData1, int eventData2)
{
    switch (event)
    {
        case EVENT_CLOSE:
            QuitUserInterface(0);
            break;
    }
    return 0;
}

/// HIFN    Gets the items-per-bucket data from the table, then draws the intensity plot on the graph.
/// HRET    0 on success. A negative value indicates an error occurred.
static int UpdateDistributionGraph()
{
    static unsigned int     *hashDistribution       = NULL,
                            hashDistArrayCapacity   = 0;
    static int              plot                    = -1;
    int                     error                   = 0,
                            numBuckets,
                            i,
                            maxChainLen             = 1;
    
    // Make sure array is big enough to hold the data
    errChk (HashTableGetAttribute(gHashTable, ATTR_HT_NUM_BUCKETS, &numBuckets));
    if (numBuckets > hashDistArrayCapacity)
    {
        hashDistArrayCapacity = numBuckets;
        free(hashDistribution);
        nullChk (hashDistribution = malloc(2 * hashDistArrayCapacity * sizeof(unsigned int)));
    }
    
    errChk (HashTableGetAttribute(gHashTable, ATTR_HT_HASH_DISTRIBUTION, hashDistribution));
    
    // Duplicate the distribution data so that the plot is a 2-D color band, not just a line
    memcpy(hashDistribution + numBuckets, hashDistribution, numBuckets * sizeof(unsigned int));
    
    // Find the maximum value so that the plot can be scaled appropriately
    for (i = 0; i < numBuckets; ++i)
        if (hashDistribution[i] > maxChainLen)
            maxChainLen = hashDistribution[i];
    gColorMap[1].dataValue.valULong = maxChainLen;
    
    if (plot != -1)
        DeleteGraphPlot(gPanel, PANEL_HASH_GRAPH, plot, VAL_DELAYED_DRAW);
    
    errChk (plot = PlotIntensity(gPanel, 
                                PANEL_HASH_GRAPH, 
                                hashDistribution, 
                                numBuckets, 
                                2, 
                                VAL_UNSIGNED_INTEGER,
                                gColorMap,
                                VAL_BLACK,
                                2,
                                TRUE,
                                FALSE));
Error:
    handleError;
    return error;
}

/// HIFN    Sets the control dimming based on whether there is an active table or not
/// HRET    0 on success. A negative value indicates an error occurred.
static int UpdateCtrlDimming()
{
    int error       = 0,
        tableExists = (gHashTable == NULL) ? FALSE : TRUE;
    
    errChk (SetCtrlAttribute(gPanel, PANEL_KEY_TYPE,        ATTR_DIMMED, tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_VAL_TYPE,        ATTR_DIMMED, tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_VAL_SIZE,        ATTR_DIMMED, tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_CREATE,          ATTR_DIMMED, tableExists));
    
    errChk (SetCtrlAttribute(gPanel, PANEL_DISPOSE,         ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_SIZE,            ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_BUCKETS,         ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_LOAD,            ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_RESIZE_MSG,      ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_GROW_ENABLE,     ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_GROW_LOAD,       ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_SHRINK_ENABLE,   ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_SHRINK_LOAD,     ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_EDIT_MSG,        ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_KEY_NUMERIC,     ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_KEY_TEXT,        ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_VAL_NUMERIC,     ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_VAL_TEXT,        ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_INSERT,          ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_REMOVE,          ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_FIND,            ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_HASH_MSG,        ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_HASH_GRAPH,      ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_ENUMERATE,       ATTR_DIMMED, !tableExists));
    errChk (SetCtrlAttribute(gPanel, PANEL_ENUM_TABLE,      ATTR_DIMMED, !tableExists));
Error:
    return error;
}

/// HIFN    Sets control values to reflect the default settings of a hash table
/// HRET    0 on success. A negative value indicates an error occurred.
static int UpdateCtrlsAccordingToTableDefaults()
{
    int error   = 0;
    
    errChk (SetCtrlAttribute(gPanel, PANEL_SHRINK_LOAD, ATTR_DIMMED, TRUE));
    
    errChk (SetCtrlVal(gPanel, PANEL_SIZE,          0));
    errChk (SetCtrlVal(gPanel, PANEL_BUCKETS,       0));
    errChk (SetCtrlVal(gPanel, PANEL_LOAD,          0.0));
    
    errChk (SetCtrlVal(gPanel, PANEL_GROW_ENABLE,   1));
    errChk (SetCtrlVal(gPanel, PANEL_GROW_LOAD,     0.80));
    errChk (SetCtrlVal(gPanel, PANEL_SHRINK_ENABLE, 0));
    errChk (SetCtrlVal(gPanel, PANEL_SHRINK_LOAD,   0.20));
    
    gColorMap[0].dataValue.valULong = 0;
    gColorMap[0].color              = VAL_WHITE;
    gColorMap[1].dataValue.valULong = 1;
    gColorMap[1].color              = VAL_BLACK;
    errChk (UpdateDistributionGraph());
Error:
    handleError;
    return error;
}

/// HIFN    This function is called after creating a new table to set the various controls'
/// HIFN    data types to match those specified for the keys and value.
/// HRET    0 on success. A negative value indicates an error occurred.
static int UpdateCtrlsAccordingToKeyValueTypes()
{
    int error   = 0;
    
    errChk (SetCtrlAttribute(gPanel, PANEL_KEY_NUMERIC, ATTR_VISIBLE, (gKeyType != VAL_STRING)));
    errChk (SetCtrlAttribute(gPanel, PANEL_KEY_TEXT,    ATTR_VISIBLE, (gKeyType == VAL_STRING)));
    errChk (SetCtrlAttribute(gPanel, PANEL_VAL_NUMERIC, ATTR_VISIBLE, (gValType != VAL_STRING)));
    errChk (SetCtrlAttribute(gPanel, PANEL_VAL_TEXT,    ATTR_VISIBLE, (gValType == VAL_STRING)));
    
    errChk (DeleteTableRows(gPanel, PANEL_ENUM_TABLE, 1, -1));
    errChk (SetTableColumnAttribute(gPanel, PANEL_ENUM_TABLE, 1, ATTR_CELL_TYPE, (gKeyType == VAL_STRING) ? VAL_CELL_STRING : VAL_CELL_NUMERIC));
    errChk (SetTableColumnAttribute(gPanel, PANEL_ENUM_TABLE, 2, ATTR_CELL_TYPE, (gValType == VAL_STRING) ? VAL_CELL_STRING : VAL_CELL_NUMERIC));
    if (gKeyType != VAL_STRING)
    {
        errChk (SetTableColumnAttribute(gPanel, PANEL_ENUM_TABLE, 1, ATTR_DATA_TYPE, gKeyType));
    }
    if (gValType != VAL_STRING)
    {
        errChk (SetTableColumnAttribute(gPanel, PANEL_ENUM_TABLE, 2, ATTR_DATA_TYPE, gValType));
    }
    if (gKeyType != VAL_STRING)
    {
        errChk (SetCtrlAttribute(gPanel, PANEL_KEY_NUMERIC, ATTR_DATA_TYPE, gKeyType));
    }
    if (gValType != VAL_STRING)
    {
        errChk (SetCtrlAttribute(gPanel, PANEL_VAL_NUMERIC, ATTR_DATA_TYPE, gValType));
    }
    else
    {
        errChk (SetCtrlAttribute(gPanel, PANEL_VAL_TEXT, ATTR_MAX_ENTRY_LENGTH, gValSize - 1));
    }
Error:
    handleError;
    return error;
            
}

/// HIFN    Sets the global key/value type and size variables from the values of the UI controls
/// HRET    0 on success. A negative value indicates an error occurred.
static int SetKeyAndValueGlobals()
{
    int error   = 0;
    
    errChk (GetCtrlVal(gPanel, PANEL_KEY_TYPE, &gKeyType));
    errChk (GetCtrlVal(gPanel, PANEL_VAL_TYPE, &gValType));
    
    switch (gKeyType)
    {
        case VAL_CHAR:
            gKeySize = sizeof(char);
            break;
        case VAL_UNSIGNED_CHAR:
            gKeySize = sizeof(unsigned char);
            break;
        case VAL_INTEGER:
            gKeySize = sizeof(int);
            break;
        case VAL_UNSIGNED_INTEGER:
            gKeySize = sizeof(unsigned int);
            break;
        case VAL_64BIT_INTEGER:
            gKeySize = sizeof(__int64);
            break;
        case VAL_UNSIGNED_64BIT_INTEGER:
            gKeySize = sizeof(unsigned __int64);
            break;
        case VAL_FLOAT:
            gKeySize = sizeof(float);
            break;
        case VAL_DOUBLE:
            gKeySize = sizeof(double);
            break;
        case VAL_STRING:
        default:
            gKeySize = 0;
    }
    switch (gValType)
    {
        case VAL_STRING:
            GetCtrlVal(gPanel, PANEL_VAL_SIZE, &gValSize);
            ++gValSize;
            break;
        case VAL_CHAR:
            gValSize = sizeof(char);
            break;
        case VAL_UNSIGNED_CHAR:
            gValSize = sizeof(unsigned char);
            break;
        case VAL_INTEGER:
            gValSize = sizeof(int);
            break;
        case VAL_UNSIGNED_INTEGER:
            gValSize = sizeof(unsigned int);
            break;
        case VAL_64BIT_INTEGER:
            gValSize = sizeof(__int64);
            break;
        case VAL_UNSIGNED_64BIT_INTEGER:
            gValSize = sizeof(unsigned __int64);
            break;
        case VAL_FLOAT:
            gValSize = sizeof(float);
            break;
        case VAL_DOUBLE:
            gValSize = sizeof(double);
            break;
        default:
            gValSize = 0;
    }
Error:
    handleError;
    return error;
}

/// HIFN    Reads a key from the UI control. Key data returned by this function must be freed by the caller.
/// HIPAR   key/A reference to a pointer that will hold the key data. This pointer must be freed by the caller.
/// OUT     key
/// HRET    0 on success. A negative value indicates an error occurred.
static int GetKeyFromCtrl(void **key)
{
    int error   = 0,
        keyLen,
        ctrlId;
    
    if (gKeyType == VAL_STRING)
    {
        ctrlId = PANEL_KEY_TEXT;
        errChk (GetCtrlAttribute(gPanel, PANEL_KEY_TEXT, ATTR_STRING_TEXT_LENGTH, &keyLen));
    }
    else
    {
        ctrlId = PANEL_KEY_NUMERIC;
        keyLen = 8; // max
    }
    
    nullChk (*key = malloc(keyLen + 1));
    errChk (GetCtrlVal(gPanel, ctrlId, *key));
    
Error:
    handleError;
    return error;
}

/// HIFN    Reads a value from the UI control. Value data returned by this function must be freed by the caller.
/// HIPAR   val/A reference to a pointer that will hold the value data. This pointer must be freed by the caller.
/// OUT     val
/// HRET    0 on success. A negative value indicates an error occurred.
static int GetValueFromCtrl(void **val)
{
    int error   = 0,
        keyLen,
        ctrlId;
    
    if (gValType == VAL_STRING)
    {
        ctrlId = PANEL_VAL_TEXT;
        keyLen = gValSize;
    }
    else
    {
        ctrlId = PANEL_VAL_NUMERIC;
        keyLen = 8; // max
    }
    
    nullChk (*val = malloc(keyLen + 1));
    errChk (GetCtrlVal(gPanel, ctrlId, *val));
    
Error:
    handleError;
    return error;
}