dictionary.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 "array_t.h"
#if defined(HAVE_UNORDERED_MAP)
#include <unordered_map>
#elif defined(__GNUC__) && (__GNUC__+0 <= 4 || ( __GNUC__+0 == 4 && __GNUC_MINOR__+0 <= 5))
#include <backward/hash_map>
#else
#include <unordered_map>
#endif

namespace std {
    // specialization of hash<> on const char*
    template <> struct hash< const char* > {
        size_t operator()(const char* x) const;
    };
}

class FASTBIT_CXX_DLLSPEC ibis::dictionary {
public:
    ~dictionary() {clear();}
    dictionary();
    dictionary(const dictionary& dic);

    uint32_t size() const {return raw_.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*, uint32_t);
    uint32_t insert(const char*);
    uint32_t insertRaw(char*);
    uint32_t appendOrdered(const char*);

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

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

    int  fromASCII(std::istream &);
    void toASCII(std::ostream &) 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<char*> buffer_;
    typedef
#if defined(HAVE_UNORDERED_MAP)
        std::unordered_map
#elif defined(__GNUC__) && (__GNUC__+0 <= 4 || ( __GNUC__+0 == 4 && __GNUC_MINOR__+0 <= 5))
        __gnu_cxx::hash_map
#else
        std::unordered_map
#endif
        <const char*, uint32_t, std::hash<const char*>,
         std::equal_to<const char*> > MYMAP;
    MYMAP key_;

    int  readRaw(const char*, FILE *);
    int  readKeys0(const char*, FILE *);
    int  readKeys1(const char*, FILE *);
    int  readKeys2(const char*, FILE *);
    void mergeBuffers() const;
    int  writeKeys(FILE*, uint32_t, array_t<uint64_t>&,
                   array_t<uint32_t>&) const;
    int  writeBuffer(FILE*, uint32_t, array_t<uint64_t>&,
                     array_t<uint32_t>&) const;

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

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

inline const char* ibis::dictionary::operator[](uint32_t i) const {
    return (i < raw_.size() ? raw_[i] : static_cast<const char*>(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