source: libcfa/src/fstream.hfa

//
// 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 : Sun Oct 10 09:37:32 2021
// Update Count     : 243
//

#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$;
}; // ofstream

// Satisfies ostream

// private
bool sepPrt$( ofstream & );
void sepReset$( ofstream & );
void sepReset$( ofstream &, bool );
const char * sepGetCur$( ofstream & );
void sepSetCur$( ofstream &, const char [] );
bool getNL$( ofstream & );
void setNL$( ofstream &, bool );
bool getANL$( ofstream & );
bool getPrt$( ofstream & );
void setPrt$( ofstream &, bool );

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

// public
void sepOn( ofstream & );
void sepOff( ofstream & );
bool sepDisable( ofstream & );
bool sepEnable( ofstream & );
void nlOn( ofstream & );
void nlOff( 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 clear( ofstream & );
int flush( ofstream & );
void open( ofstream &, const char name[], const char mode[] ); // FIX ME: use default = "w"
void open( ofstream &, const char name[] );
void close( ofstream & );

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

void ?{}( ofstream & );
void ?{}( ofstream &, const char name[], const char mode[] ); // FIX ME: use default = "w"
void ?{}( ofstream &, const char name[] );
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$;
}; // ifstream

// Satisfies istream

// private
bool getANL$( ifstream & );

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

// public
void nlOn( ifstream & );
void nlOff( ifstream & );
void ends( ifstream & );
int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));

bool fail( ifstream & is );
void clear( ifstream & );
bool eof( ifstream & is );
void open( ifstream & is, const char name[], const char mode[] ); // FIX ME: use default = "r"
void open( ifstream & is, const char name[] );
void close( ifstream & is );

ifstream & read( ifstream & is, char data[], size_t size );
ifstream & ungetc( ifstream & is, char c );

void ?{}( ifstream & is );
void ?{}( ifstream & is, const char name[], const char mode[] ); // FIX ME: use default = "r"
void ?{}( ifstream & is, const char name[] );
void ^?{}( ifstream & is );

extern ifstream & sin, & stdin;                                                 // aliases


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


exception 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 & );

exception 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 & );

exception 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 & );

exception 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: //