+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

fdm_cdr_file.cc

Go to the documentation of this file.

// -*-c++-*- 
//---------------------------< /-/ CLARAty /-/ >------------------------------
/** 
 * @file  fdm_cdr_file.cc
 *
 * FDM CDR file utilities.
 *
 * <br>@b Designer(s):  Anne Wright
 * <br>@b Author(s):    Anne Wright
 * <br>@b Date:         April 12, 2003
 *
 * <b>Software License:</b><br>
 * <code>  http://claraty.jpl.nasa.gov/license/open_src/  or
 *         file: license/open_src.txt  </code>
 *
 * &copy; 2006, Jet Propulsion Laboratory, California Institute of Technology<br>
 * &copy; 2006, NASA Ames Research Center
 *
 * $Revision: 1.2 $
 */ 
//-----------------------------------------------------------------------------

#include "claraty/fdm_cdr_file.h"
#include <map>

using namespace std;

FDM_CDR_File::FDM_CDR_File(FDM::Direction dir) : 
    FDM_CDR(dir), _conn(), _io_file(NULL), _file_ok(false), 
    _file_eof(false), _got_block(false), _topform_typename("")
{
}

FDM_CDR_File::FDM_CDR_File(const string &filename,
                           FDM::Direction dir, bool append) : 
  FDM_CDR(dir), _conn(), _io_file(NULL), _file_ok(false),
  _file_eof(false), _got_block(false), _topform_typename("")
{
  open(filename, append);
}

FDM_CDR_File::FDM_CDR_File(auto_ptr<ACE_FILE_IO> fio, FDM::Direction dir): 
  FDM_CDR(dir), _conn(), _io_file(NULL), _file_ok(false), 
  _file_eof(false), _got_block(false), _topform_typename("")
{
  if(fio.get()!=NULL) {
    _io_file = fio.release();
    _file_ok=true;
  }
}
FDM_CDR_File::~FDM_CDR_File() {
  close();
}

bool 
FDM_CDR_File::open(const string &filename, bool append) 
{
  if(_io_file!=NULL) {
    // destruct old file, should close it
    delete _io_file;
    _io_file = NULL;
    _file_ok = false;
  }
  // Create a new _io_file
  _io_file = new ACE_FILE_IO();
  _file_ok = false;

  if(is_read()) {
    // Try to open the file
    if(_conn.connect (*_io_file, 
                      ACE_FILE_Addr (filename.c_str()),
                      0, // No timeout.
                      ACE_Addr::sap_any, // Ignored.
                      0, // Don't try to reuse the addr.
                      O_RDONLY,
                      ACE_DEFAULT_FILE_PERMS) < 0) {
      // Open failed, return false
      _file_ok=false;
      return(false);
    }
    // Opened the file ok, reset flags
    _file_ok=true;
    _file_eof=false;
    _got_block=false;
    return(true);
  }
  else {                        // Writing
    // Try to open the file for write, TODO: append option
    int appflag = (append) ? (O_APPEND) : (O_TRUNC);
    if(_conn.connect (*_io_file, 
                      ACE_FILE_Addr (filename.c_str()),
                      0, // No timeout.
                      ACE_Addr::sap_any, // Ignored.
                      0, // Don't try to reuse the addr.
                      O_RDWR|O_CREAT|appflag,
                      ACE_DEFAULT_FILE_PERMS) < 0) {
      // Open failed, return false
      _file_ok=false;
      return(false);
    }
    // Opened the file ok
    _file_ok=true;
    _file_eof=false;
    return(true);

  }
}

void 
FDM_CDR_File::close() 
{
  if(_io_file != NULL) {
    if(is_write() && _file_ok && _ostr != NULL) {
      // Make sure everything's been written
      flush();
    }
    delete _io_file;
    _io_file = NULL;
  }
  _file_ok = false;
}

bool 
FDM_CDR_File::_read_block(auto_ptr<ACE_Message_Block> &msg)
{
  if(!_file_ok || _file_eof || _io_file == NULL) {
    return(false);
  }

  // Deal with the Header
  ACE_Message_Block header(ACE_DEFAULT_CDR_BUFSIZE);
  // The header has 4 character ID and an unsigned long that is length
  ACE_CDR::mb_align(&header);

  // Read the header from the file
  size_t nread;
  nread = _io_file->recv_n(header.wr_ptr(), 8);
  if(nread == 0) {
    // EOF
    _file_eof = true;
    return(false);
  }
  else if(nread != 8) {
    cerr << "fdm_cdr_       file: ..ader file read failed" << endl;
    _file_ok = false;
    return(false);
  }
  // Advance the write pointer
  header.wr_ptr(8);

  // Parse the header
  ACE_InputCDR h_in(&header);
  char idstr[5];
  ACE_CDR::ULong len;
  bool ok = true;

  // Read and null-terminate 4-byte id string
  ok &= h_in.read_char_array(idstr, 4);
  idstr[4] = 0;
  // Read length of following data block
  ok &= h_in.read_ulong(len);

  if(!ok || string(idstr) != FDM_CDR_FILETAG) {
    cerr << "fdm_cdr_       file: ..ader read failed" << endl;
    _file_ok = false;
    return(false);
  }

  // We now know the length, create and fill an appropriate message block
  // for the payload
  msg.reset(new ACE_Message_Block(len + ACE_CDR::MAX_ALIGNMENT));
  ACE_CDR::mb_align(msg.get());
    
  size_t remsize = len;
  bool done=false;

  while(!done) {
    nread = _io_file->recv(msg->wr_ptr(), remsize);
    if(nread == 0) {
      // Assume EOF, TODO: how would we do better?
      _file_eof = true;
      return(true);
    }
    remsize -= nread;
    msg->wr_ptr(nread);

    if(remsize == 0) {
      done=true;
    }
  }
  return(true);
}

bool
FDM_CDR_File::_write_block(const ACE_Message_Block &msg)
{
  if(!_file_ok || _file_eof || _io_file == NULL) {
    return(false);
  }

  // Create Header
  ACE_OutputCDR header(ACE_CDR::MAX_ALIGNMENT +8);
  ACE_CDR::ULong len = msg.total_length();
  bool ok = true;

  ok &= header.write_char_array(FDM_CDR_FILETAG,4);
  ok &= header.write_ulong(len);

  // Send header
  if(_io_file->send_n(header.begin()) < 0) {
    // Write failed
    _file_ok = false;
    return(false);
  }

  // Send message block
  if(_io_file->send_n(&msg) < 0) {
    // Write failed
    _file_ok = false;
    return(false);
  }
  return(true);
}

bool 
FDM_CDR_File::flush() 
{
  const ACE_Message_Block &msg = get_message_block();
  if(msg.total_length() == 0) {
    // Nothing to write, just return true
    return(true);
  }
  // Something to write, write the existing block
  if(_write_block(msg)) {
    // Write succeeded, clear the ACE_OutputCDR
    clear();
    return(true);
  }
  return(false);
}

// Helper functions to make the case where there is one object per
// file convenient
bool 
FDM_CDR_File::message_block_to_file(const ACE_Message_Block &mb, 
                                    string filename, 
                                    bool append)
{
  // Create conduit between fdr and the file
  FDM_CDR_File out(filename, FDM::Write, append);
    
  // Put the message block into the output file
  return(out._write_block(mb));
}
  
// For now only get the first block
bool 
FDM_CDR_File::file_to_message_block(ACE_Message_Block &mb, 
                                    const string &filename)
{
  // Create conduit between fdr and the file
  FDM_CDR_File  in(filename, FDM::Read);

  // Read the first block
  if(in._file_ok && in._process_next_block()) {
    assert(in._istr!=NULL);
    // This copies the data from _istr into mb
    ACE_CDR::consolidate(&mb, in._istr->start());
    return(true);
  }
  return(false);
}

// Debugging
void
FDM_CDR_File::summarize(ostream &os)
{
  if(is_write()) {
    os << "File type FDM_CDR_File " << endl;
    return;
  }

  map<std::string,int> bmap;
  int i=0;
  while(_file_ok && !_file_eof && _process_next_block()) {
    // Get the type name
    string tname;
    if(_io_object(tname)) {
      if(bmap.find(tname) == bmap.end()) {
        bmap[tname] = 1;
      }
      else {
        bmap[tname]++;
      }
      i++;
    }
  }
  os << "FDM_CDR_File, " << i << " records";
  if(bmap.size()==1) {
    os << " of type " << bmap.begin()->first;
  }
  else {
    os << " of the following types: " << endl;
    std::map<std::string, int>::const_iterator it = bmap.begin();
    for (it = bmap.begin(); it != bmap.end(); it++) {
      os << "  " << it->first << "\t[" << it->second << "]" << endl;
    }
  }
}
bool 
FDM_CDR_File::show_file_contents(ostream &os, const string &filename)
{
  // Create conduit between fdr and the file
  FDM_CDR_File  in(filename, FDM::Read);

  if(!in._file_ok) {
    return(false);
  }

  // Read the first block
  int i=0;
  while(in._file_ok && !in._file_eof && in._process_next_block()) {
    assert(in._istr!=NULL);
    // Get the type name
    string tname="";
    in._peek_object(tname);
    os << "----------------------------------------------------" << endl;
    os << "Block " << i++ << ": Type " << tname << endl;
    os << *(in._istr->start());
  }
  return(true);
}

bool 
FDM_CDR_File::_start_topform(const char *type_name) 
{
  bool ok = true;
  // Read the next block if we haven't already
  if(is_read() && !_got_block) {
    ok &= _process_next_block();
  }
  // Put or get the type name
  _topform_typename = type_name;
  _io_object(_topform_typename);
  if(is_read()) {
    if(_topform_typename != type_name) {
      // If reading, _typeform_typename is now what was stored in the block, 
      // compare to type_name and warn if different
      // This is ok, since sometimes we're reading into a different type, but
      // ultimately using the same io routine (most often when reading into an
      // auto_ptr of a superclass type via a factory)
      /*
      cerr << "WARNING: Stored type differs from that requested " << endl
           << "   Requested '" << type_name 
           << "', Read '" << _topform_typename << endl;
      */
    }
  }
  return(ok & FDM_Stream::_start_topform(type_name));
}
bool 
FDM_CDR_File::_end_topform() 
{
  bool ok = true;
  // If writing, flush output to file
  if(is_write()) {
    ok &= flush();
  }
  else {
    // Reading, record that we don't have the next block yet
    _got_block=false;
    // Check that we read it all, print warning if not
    if(_istr->length() != 0) {
      cerr << "WARNING: In fdm_cdr_file, " << _istr->length()
           << " bytes left in read block, skipping" << endl;
    }
  }
  return(ok);
}

bool 
FDM_CDR_File::_process_next_block()
{
  if(!_file_ok || _file_eof || _io_file == NULL) {
    return(false);
  }

  auto_ptr<ACE_Message_Block> msg;
  // This is guaranteed to create a single, non-chained message block
  bool ok = _read_block(msg);
  if(!ok) {
    _file_ok=false;
    return(false);
  }
  // Make sure that read_block didn't return a chain
  assert(msg.get()!=NULL && msg->cont()==NULL);
  set_message_block(*msg);

  // Mark that we already got the next block
  _got_block = true;

  // set_read_data makes a consolidated copy, so the message block
  // we allocated while reading can now be freed, which the auto_ptr
  // takes care of for us.
  return(true);
}      

bool 
FDM_CDR_File::_check_streams(size_t size) 
{
  bool ok = FDM_CDR::_check_streams(size);
  if(!ok || !_file_ok || _io_file==NULL) {
    // Something fundamental is wrong, fail
    return(false);
  }
  return(true);
}

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635