Stream.h

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 2017 AURA/LSST.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <https://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef ASTSHIM_SOURCESINK_H
#define ASTSHIM_SOURCESINK_H

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

#include "astshim/base.h"
#include "astshim/detail/utils.h"
#include "astshim/Object.h"

namespace ast {

class Channel;  // forward declaration for friendship

class Stream {
public:
    explicit Stream(std::istream *istreamPtr, std::ostream *ostreamPtr)
            : _istreamPtr(), _ostreamPtr(), _sourceStr(), _isFits(false) {
        if (istreamPtr) {
            _istreamPtr = std::make_shared<std::istream>(istreamPtr->rdbuf());
        }
        if (ostreamPtr) {
            _ostreamPtr = std::make_shared<std::ostream>(ostreamPtr->rdbuf());
        }
    }

    explicit Stream() : Stream(nullptr, nullptr) {}

    virtual ~Stream() {}

    Stream(Stream const &) = default;
    Stream(Stream &&) = default;
    Stream &operator=(Stream const &) = default;
    Stream &operator=(Stream &&) = default;

    bool hasStdStream() { return _istreamPtr || _ostreamPtr; }

    char const *source() {
        if ((_istreamPtr) && (*_istreamPtr)) {
            if (_isFits) {
                // http://codereview.stackexchange.com/a/28759
                _sourceStr.resize(detail::FITSLEN);
                _istreamPtr->read(&_sourceStr[0], detail::FITSLEN);
            } else {
                std::getline(*_istreamPtr, _sourceStr);
            }
            if (*_istreamPtr) {
                return _sourceStr.c_str();
            }
        }
        return nullptr;
    }

    bool sink(char const *cstr) {
        if (_ostreamPtr) {
            (*_ostreamPtr) << cstr;
            if (!_isFits) {
                (*_ostreamPtr) << std::endl;
            }
            return static_cast<bool>(*_ostreamPtr);
        } else {
            return true;
        }
    }

    friend class Channel;

    bool getIsFits() const { return _isFits; }

protected:
    void setIsFits(bool isFits) { _isFits = isFits; }

    std::shared_ptr<std::istream> _istreamPtr;  
    std::shared_ptr<std::ostream> _ostreamPtr;  
    std::string _sourceStr;
    bool _isFits;  
};

class FileStream : public Stream {
public:
    explicit FileStream(std::string const &path, bool doWrite = false) : Stream(), _path(path) {
        auto mode = doWrite ? std::ios_base::out : std::ios_base::in;
        auto fstreamPtr = std::make_shared<std::fstream>(path, mode);
        if (!*fstreamPtr) {
            std::ostringstream os;
            os << "Failed to open file \"" << path << "\" for " << (doWrite ? "writing" : "reading");
            throw std::runtime_error(os.str());
        }
        if (doWrite) {
            _ostreamPtr = fstreamPtr;
        } else {
            _istreamPtr = fstreamPtr;
        }
    }

    virtual ~FileStream() {}

    std::string getPath() const { return _path; }

private:
    std::string _path;  
};

class StringStream : public Stream {
public:
    explicit StringStream(std::string const &data = "") : Stream(), _istringstreamPtr(), _ostringstreamPtr() {
        _istringstreamPtr = std::make_shared<std::istringstream>(data);
        _ostringstreamPtr = std::make_shared<std::ostringstream>();
        _istreamPtr = _istringstreamPtr;
        _ostreamPtr = _ostringstreamPtr;
    }

    virtual ~StringStream() {}

    std::string getSourceData() const { return _istringstreamPtr->str(); }

    std::string getSinkData() const { return _ostringstreamPtr->str(); }

    void sinkToSource() {
        _istringstreamPtr->clear();
        _istringstreamPtr->str(getSinkData());
        _ostringstreamPtr->str("");
    }

private:
    std::shared_ptr<std::istringstream> _istringstreamPtr;
    std::shared_ptr<std::ostringstream> _ostringstreamPtr;
};

namespace detail {

inline const char *source() {
    auto ssptr = reinterpret_cast<Stream *>(astChannelData);
    if (ssptr) {
        return ssptr->source();
    } else {
        return nullptr;
    }
}

inline void sink(const char *cstr) {
    auto ssptr = reinterpret_cast<Stream *>(astChannelData);
    if (ssptr) {
        auto isok = ssptr->sink(cstr);
        if (!isok) {
            astSetStatus(AST__ATGER);
        }
    }
}

}  // namespace detail

}  // namespace ast

#endif