RootInputStream.cc

Go to the documentation of this file.

#include "RootIOSvc/RootInputStream.h"
#include "RootIOSvc/RootInputFile.h"

RootInputStream::RootInputStream(void* addr, /*int clid,*/
                                 const std::string& treepath,
                                 const std::string& branchname)
    : RootIOStream(addr)
    , m_files()
    , m_entry(-1)
    , m_clid(0)
    , m_entries(-1)
    , m_treepath(treepath)
    , m_branchname(branchname)
    , log("RootInputStream")
{
}


RootInputStream::~RootInputStream()
{
    // close file if needed
}

int RootInputStream::clID()
{
    return m_clid;
}

std::string RootInputStream::path()
{
    return m_treepath;
}

std::string RootInputStream::filename()
{
    RootInputFile* rif = m_files.current();
    if (rif) return rif->filename();
    return "";
}

int RootInputStream::fileNumber()
{
    return m_files.index();
}

bool RootInputStream::append(const std::string& filename, bool ignore_missing)
{
    if ("" == m_treepath || "" == m_branchname) {
        log << MSG::ERROR << "Can not guess tree path or branch name for "
            << filename << endreq;
        return false;
    }

    int clid = RootInputFile::TestForObject(filename,m_treepath,m_branchname, true);
    if (m_clid && clid && clid != m_clid) {
        log << MSG::ERROR << "Bad class ID from new file " << filename
            << " for " << m_treepath
            << "; got " << clid << " (had " << m_clid << ")"
            << endreq;
        return false;
    } else if (!clid) {         // not present
        if (ignore_missing) {
            // Even if this file is missing the path, we still need to add a
            // dummy entry to the input stream, since all input streams must
            // have the same number of files.
            m_files.push_back(new RootInputFile("","",""));
        } else {
            log << MSG::ERROR << "Missing class ID " << m_clid
                << " for " << m_treepath
                << " in file " << filename << endreq;
            return false;
        }
    } else {                    // we found it
        m_clid = clid;
        m_files.push_back(new RootInputFile(filename,m_treepath,m_branchname));
    }

    if (1 == m_files.size()) {
        m_files.next();
    }
    return true;
}

bool RootInputStream::append(const std::string& filename,
                             const std::string& treepath,
                             const std::string& branchname,
                             bool ignore_missing)
{
    if ("" != m_treepath) m_treepath = treepath;
    if ("" != m_branchname) m_branchname = branchname;

    return append(filename, ignore_missing);
}
    
// read expects corectly positioned and open file
bool RootInputStream::read()
{
    RootInputFile* rif = m_files.current();
    if (!rif) {
        log << MSG::ERROR << "No current file" << endreq;
        return false;
    }

    int nbytes = 0;
    bool ok = rif->read(m_addr,nbytes);
    log << MSG::DEBUG << "read() " << nbytes
        << " bytes at entry " << m_entry
        << " from file \"" << rif->filename() 
        << "\" to path \"" <<  this->path() 
        << endreq;
    return ok;
}

bool RootInputStream::setEntry(int entry, bool read)
{
    int steps = entry - m_entry;
    log << MSG::DEBUG << "setEntry(entry="<<entry<<",read="<<read<<") steps = " << steps
        << " (stream=\"" << this->path() << "\")"
        << endreq;
    if (steps < 0) return prev(-steps, read);
    if (steps > 0) return next(steps, read);
    return true;                // no change
}

bool RootInputStream::setFileEntry(int file, int entry, bool read)
{
    if (!m_files.jump(file)) {
        log << MSG::ERROR
            << "jump("<<file<<"): failed"
            << endreq;
        return false;
    }
    RootInputFile* rif = m_files.current();
    if (!rif) {
        log << MSG::ERROR << "Failed to get current file #" << file << endreq;
        return false;
    }
    if (!rif->setEntry(entry)) {
        log << MSG::ERROR << "Failed to set entry " << entry << " on file #" << file << endreq;
        return false;
    }

    int totEntries = m_files.entriesBefore(file);
    if (totEntries < 0) {
        log << MSG::ERROR << "Failed to get sane number of entries before file#" << file << endreq;
        return false;
    }
    m_entry = totEntries + entry;
    log << MSG::DEBUG << "setFileEntry(file="<<file<<",entry="<<entry<<",read="<<read<<") "
        << "totEntries=" << totEntries <<" m_entry=" << m_entry 
        << " (stream=\"" << this->path() 
        << "\", filename=\"" << rif->filename() << "\")"
        << endreq;
    
    if (read) return this->read();
    return true;

}

bool RootInputStream::next(int nsteps, bool read)
{
    RootInputFile* rif = m_files.current();

    if (!rif) {
        log << MSG::ERROR << "No files" << endreq;
        return false;
    }

    log << MSG::DEBUG << "next(nsteps="<<nsteps<<",read="<<read<<")" 
        << " (stream=\"" << this->path() << "\")"
        << endreq;

    while (nsteps) {

        // must leave current file?
        if (rif->entry() + nsteps >= rif->entries()) {

            // burn what steps current file provides
            int jump = rif->entries() - (rif->entry() + 1); 
            nsteps -= jump;
            m_entry += jump;
            if (!m_files.next()) {
                log << MSG::INFO
                    << "next(): no more files to go to next:"
                    << " jump = " << jump
                    << " nsteps = " << nsteps 
                    << " entry = " << m_entry
                    << " tentries=" << rif->entries() << endreq;
                return false;
            }
            rif = m_files.current();
            continue;
        }

        // Current file has enough entries left
        rif->next(nsteps);
        m_entry += nsteps;
        nsteps = 0;
        break;        
    }
    log << MSG::DEBUG << "next(): at stream entry " << m_entry
        << " (file: " << rif->filename() << " file entry: " << rif->entry() << ")"
        << " (stream=\"" << this->path() << "\")"
        << endreq;
    if (read) return this->read();
    return true;
}
    
bool RootInputStream::prev(int nsteps, bool read)
{
    RootInputFile* rif = m_files.current();
    if (!rif) {
        log << MSG::ERROR << "No files yet, cannot go prev" << endreq;
        return false;
    }

    log << MSG::DEBUG << "prev(nsteps="<<nsteps<<",read="<<read<<")"
        << " (stream=\"" << this->path() << "\")"
        << endreq;

    while (nsteps) {

        // must leave current file?
        if (rif->entry()-nsteps < 0) { 

            // Burn what steps this file provides
            int jump = 1 + rif->entry();
            nsteps -= jump;
            m_entry -= jump;
            if (!m_files.prev()) {
                log << MSG::ERROR << "Already at first file, cannot go prev"
                    << endreq;
                return false;
            }
            rif = m_files.current();
            rif->ending();      // position file entry at end
            continue;
        }

        // Can stay in current file
        rif->prev(nsteps);
        m_entry -= nsteps;
        nsteps = 0;
        break;
    }

    log << MSG::DEBUG << "prev(): at stream entry " << m_entry
        << " (file: " << rif->filename() << " file entry: " << rif->entry() << ")"
        << " (stream=\"" << this->path() << "\")"
        << endreq;

    if (read) return this->read();
    return true;
}


bool RootInputStream::first(bool read)
{
    bool okay = m_files.first();
    if (!okay) {
        log << MSG::ERROR << "first(): failed to go to first file in stream" 
            << endreq;
        return false;
    }

    RootInputFile* rif = m_files.current();
    if (!rif) {
        log << MSG::ERROR << "first(): failed to get current file in stream" 
            << endreq;
        return false;
    }

    okay = rif->beginning();
    if (!okay) return false;

    if (read) return this->read();
    return true;    
}


bool RootInputStream::last(bool read)
{
    bool okay = m_files.last();
    if (!okay) {
        log << MSG::ERROR << "last(): failed to go to last file in stream" 
            << endreq;
        return false;
    }

    RootInputFile* rif = m_files.current();
    if (!rif) {
        log << MSG::ERROR << "last(): failed to get current file in stream" 
            << endreq;
        return false;
    }

    okay = rif->ending();
    if (!okay) return false;

    if (read) return this->read();
    return true;
}

int RootInputStream::entries()
{
  if( m_entries>=0 ) {
    return m_entries;
  } else {
    m_entries=0;
    RootInputFileList::iterator it,itend = m_files.end();
    for( it=m_files.begin(); it!=itend; it++ ) {
      m_entries+= (*it)->entries();
    }
    return m_entries;
  }
}