symbol-table.H

Go to the documentation of this file.

// Copyright 2012, Google Inc.
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
// 
//   * Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above
//     copyright notice, this list of conditions and the following disclaimer
//     in the documentation and/or other materials provided with the
//     distribution.
//   * Neither the name of Google Inc. nor the names of its
//     contributors may be used to endorse or promote products derived from
//     this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// -----------------------------------------------------------------------------
//
//

#ifndef RERANKER_SYMBOL_TABLE_H_
#define RERANKER_SYMBOL_TABLE_H_

#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>

namespace reranker {

using std::cerr;
using std::endl;
using std::ostream;
using std::string;
using std::unordered_map;
using std::vector;

class Symbols {
 public:
  virtual ~Symbols() { }
  typedef unordered_map<string, int>::const_iterator const_iterator;

  virtual const_iterator begin() = 0;
  virtual const_iterator end() = 0;

  virtual size_t size() const = 0;

  virtual int GetIndex(const string &symbol) = 0;

  virtual const string &GetSymbol(int index) const = 0;

  virtual void SetIndex(const string &symbol, int index) = 0;

  virtual void Clear() = 0;

  virtual Symbols *Clone() const = 0;

  virtual ostream &Output(ostream &os) = 0;
 protected:
  static string null_symbol;  
};

class StaticSymbolTable : public Symbols {
 public:
  virtual const_iterator begin() {return symbols_.begin(); }
  virtual const_iterator end() { return symbols_.end(); }

  virtual size_t size() const { return symbols_.size(); }

  virtual int GetIndex(const string &symbol);

  virtual const string &GetSymbol(int index) const;

  virtual void SetIndex(const string &symbol, int index) {
    unordered_map<string, int>::const_iterator it = symbols_.find(symbol);
    if (it != symbols_.end()) {
      // TODO(dbikel): Emit warning message?
      int index = GetIndex(symbol);
      symbols_.erase(symbol);
      indices_to_symbols_.erase(index);
    }
    symbols_[symbol] = index;
    indices_to_symbols_[index] = symbol;
  }

  virtual void Clear() {
    symbols_.clear();
    indices_to_symbols_.clear();
  }

  virtual Symbols *Clone() const {
    return new StaticSymbolTable();
  }

  virtual ostream &Output(ostream &os) {
    for (unordered_map<string, int>::const_iterator it = symbols_.begin();
         it != symbols_.end();
         ++it) {
      os << it->first << "\t" << it->second << "\n";
    }
    os.flush();
    return os;
  }

 private:
  // static data members
  static unordered_map<string, int> symbols_;
  static unordered_map<int, string> indices_to_symbols_;
};

class LocalSymbolTable : public Symbols {
 public:
  virtual const_iterator begin() {return symbols_.begin(); }
  virtual const_iterator end() { return symbols_.end(); }

  virtual size_t size() const { return symbols_.size(); }

  virtual int GetIndex(const string &symbol);

  virtual const string &GetSymbol(int index) const;

  virtual void SetIndex(const string &symbol, int index) {
    unordered_map<string, int>::const_iterator it = symbols_.find(symbol);
    if (it != symbols_.end()) {
      cerr << "LocalSymbolTable::SetIndex: warning: symbol \"" << symbol
           << "\" already has an index " << it->second << "; new index: "
           << index << endl;
      int index = GetIndex(symbol);
      symbols_.erase(symbol);
      indices_to_symbols_.erase(index);
    }
    symbols_[symbol] = index;
    indices_to_symbols_[index] = symbol;
  }

  virtual void Clear() {
    symbols_.clear();
    indices_to_symbols_.clear();
  }

  virtual Symbols *Clone() const {
    return new LocalSymbolTable(*this);
  }

  virtual ostream &Output(ostream &os) {
    for (unordered_map<string, int>::const_iterator it = symbols_.begin();
         it != symbols_.end();
         ++it) {
      os << it->first << "\t" << it->second << "\n";
    }
    os.flush();
    return os;
  }

 private:
  // data members
  unordered_map<string, int> symbols_;
  unordered_map<int, string> indices_to_symbols_;
};

}  // namespace reranker

#endif