#include <extforce.h>

Inheritance diagram for ExtFileHandler:

Collaboration diagram for ExtFileHandler:

Public Member Functions
	ExtFileHandler (std::string &fin, bool bRemoveIn, std::string &fout, bool bNoClobberOut, mbsleep_t SleepTime, std::streamsize Precision)

virtual	~ExtFileHandler (void)

virtual bool	Prepare_pre (void)

virtual void	Prepare_post (bool ok)

virtual void	AfterPredict (void)

virtual bool	Send_pre (SendWhen when)

virtual void	Send_post (SendWhen when)

virtual bool	Recv_pre (void)

virtual bool	Recv_post (void)

virtual std::ostream *	GetOutStream (void)

virtual std::istream *	GetInStream (void)

Public Member Functions inherited from ExtFileHandlerBase
	ExtFileHandlerBase (mbsleep_t SleepTime, std::streamsize Precision)

virtual	~ExtFileHandlerBase (void)

virtual Negotiate	NegotiateRequest (void) const

virtual int	GetOutFileDes (void)

virtual int	GetSendFlags (void) const

virtual int	GetInFileDes (void)

virtual int	GetRecvFlags (void) const

Protected Attributes
std::string	fin

std::string	fout

std::string	tmpout

bool	bRemoveIn

bool	bNoClobberOut

std::ifstream	inf

std::ofstream	outf

Protected Attributes inherited from ExtFileHandlerBase
std::streamsize	Precision

mbsleep_t	SleepTime

bool	bOK

Additional Inherited Members
Public Types inherited from ExtFileHandlerBase
enum	SendWhen { SEND_FIRST_TIME, SEND_REGULAR, SEND_AFTER_CONVERGENCE }

enum	Negotiate { NEGOTIATE_NO, NEGOTIATE_CLIENT, NEGOTIATE_SERVER }

enum	OutputFlags { OUTPUT_KIN = 0x1000, OUTPUT_DYN = 0x2000, OUTPUT_REF = 0x4000, OUTPUT_REF_KIN = (OUTPUT_REF \| OUTPUT_KIN), OUTPUT_REF_DYN = (OUTPUT_REF \| OUTPUT_DYN) }

Detailed Description

Definition at line 112 of file extforce.h.

Constructor & Destructor Documentation

ExtFileHandler::ExtFileHandler	(	std::string &	fin,
		bool	bRemoveIn,
		std::string &	fout,
		bool	bNoClobberOut,
		mbsleep_t	SleepTime,
		std::streamsize	Precision
	)

Definition at line 116 of file extforce.cc.

References NO_OP.

 : ExtFileHandlerBase(SleepTime, Precision),
 fin(fin), fout(fout), tmpout(fout + ".tmp"),
 bRemoveIn(bRemoveIn), bNoClobberOut(bNoClobberOut)
 {
         NO_OP;
 }

ExtFileHandler::~ExtFileHandler ( void )

virtual

Definition at line 129 of file extforce.cc.

References NO_OP.

 {
         NO_OP;
 }

Member Function Documentation

void ExtFileHandler::AfterPredict ( void )

virtual

Implements ExtFileHandlerBase.

Definition at line 147 of file extforce.cc.

References NO_OP.

 {
         NO_OP;
 }

std::istream * ExtFileHandler::GetInStream ( void )

virtual

Reimplemented from ExtFileHandlerBase.

Definition at line 289 of file extforce.cc.

References inf.

 {
         return &inf;
 }

std::ostream * ExtFileHandler::GetOutStream ( void )

virtual

Reimplemented from ExtFileHandlerBase.

Definition at line 283 of file extforce.cc.

References outf.

 {
         return &outf;
 }

void ExtFileHandler::Prepare_post ( bool ok )

virtual

Implements ExtFileHandlerBase.

Definition at line 141 of file extforce.cc.

References NO_OP.

 {
         NO_OP;
 }

bool ExtFileHandler::Prepare_pre ( void )

virtual

Implements ExtFileHandlerBase.

Definition at line 135 of file extforce.cc.

 {
         return true;
 }

bool ExtFileHandler::Recv_post ( void )

virtual

Implements ExtFileHandlerBase.

Definition at line 257 of file extforce.cc.

References bRemoveIn, fin, inf, and MBDYN_EXCEPT_ARGS.

 {
         inf.close();
 
         if (bRemoveIn) {
                 if (unlink(fin.c_str()) != 0) {
                         int save_errno = errno;
 
                         switch (save_errno) {
                         case ENOENT:
                                 break;
 
                         default:
                                 silent_cerr("unable to delete input file "
                                         "\"" << fin.c_str() << "\": "
                                         << strerror(save_errno) << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
                 }
         }
 
         // NOTE: allow MBDyn to decide when converged
         return true;
 }

bool ExtFileHandler::Recv_pre ( void )

virtual

Implements ExtFileHandlerBase.

Definition at line 234 of file extforce.cc.

References ExtFileHandlerBase::bOK, fin, inf, mbdyn_stop_at_end_of_iteration(), mbsleep(), and ExtFileHandlerBase::SleepTime.

 {
         inf.open(fin.c_str());
 
         for (int cnt = 0; !inf; cnt++) {
                 silent_cout("input file \"" << fin.c_str() << "\" missing, "
                         "try #" << cnt << "; "
                         "sleeping " << SleepTime << " s" << std::endl); 
                
                 if (mbdyn_stop_at_end_of_iteration()) {
                         inf.setstate(std::ios_base::badbit);
                         return (bOK = false);
                 }
 
                 mbsleep(&SleepTime);
                 inf.clear();
                 inf.open(fin.c_str());
         }
 
         return inf.good();
 }

Here is the call graph for this function:

void ExtFileHandler::Send_post ( SendWhen when )

virtual

Implements ExtFileHandlerBase.

Definition at line 219 of file extforce.cc.

References fout, MBDYN_EXCEPT_ARGS, outf, and tmpout.

 {
         outf.close();
         if (rename(tmpout.c_str(), fout.c_str()) != 0) {
                 int save_errno = errno;
                 silent_cerr("ExtFileHandler: unable to rename output file "
                         "\"" << tmpout.c_str() << "\" "
                         "into \"" << fout.c_str() << "\" "
                         "(" << save_errno << ": " << strerror(save_errno) << ")"
                         << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 }

bool ExtFileHandler::Send_pre ( SendWhen when )

virtual

Implements ExtFileHandlerBase.

Definition at line 153 of file extforce.cc.

References bNoClobberOut, fout, MBDYN_EXCEPT_ARGS, mbdyn_stop_at_end_of_iteration(), mbsleep(), outf, ExtFileHandlerBase::Precision, ExtFileHandlerBase::SleepTime, and tmpout.

 {
         if (bNoClobberOut) {
                 bool    bKeepGoing(true);
 
                 for (int cnt = 0; bKeepGoing; cnt++) {
                         struct stat     s;
 
                         if (stat(fout.c_str(), &s) != 0) {
                                 int save_errno = errno;
 
                                 switch (save_errno) {
                                 case ENOENT:
                                         bKeepGoing = false;
                                         break;
 
                                 default:
                                         silent_cerr("unable to stat output file "
                                                 "\"" << fout.c_str() << "\": "
                                                 << strerror(save_errno)
                                                 << std::endl);
                                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                                 }
 
                         } else {
                                 if (mbdyn_stop_at_end_of_iteration()) {
                                         outf.setstate(std::ios_base::badbit);
                                         return false;
                                 }
 
                                 if (SleepTime > 0) {
                                         silent_cout("output file "
                                                 "\"" << fout.c_str() << "\" "
                                                 "still present, "
                                                 "try #" << cnt << "; "
                                                 "sleeping " << SleepTime << " s"
                                                 << std::endl);
                                         mbsleep(&SleepTime);
 
                                 } else {
                                         silent_cout("output file "
                                                 "\"" << fout.c_str() << "\" "
                                                 "still present, "
                                                 "try #" << cnt
                                                 << std::endl);
                                 }
                         }
                 }
         }
 
         outf.open(tmpout.c_str());
 
         if (!outf) {
                 silent_cerr("unable to open file \"" << fout.c_str() << "\""
                         << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         if (Precision != 0) {
                 outf.precision(Precision);
         }
         outf.setf(std::ios::scientific);
         return outf.good();
 }