CompactFV.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

// Created on Mon Mar 30 11:38:16 PST 1998 by heydon
// Last modified on Fri Apr 22 17:20:01 EDT 2005 by ken@xorian.net        
//      modified on Sun Jul 28 12:12:48 EDT 2002 by lken@remote.xorian.net
//      modified on Fri May  8 16:06:36 PDT 1998 by heydon

#include <Basics.H>
#include <SRPC.H>
#include "FV.H"
#include "PrefixTbl.H"
#include "BitVector.H"
#include "PrefixTbl.H"
#include "CompactFV.H"

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

CompactFV::List::List(const FV::List &names) throw (PrefixTbl::Overflow)
: num((short) names.len), tbl(names.len + 5)
{
    if (names.len > 0) {
        this->idx = NEW_PTRFREE_ARRAY(short, names.len);
        this->types = NEW_PTRFREE_ARRAY(char, names.len);
        TextIntTbl putTbl(/*sizeHint=*/ names.len << 1, /*useGC=*/ true);
        for (int i = 0; i < names.len; i++) {
            const char *str = names.name[i].cchars();

            // strip off name type code (a single character)
            assert(str[0] != '\0' && str[1] == '/');
            this->types[i] = str[0];

            // add rest of path to table
            this->idx[i] = this->tbl.Put(str+2, /*INOUT*/ putTbl);
        }
    } else {
        this->idx = (short *)NULL;
        this->types = (char *)NULL;
    }
}

void CompactFV::List::ToFVList(/*INOUT*/ FV::ListApp &fvl) const throw ()
{
    const int BuffLen = 100;
    char buff[BuffLen + 2];

    char *str = buff;
    int strLen = BuffLen;
    str[1] = '/';
    for (int i = 0; i < this->num; i++) {
        while (! this->tbl.GetString(this->idx[i], str+2, strLen)) {
            // allocate a new, larger buffer and try again
            strLen <<= 1;
            str = NEW_PTRFREE_ARRAY(char, strLen + 2);
            str[1] = '/';
        }
        str[0] = this->types[i];
        int ix = fvl.Append(FV::T(str)); assert(ix == i);
    }
}

void CompactFV::List::Write(ostream &ofs) const throw (FS::Failure)
{
    this->tbl.Write(ofs);
    FS::Write(ofs, (char *)(&(this->num)), sizeof(this->num));
    if (this->num > 0) {
        FS::Write(ofs, this->types, this->num * sizeof(this->types[0]));
        FS::Write(ofs, (char *)(this->idx), this->num * sizeof(this->idx[0]));
    }
}

void CompactFV::List::Read(istream &ifs) throw (FS::EndOfFile, FS::Failure)
{
    this->tbl.Read(ifs);
    FS::Read(ifs, (char *)(&(this->num)), sizeof(this->num));
    if (this->num > 0) {
        this->types = NEW_PTRFREE_ARRAY(char, this->num);
        this->idx = NEW_PTRFREE_ARRAY(short, this->num);
        FS::Read(ifs, this->types, this->num * sizeof(this->types[0]));
        FS::Read(ifs, (char *)(this->idx), this->num * sizeof(this->idx[0]));
    } else {
        this->types = (char *) NULL;
        this->idx = (short *) NULL;
    }
}

void CompactFV::List::Send(SRPC &srpc) const throw (SRPC::failure)
{
    this->tbl.Send(srpc);
    srpc.send_bytes((const char *)(this->types), this->num);
    srpc.send_short_array(this->idx, this->num);
}

void CompactFV::List::Recv(SRPC &srpc) throw (SRPC::failure)
/* Note: The wire protocol of this method must agree with that of
   "FV::List::Send" in "FV.C". */
{
    this->tbl.Recv(srpc);
    int len;
    this->types = srpc.recv_bytes(/*OUT*/ len);
    this->idx = srpc.recv_short_array(/*OUT*/ len);
    this->num = (short) len;
}

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

void CompactFV::List::Print(ostream &os, int indent) const throw ()
{
    for (int i = 0; i < this->num; i++) {
        Indent(os, indent);
        FV2::T *nm = this->tbl.Get(this->idx[i]);
        os << this->types[i] << '/' << *nm << endl;
    }
}

---