---

IStreamFile.h

Go to the documentation of this file.

#ifndef SCT_FILE_ISTREAMFILE_H
#define SCT_FILE_ISTREAMFILE_H

#include "../IStream.h"
#include "../IoExceptions.h"

#include <fstream>
#include <string>
#include <cstring>

using std::fstream;
using std::string;
using std::strcpy;

namespace Sct {
namespace File {

template<typename T>
void getArray(ifstream& file, T* p, size_t size, size_t actualSize);

template<typename T>
void getArrayCreate(ifstream& file, T** p, size_t& size);

template<typename T>
void getArrayNoCreate(ifstream& file, T* p, size_t size);

class IStreamFile : public virtual IStream {
public:
    IStreamFile(const string& fileName) : file(fileName.c_str()) {
        if (!file.is_open()) {
            throw FileError(fileName, "Couldn't open file", __FILE__, __LINE__);
        }
    }

    virtual ~IStreamFile() {
        if (file.is_open()) {
            file.close();
        }
    }

    virtual IStream & operator>>(char *str) {
        file >> str;
    //cout << "Read: " << str << endl;
        return *this;
    }

    virtual IStream & operator>>(unsigned char *str) {
        file >> str;
    //cout << "Read: " << str << endl;  
    return *this;
    }

    virtual IStream & operator>>(char **str) {
        string inStr;
        file >> inStr;
        *str = new char[inStr.length()+1];
        strcpy(*str, inStr.c_str());
    //cout << "Read: " << *str << endl; 
    return *this;
    }

    virtual IStream & operator>>(unsigned char **str)  {
        string inStr;
        file >> inStr;
        char* str2 = new char[inStr.length()+1];
        strcpy(str2, inStr.c_str());
        *str = reinterpret_cast<unsigned char*>(str2);
    //cout << "Read: " << *str << endl; 
    return *this;
    }

    virtual IStream & operator>>(bool& val) {
        file >> val;
        return *this;
    }

    virtual IStream & operator>>(char& val) {
    int temp = 0;
        file >> temp;
    val = (char)val;
        return *this;
    }

    virtual IStream & operator>>(unsigned char& val) {
    unsigned int temp = 0;
        file >> temp;
    val = (unsigned char)temp;
    //cout << "ReadUChar: " << (int)val << " at: " << file.tellg() << " temp: " << temp << endl;    
        return *this;
    }

    virtual IStream & operator>>(short& val) {
        file >> val;
        return *this;
    }

    virtual IStream & operator>>(unsigned short& val) {
        file >> val;
        return *this;
    }

    virtual IStream & operator>>(int& val) {
        file >> val;
        return *this;
    }

    virtual IStream & operator>>(unsigned int& val) {
        file >> val;
        return *this;
    }

    virtual IStream & operator>>(long& val)  {
        file >> val;
        return *this;
    }

    virtual IStream & operator>>(unsigned long& val) {
        file >> val;
        return *this;
    }

    virtual IStream & operator>>(float& val) {
        file >> val;
        return *this;
    }

    virtual IStream & operator>>(double& val) {
        file >> val;
        return *this;
    }

    virtual IStream & operator>>(std::string& val) {
        file >> val;
        return *this;
    }

    //    virtual IStream & operator>>(OWLDate& val) = 0;
    //    virtual IStream & operator>>(OWLTime& val) = 0;


    virtual IStream & get ( bool ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    virtual IStream & get ( char ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    virtual IStream & get ( unsigned char ** p, size_t & size ) {
    getArrayCreate(file, p, size);
    return *this;
    }

    virtual IStream & get( short ** p, size_t & size ) {
    getArrayCreate(file, p, size);
    return *this;
    }

    virtual IStream & get( unsigned short ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( int ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( unsigned int ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( long ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( unsigned long ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( float ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( double ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( std::string ** p, size_t & size ) {
    getArrayCreate(file, p, size);
        return *this;
    }

    //    virtual IStream & get( OWLDate ** p, size_t & size ) = 0;
    //    virtual IStream & get( OWLTime ** p, size_t & size ) = 0;

    virtual IStream & get( bool * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( char * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);        
    return *this;
    }

    virtual IStream & get( unsigned char * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);        
    return *this;
    }

    virtual IStream & get( short * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);        
    return *this;
    }

    virtual IStream & get( unsigned short * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);        
    return *this;
    }

    virtual IStream & get( int * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);        
    return *this;
    }

    virtual IStream & get( unsigned int * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);        
    return *this;
    }

    virtual IStream & get( long * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);
    return *this;
    }

    virtual IStream & get( unsigned long * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( float * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( double * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);
        return *this;
    }

    virtual IStream & get( std::string * const p, const size_t size ) {
        getArrayNoCreate(file, p, size);
        return *this;
    }

    //    virtual IStream & get( OWLDate * const p, const size_t size ) = 0;
    //    virtual IStream & get( OWLTime * const p, const size_t size ) = 0;

private:
    ifstream file;
};

template<typename T>
void getArray(ifstream& file, T* p, size_t size, size_t actualSize) {
    size_t copySize = min(size, actualSize);
    for (unsigned int i=0; i<copySize; ++i) {
        file >> p[i];
    }
    for (unsigned int i=size; i<actualSize; ++i) {
        T temp;
        file >> temp;
    }
}

void getArray(ifstream& file, char* p, size_t size, size_t actualSize) {
    int temp;
    size_t copySize = min(size, actualSize);
    for (unsigned int i=0; i<copySize; ++i) {
        file >> temp;
    p[i] = (char)temp;
    }
    for (unsigned int i=size; i<actualSize; ++i) {
        file >> temp;
    }
}

void getArray(ifstream& file, unsigned char* p, size_t size, size_t actualSize) {
    int temp;
    size_t copySize = min(size, actualSize);
    for (unsigned int i=0; i<copySize; ++i) {
        file >> temp;
    p[i] = (unsigned char)temp;
    }
    for (unsigned int i=size; i<actualSize; ++i) {
        file >> temp;
    }
}


template<typename T>
void getArrayCreate(ifstream& file, T** p, size_t& size) {
    file >> size;
    *p = new T[size];
    getArray(file, *p, size, size);
}

template<typename T>
void getArrayNoCreate(ifstream& file, T* p, size_t size) {
    size_t actualSize = 0;
    file >> actualSize;
    getArray(file, p, size, actualSize);
}

}
}
#endif //SCT_FILE_ISTREAMFILE_H

---