CacheLog.C

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 Thu Apr 28 23:57:21 EDT 2005 by ken@xorian.net
//      modified on Thu Feb 10 12:15:58 PST 2000 by heydon

#include <Basics.H>
#include <FS.H>
#include <VestaLog.H>
#include <Recovery.H>
#include <FP.H>
#include <PKEpoch.H>
#include <FV.H>
#include <TextIO.H>

#include "CacheEntry.H"
#include "CacheLog.H"

using std::ostream;
using std::endl;

void CacheLog::Entry::Init(const Text& sourceFunc, FP::Tag *pk,
                           PKFile::Epoch pkEpoch,
                           CacheEntry::Index ci, VestaVal::T *value,
                           Model::T model, CacheEntry::Indices *kids,
                           FV::List *names, FP::List *fps)
  throw ()
{
    this->sourceFunc = sourceFunc;
    this->pk = pk;
    this->pkEpoch = pkEpoch;

    this->ci = ci;
    this->value = value;
    this->model = model;
    this->kids = kids;
    this->names = names;
    this->fps = fps;
    assert(names->len == fps->len);

    this->next = (Entry *)NULL;
}

void CacheLog::Entry::Log(VestaLog &log) const
  throw (VestaLog::Error)
{
    TextIO::Log(log, this->sourceFunc);
    this->pk->Log(log);
    log.write((char *)(&(this->pkEpoch)), sizeof(this->pkEpoch));

    log.write((char *)(&(this->ci)), sizeof(this->ci));
    this->value->Log(log);
    this->kids->Log(log);
    Model::Log(this->model, log);

    this->names->Log(log);
    this->fps->Log(log);
}

void CacheLog::Entry::Recover(RecoveryReader &rd)
  throw (VestaLog::Error, VestaLog::Eof)
{
    TextIO::Recover(rd, /*OUT*/ this->sourceFunc);
    pk = NEW_CONSTR(FP::Tag, (rd));
    rd.readAll((char *)(&(this->pkEpoch)), sizeof(this->pkEpoch));

    rd.readAll((char *)(&(this->ci)), sizeof(this->ci));
    this->value = NEW_CONSTR(VestaVal::T, (rd));
    this->kids = NEW_CONSTR(CacheEntry::Indices, (rd));
    Model::Recover(/*OUT*/ this->model, rd);

    this->names = NEW_CONSTR(FV::List, (rd));
    this->fps = NEW_CONSTR(FP::List, (rd));
}

void CacheLog::Entry::Write(ostream &ofs) const throw (FS::Failure)
{
    TextIO::Write(ofs, this->sourceFunc);
    this->pk->Write(ofs);
    FS::Write(ofs, (char *)(&(this->pkEpoch)), sizeof(this->pkEpoch));

    FS::Write(ofs, (char *)(&this->ci), sizeof(this->ci));
    this->value->Write(ofs);
    this->kids->Write(ofs);
    Model::Write(this->model, ofs);

    this->names->Write(ofs);
    this->fps->Write(ofs);
}

static void Indent(ostream &os, int indent) throw ()
{
    for (int i = 0; i < indent; i++) os << ' ';
}

void CacheLog::Entry::Debug(ostream &s, int indent) const throw ()
{
    Indent(s, indent);
    s << "pk = " << *pk << ", pkEpoch = " << pkEpoch
      << ", ci = " << ci << ", ..." << endl;
}

void CacheLog::Entry::DebugFull(ostream &s) const throw ()
{
    s << "  sourceFunc = " << this->sourceFunc << endl;
    s << "  pk         = " << *pk << endl;
    s << "  pkEpoch    = " << pkEpoch << endl;

    s << "  ci         = " << ci << endl;
    s << "  value      =" << endl; this->value->Print(s, /*indent=*/ 4);
    s << "  kids       = "; this->kids->Print(s, /*indent=*/ 4);
    s << "  model      = " << this->model << endl;

    s << "  names      =" << endl; this->names->Print(s, /*indent=*/ 4);
    s << "  fps        =" << endl; this->fps->Print(s, /*indent=*/ 4);
}

---