unicity_table.h

Go to the documentation of this file.

 
// File:        unicity_table.h
// Description: a class to uniquify objects, manipulating them using integers
//              ids.
// Author:      Samuel Charron
//
// (C) Copyright 2006, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
 
#ifndef TESSERACT_CCUTIL_UNICITY_TABLE_H_
#define TESSERACT_CCUTIL_UNICITY_TABLE_H_
 
#include "errcode.h"
 
#include "genericvector.h"
 
#include <functional> // for std::function
 
namespace tesseract {
 
// A class to uniquify objects, manipulating them using integers ids.
// T requirements:
//   operator= to add an element
//   default-constructible: allocating the internal table will call the default
//     constructor.
template <typename T>
class UnicityTable {
public:
  ~UnicityTable() {
    clear();
  }
 
  void reserve(int size) {
    table_.reserve(size);
  }
 
  int size() const  {
    return table_.size();
  }
 
  const T &at(int id) const {
    return table_.at(id);
  }
 
  // Return the pointer to an object with the given id.
  T &at(int id) {
    return table_.at(id);
  }
 
  T &operator[](size_t id) {
    return table_[id];
  }
  const T &operator[](size_t id) const {
    return table_[id];
  }
 
  int get_index(T object) const {
    return table_.get_index(object);
  }
 
  int push_back(T object)  {
    auto idx = get_index(object);
    if (idx == -1) {
      idx = table_.push_back(object);
    }
    return idx;
  }
 
  void set_clear_callback(const std::function<void(T)> &cb) {
    table_.set_clear_callback(cb);
  }
 
  void clear()  {
    table_.clear();
  }
 
  void move(UnicityTable<T> *from) {
    table_.move(&from->table_);
  }
 
  bool write(FILE *f, const std::function<bool(FILE *, const T &)> &cb) const {
    return table_.write(f, cb);
  }
  bool read(tesseract::TFile *f, const std::function<bool(tesseract::TFile *, T *)> &cb) {
    return table_.read(f, cb);
  }
 
private:
  GenericVector<T> table_;
};
 
} // namespace tesseract
 
#endif // TESSERACT_CCUTIL_UNICITY_TABLE_H_