/////////////////////////////////////////////////////////////////////// // File: UnicityTable.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 "callback.h" #include "errcode.h" #include "genericvector.h" // 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 the structures and deallocate internal structures. ~UnicityTable(); // Reserve some memory. If there is size or more elements, the table will // then allocate size * 2 elements. void reserve(int size); // Return the size used. int size() const; // Return the object from an id. T get(int id) const; // Return the id of the T object. // This method NEEDS a compare_callback to be passed to // set_compare_callback. int get_id(T object) const; // Return true if T is in the table bool contains(T object) const; // Return true if the id is valid T contains_id(int id) const; // Add an element in the table int push_back(T object); // Add a callback to be called to delete the elements when the table took // their ownership. void set_clear_callback(Callback1<T>* cb); // Add a callback to be called to compare the elements when needed (contains, // get_id, ...) void set_compare_callback(ResultCallback2<bool, T const &, T const &>* cb); // Clear the table, calling the callback function if any. // All the owned Callbacks are also deleted. // If you don't want the Callbacks to be deleted, before calling clear, set // the callback to NULL. void clear(); // This method clear the current object, then, does a shallow copy of // its argument, and finally invalidate its argument. void move(UnicityTable<T>* from); // Read/Write the table to a file. This does _NOT_ read/write the callbacks. // The Callback given must be permanent since they will be called more than // once. The given callback will be deleted at the end. void write(FILE* f, Callback2<FILE*, T const &>* cb); // swap is used to switch the endianness. void read(FILE* f, Callback3<FILE*, T*, bool>* cb, bool swap); private: GenericVector<T> table_; // Mutable because Run method is not const mutable ResultCallback2<bool, T const &, T const &>* compare_cb_; }; template <typename T> class UnicityTableEqEq : public UnicityTable<T> { public: UnicityTableEqEq() { UnicityTable<T>::set_compare_callback( NewPermanentCallback(tesseract::cmp_eq<T>)); } }; template <typename T> UnicityTable<T>::UnicityTable() : compare_cb_(0) { } template <typename T> UnicityTable<T>::~UnicityTable() { clear(); } template <typename T> int UnicityTable<T>::size() const{ return table_.size(); } // Reserve some memory. If there is size or more elements, the table will // then allocate size * 2 elements. template <typename T> void UnicityTable<T>::reserve(int size) { table_.reserve(size); } // Return the object from an id. template <typename T> T UnicityTable<T>::get(int id) const { return table_.get(id); } // Return true if the id is valid template <typename T> T UnicityTable<T>::contains_id(int id) const { return table_.contains_index(id); } // Return the id of the T object. template <typename T> int UnicityTable<T>::get_id(T object) const { return table_.get_index(object); } // Return true if T is in the table template <typename T> bool UnicityTable<T>::contains(T object) const { return get_id(object) != -1; } // Add an element in the table template <typename T> int UnicityTable<T>::push_back(T object) { int idx = get_id(object); if (idx == -1) { idx = table_.push_back(object); } return idx; } // Add a callback to be called to delete the elements when the table took // their ownership. template <typename T> void UnicityTable<T>::set_clear_callback(Callback1<T>* cb) { table_.set_clear_callback(cb); } // Add a callback to be called to delete the elements when the table took // their ownership. template <typename T> void UnicityTable<T>::set_compare_callback(ResultCallback2<bool, T const &, T const &>* cb) { table_.set_compare_callback(cb); compare_cb_ = cb; } // Clear the table, calling the callback function if any. template <typename T> void UnicityTable<T>::clear() { table_.clear(); } template <typename T> void UnicityTable<T>::write(FILE* f, Callback2<FILE*, T const &>* cb) { table_.write(f, cb); } template <typename T> void UnicityTable<T>::read(FILE* f, Callback3<FILE*, T*, bool>* cb, bool swap) { table_.read(f, cb, swap); } // This method clear the current object, then, does a shallow copy of // its argument, and finally invalidate its argument. template <typename T> void UnicityTable<T>::move(UnicityTable<T>* from) { table_.move(&from->table_); } #endif // TESSERACT_CCUTIL_UNICITY_TABLE_H_