MasterTable.h

Go to the documentation of this file.

/******************************************************************************/
/******************************************************************************/

#if !defined(PROJECT_CPP_MASTERTABLE_H)
#define PROJECT_CPP_MASTERTABLE_H

#include "../dictionary/ion_master_table.h"
#include "Dictionary.h"
#include "BppTree.h"
#include "FlatFile.h"
#include "OpenAddressFileHash.h"
#include "OpenAddressHash.h"
#include "SkipList.h"
#include "LinearHash.h"

class MasterTable {
public:

ion_dictionary_handler_t handler;

MasterTable(
) {
    this->initializeMasterTable();
}

~MasterTable(
) {
    this->deleteMasterTable();
}

ion_err_t
initializeMasterTable(
) {
    return ion_init_master_table();
}

ion_err_t
closeMasterTable(
) {
    return ion_close_master_table();
}

ion_err_t
closeAllMasterTable(
) {
    return ion_close_all_master_table();
}

ion_err_t
deleteMasterTable(
) {
    return ion_delete_master_table();
}

template<typename K, typename V>
ion_err_t
addToMasterTable(
    Dictionary<K, V>        *dictionary,
    ion_dictionary_size_t dictionary_size
) {
    ion_dictionary_id_t id;

    ion_err_t err = ion_master_table_get_next_id(&id);

    if (err_ok != err) {
        return err;
    }

    dictionary->dict.instance->id = id;

    ion_dictionary_config_info_t config = {
        .id = dictionary->dict.instance->id, .use_type = 0, .type = dictionary->dict.instance->key_type, .key_size = dictionary->dict.instance->record.key_size, .value_size = dictionary->dict.instance->record.value_size, .dictionary_size = dictionary_size, .dictionary_type = dictionary->dict.instance->type
    };

    return ion_master_table_write(&config, ION_MASTER_TABLE_WRITE_FROM_END);
}

ion_dictionary_id_t
getNextID(
) {
    return ion_master_table_next_id;
}

ion_err_t
initializeHandler(
    ion_dictionary_type_t type
) {
    return ion_switch_handler(type, &handler);
}

ion_err_t
lookupMasterTable(
    ion_dictionary_id_t             id,
    ion_dictionary_config_info_t    *config
) {
    return ion_lookup_in_master_table(id, config);
}

ion_err_t
findByUse(
    ion_dictionary_config_info_t    *config,
    ion_dict_use_t                  use_type,
    char                            whence
) {
    return ion_find_by_use_master_table(config, use_type, whence);
}

ion_err_t
deleteFromMasterTable(
    ion_dictionary_id_t id
) {
    return ion_delete_from_master_table(id);
}

template<typename K, typename V>
ion_err_t
openDictionary(
    Dictionary<K, V>    *dictionary,
    ion_dictionary_id_t id
) {
    ion_err_t                       err;
    ion_dictionary_config_info_t    config;

    err = ion_lookup_in_master_table(id, &config);

    /* Lookup for id failed. */
    if (err_ok != err) {
        return err_uninitialized;
    }

    err = ion_switch_handler(config.dictionary_type, &handler);

    if (err_ok != err) {
        return err;
    }

    dictionary->dict.handler    = &handler;

    err                         = dictionary->open(config);

    return err;
}

template<typename K, typename V>
ion_err_t
closeDictionary(
    Dictionary<K, V> *dictionary
) {
    ion_err_t err = dictionary->close();

    return err;
}

template<typename K, typename V>
Dictionary<K, V> *
initializeDictionary(
    ion_key_type_t          key_type,
    K                       k,
    V                       v,
    ion_key_size_t          key_size,
    ion_value_size_t        value_size,
    ion_dictionary_size_t   dictionary_size,
    ion_dictionary_type_t   dictionary_type
) {
    UNUSED(k);
    UNUSED(v);

    Dictionary<K, V> *dictionary;

    ion_dictionary_id_t id = ion_master_table_next_id;

    switch (dictionary_type) {
        case dictionary_type_bpp_tree_t: {
            dictionary = new BppTree<K, V>(id, key_type, key_size, value_size);

            break;
        }

        case dictionary_type_flat_file_t: {
            dictionary = new FlatFile<K, V>(id, key_type, key_size, value_size, dictionary_size);

            break;
        }

        case dictionary_type_open_address_file_hash_t: {
            dictionary = new OpenAddressFileHash<K, V>(id, key_type, key_size, value_size, dictionary_size);

            break;
        }

        case dictionary_type_open_address_hash_t: {
            dictionary = new OpenAddressHash<K, V>(id, key_type, key_size, value_size, dictionary_size);

            break;
        }

        case dictionary_type_skip_list_t: {
            dictionary = new SkipList<K, V>(id, key_type, key_size, value_size, dictionary_size);

            break;
        }

        case dictionary_type_linear_hash_t: {
            dictionary = new LinearHash<K, V>(id, key_type, key_size, value_size, dictionary_size);

            break;
        }

        case dictionary_type_error_t: {
            dictionary              = new SkipList<K, V>(id, key_type, key_size, value_size, dictionary_size);
            dictionary->dict.status = ion_dictionary_status_error;
            break;
        }
    }

    if ((dictionary_type != dictionary_type_error_t) && (ion_dictionary_status_error != dictionary->dict.status)) {
        ion_err_t err = addToMasterTable(dictionary, dictionary_size);

        if (err_ok != err) {
            dictionary->dict.status = ion_dictionary_status_error;
        }
    }

    return dictionary;
}

template<typename K, typename V>
ion_err_t
deleteDictionary(
    Dictionary<K, V>        *dictionary
) {
    ion_dictionary_id_t id = dictionary->dict.instance->id;

    delete dictionary;

    return ion_delete_from_master_table(id);
}
};

#endif /* PROJECT_CPP_MASTERTABLE_H */