source: libcfa/src/fstream.hfa@ 8eb85de

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// fstream --
//
// Author           : Peter A. Buhr
// Created On       : Wed May 27 17:56:53 2015
// Last Modified By : Peter A. Buhr
// Last Modified On : Wed Jan 14 21:11:16 2026
// Update Count     : 280
//

#pragma once

#include "bits/weakso_locks.hfa"                                                // mutex_lock
#include "iostream.hfa"


// *********************************** ofstream ***********************************


enum { ofstream_sepSize = 16 };
struct ofstream {
        void * file$;
        bool sepDefault$;
        bool sepOnOff$;
        bool nlOnOff$;
        bool prt$;                                                                                      // print text
        bool sawNL$;
        const char * sepCur$;
        char separator$[ofstream_sepSize];
        char tupleSeparator$[ofstream_sepSize];
        multiple_acquisition_lock lock$;                                        // used by trait is_lock for mutex statement
}; // ofstream

// Satisfies ostream
extern basic_ostream_data(ofstream) const & basic_ostream_table;
extern ostream_data(ofstream) const & ostream_table;

// private
bool getNL$( ofstream & );
bool setNL$( ofstream &, bool );
bool getANL$( ofstream & );
bool setANL$( ofstream &, bool );

bool sepPrt$( ofstream & );
void sepReset$( ofstream & );
void sepReset$( ofstream &, bool );
const char * sepGetCur$( ofstream & );
void sepSetCur$( ofstream &, const char [] );

bool getPrt$( ofstream & );
bool setPrt$( ofstream &, bool );

void lock( ofstream & );
void unlock( ofstream & );

// public
void nlOn( ofstream & );
void nlOff( ofstream & );

void sep( ofstream & );
void nosep( ofstream & );
bool sepOn( ofstream & );
bool sepOff( ofstream & );
const char * sepGet( ofstream & );
void sepSet( ofstream &, const char [] );
const char * sepGetTuple( ofstream & );
void sepSetTuple( ofstream &, const char [] );

void ends( ofstream & );
int fmt( ofstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));

bool fail( ofstream & );
void clearerr( ofstream & );
int flush( ofstream & );
void open( ofstream &, const char name[], const char mode[] = "w" );
void close( ofstream & );

ofstream & write( ofstream &, const char data[], size_t size );

void ?{}( ofstream & );
void ?{}( ofstream &, const char name[], const char mode[] = "w" );
void ^?{}( ofstream & );

// private
static inline ofstream & nl$( ofstream & os ) { return nl( os ); } // remember basic_ostream nl
// public
ofstream & nl( ofstream & os );                                                 // override basic_ostream nl

extern ofstream & sout, & stdout, & serr, & stderr;             // aliases
extern ofstream & exit, & abort;


// *********************************** ifstream ***********************************


struct ifstream {
        void * file$;
        bool nlOnOff$;
        multiple_acquisition_lock lock$;                                        // used by trait is_lock for mutex statement
}; // ifstream

// Satisfies istream
extern basic_istream_data(ifstream) const & basic_istream_table;
extern istream_data(ifstream) const & istream_table;

// private
bool getANL$( ifstream & );
bool setANL$( ifstream &, bool );

void lock( ifstream & );
void unlock( ifstream & );

// public
void nlOn( ifstream & );
void nlOff( ifstream & );
int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
ifstream & ungetc( char c, ifstream & is );
bool eof( ifstream & is );

bool fail( ifstream & is );
void clearerr( ifstream & );
void open( ifstream & is, const char name[], const char mode[] = "r" );
void close( ifstream & is );
ifstream & read( ifstream & is, char data[], size_t size );

void ?{}( ifstream & is );
void ?{}( ifstream & is, const char name[], const char mode[] = "r" );
void ^?{}( ifstream & is );

extern ifstream & sin, & stdin;                                                 // aliases


// *********************************** exceptions ***********************************


ExceptionDecl( open_failure,
        union {
                ofstream * ostream;
                ifstream * istream;
        };
        // TEMPORARY: need polymorphic exceptions
        int tag;                                                                                        // 1 => ostream; 0 => istream
);

void ?{}( open_failure & this, ofstream & );
void ?{}( open_failure & this, ifstream & );

ExceptionDecl( close_failure,
        union {
                ofstream * ostream;
                ifstream * istream;
        };
        // TEMPORARY: need polymorphic exceptions
        int tag;                                                                                        // 1 => ostream; 0 => istream
);

void ?{}( close_failure & this, ofstream & );
void ?{}( close_failure & this, ifstream & );

ExceptionDecl( write_failure,
        union {
                ofstream * ostream;
                ifstream * istream;
        };
        // TEMPORARY: need polymorphic exceptions
        int tag;                                                                                        // 1 => ostream; 0 => istream
);

void ?{}( write_failure & this, ofstream & );
void ?{}( write_failure & this, ifstream & );

ExceptionDecl( read_failure,
        union {
                ofstream * ostream;
                ifstream * istream;
        };
        // TEMPORARY: need polymorphic exceptions
        int tag;                                                                                        // 1 => ostream; 0 => istream
);

void ?{}( read_failure & this, ofstream & );
void ?{}( read_failure & this, ifstream & );

// Local Variables: //
// mode: c //
// tab-width: 4 //
// End: //