/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex-cpp/src/util/Vocabulary.cpp

Go to the documentation of this file.

#include "Vocabulary.hpp"
#include "Converter.hpp"
#include "Exception.hpp"
#include <boost/filesystem/fstream.hpp>

namespace aitools {
namespace invertedindex {

Vocabulary::Vocabulary()
{}

Vocabulary::Vocabulary(const bfs::path& path) throw (std::invalid_argument)
{
        load(path);
}

Vocabulary::Vocabulary(const Vocabulary& vocabulary)
:       hash_map_(vocabulary.hash_map_)
{}

Vocabulary::~Vocabulary()
{}

void
Vocabulary::accumulate(const std::string& word, uint64_t frequency)
{
        std::pair<iterator, bool>
        insert_result(hash_map_.insert(std::make_pair(word, frequency)));
        if (!insert_result.second)
        {
                insert_result.first->second += frequency;
        }
}

Vocabulary::const_iterator
Vocabulary::begin() const
{
    return hash_map_.begin();
}

Vocabulary::iterator
Vocabulary::begin()
{
    return hash_map_.begin();
}

void
Vocabulary::clear()
{
        hash_map_.clear();
}

bool
Vocabulary::contains(const std::string& word) const
{
    return hash_map_.find(word) != hash_map_.end();
}

Vocabulary::const_iterator
Vocabulary::end() const
{
    return hash_map_.end();
}

Vocabulary::iterator
Vocabulary::end()
{
    return hash_map_.end();
}

Vocabulary::const_iterator
Vocabulary::find(const std::string& word) const
{
        return hash_map_.find(word);
}

Vocabulary::iterator
Vocabulary::find(const std::string& word)
{
        return hash_map_.find(word);
}

uint64_t
Vocabulary::frequency(const std::string& word) const
{
        Vocabulary::const_iterator it(find(word));
        return it == end() ? 0 : it->second;
}

void
Vocabulary::get_words(std::vector<std::string>& words) const
{
        words.clear();
        words.reserve(hash_map_.size());
        for (hash_map_t::const_iterator it(begin()); it != end(); ++it)
        {
                words.push_back(it->first);
        }
        std::sort(words.begin(), words.end());
}

bool
Vocabulary::insert(const std::string& word, uint64_t frequency)
{
        return hash_map_.insert(std::make_pair(word, frequency)).second;
}

bool
Vocabulary::is_empty() const
{
    return hash_map_.empty();
}

void
Vocabulary::load(const bfs::path& file) throw (std::invalid_argument)
{
        bfs::ifstream ifs(file);
        if (!ifs)
        {
                Exception::throw_invalid_argument("Cannot open", file);
        }
        clear();
        std::string line;
        uint64_t frequency(0);
        std::string::size_type tabpos;
        while (std::getline(ifs, line))
        {
                tabpos = line.rfind(delim);
                if (tabpos != std::string::npos)
                {
                        frequency = Converter::str_to_ui64(line.substr(tabpos));
                        line = line.substr(0, tabpos);
                }
                accumulate(line, frequency);
        }
        ifs.close();
}

void
Vocabulary::save(const bfs::path& file) throw (std::invalid_argument)
{
        bfs::ofstream ofs(file);
        if (!ofs)
        {
                Exception::throw_invalid_argument("Cannot create", file);
        }
        tree_map_t sorted_map(begin(), end());
        tree_map_t::const_iterator end(sorted_map.end());
        for (tree_map_t::const_iterator it(sorted_map.begin()); it != end; ++it)
        {
                ofs << it->first << delim << it->second << newline;
        }
        ofs.close();
}

size_t
Vocabulary::size() const
{
    return hash_map_.size();
}

} // namespace invertedindex
} // namespace aitools

namespace std {

ostream&
operator<<(ostream& os, const aitools::invertedindex::Vocabulary& vocabulary)
{
        if (os)
        {
                os << "aitools::invertedindex::Vocabulary [ size = "
                   << vocabulary.size() << " ]";
        }
        return os;
}

} // namespace std

---