dict-0.h

Go to the documentation of this file.

//File: $Id$
// Author: John Wu <John.Wu at ACM.org>
// Copyright (c) 2000-2016 the Regents of the University of California
#ifndef IBIS_DICTIONARY_H
#define IBIS_DICTIONARY_H
#include "util.h"
#include "array_t.h"

class FASTBIT_CXX_DLLSPEC ibis::dictionary {
public:
    ~dictionary() {clear();}
    dictionary(const dictionary& dic);
    dictionary() : raw_(1) {raw_[0] = 0;}

    uint32_t size() const {return key_.size();}

    const char* operator[](uint32_t i) const;
    uint32_t operator[](const char* str) const;
    const char* find(const char* str) const;
    void patternSearch(const char* pat, array_t<uint32_t>& matches) const;

    uint32_t insert(const char* str);
    uint32_t insertRaw(char* str);
    uint32_t appendOrdered(const char* str);

    void clear();
    void swap(dictionary&);

    int  read(const char* name);
    int  write(const char* name) const;

    void sort(array_t<uint32_t>&);
    int  merge(const dictionary&);
    int  morph(const dictionary&, array_t<uint32_t>&) const;

    bool equal_to(const ibis::dictionary&) const;

    void copy(const dictionary& rhs);

protected:

    array_t<const char*> raw_;
    array_t<const char*> key_;
    array_t<uint32_t> code_;
    array_t<char*> buffer_;

    int readRaw(const char*, FILE *);
    int readKeys(const char*, FILE *);

private:
    dictionary& operator=(const dictionary&);
}; // ibis::dictionary

inline void ibis::dictionary::swap(ibis::dictionary& rhs) {
    raw_.swap(rhs.raw_);
    key_.swap(rhs.key_);
    code_.swap(rhs.code_);
    buffer_.swap(rhs.buffer_);
} // ibis::dictionary::swap

inline const char* ibis::dictionary::operator[](uint32_t i) const {
    return (i < raw_.size() ? raw_[i] : raw_[0]);
} // int to string

inline const char* ibis::dictionary::find(const char* str) const {
    const char* ret = 0;
    const uint32_t ind = operator[](str);
    if (ind < raw_.size())
        ret = raw_[ind];
    return ret;
} // ibis::dictionary::find
#endif // IBIS_DICTIONARY_H