IntIntTblLR.H

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

// Last modified on Wed Aug  4 18:08:12 EDT 2004 by ken@xorian.net
//      modified on Thu Sep 25 18:06:01 PDT 1997 by heydon

/* IntIntTblLR.H -- Like a generic "IntIntTbl", defines a table that maps
   non-negative shorts to short, but these tables also have methods to
   write/read them from logs and streams. */

#ifndef _INT_INT_TBL_LR_H
#define _INT_INT_TBL_LR_H

#include <Basics.H>
#include <FS.H>
#include <VestaLog.H>
#include <Recovery.H>

class IntIntTblLR {
  public:
    // constructors
    IntIntTblLR(int sizeHint = 0) throw ();
    IntIntTblLR(const IntIntTblLR *tbl) throw ();
    IntIntTblLR(RecoveryReader &rd) throw (VestaLog::Error, VestaLog::Eof)
        { Recover(rd); }
    IntIntTblLR(std::istream &ifs) throw (FS::EndOfFile, FS::Failure)
        { Read(ifs); }
    ~IntIntTblLR() throw ()
        { this->elt = (short *)NULL; }

    // table operations
    bool Get(short k, /*OUT*/ short& v) const throw ();
    /* If the key "k" exists in the table, then set "v" to the
       associated value and return "true". Otherwise, leave "v"
       unchanged and return "false". */

    bool Put(short k, short v) throw ();
    /* Set the value associated with key "k" in the table to "v". Return
       "true" iff there was already a value associated with "k" in the
       table before the method was invoked. */

    bool Delete(short k, /*OUT*/ short& v) throw ();
    /* If the key "k" exists in the table, set "v" to its associated
       value, remove the association from the table, and return "true".
       Otherwise, leave "v" unchanged and return "false". */

    int Size() const throw () { return this->numEntries; }
    /* Return the number of <k,v> associations in the table. */

    int ArraySize() const throw () { return this->eltLen; }
    /* Return the size of the underlying array. */

    // log/recover
    void Log(VestaLog& log) const throw (VestaLog::Error);
    /* Append a representation of this table to "log". Requires "log" to
       be in the "logging" state. */
    void Recover(RecoveryReader &rd)
      throw (VestaLog::Error, VestaLog::Eof);
    /* Recover the representation of this table from "rd". */

    // write/read
    void Write(std::ostream &ofs) const throw (FS::Failure);
    /* Write this table to "ofs". */
    void Read(std::istream &ifs) throw (FS::EndOfFile, FS::Failure);
    /* Read this table from "ifs". */

    // print
    void Print(std::ostream &os, int indent) const throw ();

  private:
    int numEntries;  // number of elements in "elt"
    int eltLen;      // size of "elt" array
    short *elt;      // array of elements; may be NULL if "eltLen == 0"

    friend class IntIntTblIter;
};

class IntIntTblIter {
  public:
    IntIntTblIter(const IntIntTblLR* tbl) throw ()
        : tbl(tbl) { Reset(); }
    /* Return a new iterator on the "Default" table "tbl". While the
       iterator is in use, the client is only allowed to modify the table
       by invoking the "Put" and "Delete" methods with "resize = false".
       Once the iteration is complete, it is recommended that the "Resize"
       method be called to adjust the size of the table if necessary. */

    void Reset() throw () { this->k = 0; this->done = false; }
    /* Resets the iterator so that it will iterate over all the elements
       in its associated table. This can be used to iterate over the
       elements of the same table multiple times. */

    bool Next(/*OUT*/ short& k, /*OUT*/ short& v) throw ();
    /* If there is an association in this iterator's table that has not
       already been enumerated, select one, set "k" to its key, set "v" to
       its value, and return "true". Otherwise, leave "k" and "v"
       unchanged, and return "false". */
  private:
    const IntIntTblLR* tbl;  // corresponding table
    short k;                 // next key to consider
    bool done;               // true if Next() has returned "false"

    // hide copy constructor
    IntIntTblIter(const IntIntTblIter&);
};

#endif // _INT_INT_TBL_LR_H

---