Csv.cc

Go to the documentation of this file.

// -*- lsst-c++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 * 
 * 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 <http://www.lsstcorp.org/LegalNotices/>.
 */

#ifndef LSST_AP_UTILS_CSV_CC
#define LSST_AP_UTILS_CSV_CC

#include "Csv.h"

#include <limits>

#include "boost/mpl/or.hpp"
#include "boost/static_assert.hpp"
#include "boost/type_traits/is_integral.hpp"
#include "boost/type_traits/is_floating_point.hpp"
#include "boost/type_traits/is_same.hpp"


namespace lsst { namespace ap { namespace utils {

// -- CsvReader inline/template members ----

inline CsvControl const & CsvReader::getControl() const {
    return _control;
}

inline size_t CsvReader::getNumLines() const {
    return _numLines;
}

inline size_t CsvReader::getNumRecords() const {
    return _numRecords;
}

inline std::vector<std::string> const & CsvReader::getFieldNames() const {
    return _names;
}


inline int CsvReader::getIndexOf(std::string const &name) const {
    FieldIndexes::const_iterator i = _indexes.find(name);
    return i == _indexes.end() ? -1 : static_cast<int>(i->second);
}
inline int CsvReader::getIndexOf(char const *name) const {
    return getIndexOf(std::string(name));
}

inline bool CsvReader::isDone() const {
    return _done;
}

inline void CsvReader::nextRecord() {
    if (!_done) {
        _readRecord();
    }
}

inline int CsvReader::getNumFields() const {
    return static_cast<int>(_fields.size());
}

inline bool CsvReader::isNull(int i) const {
    if (_done) {
        _ioError("no current record (all records have been read)");
    }
    if (i < 0 || static_cast<size_t>(i) >= _fields.size()) {
        _ioError("attempt to access field with invalid field name or index");
    }
    return _fields[i] < 0;
}
inline bool CsvReader::isNull(std::string const &name) const {
    return isNull(getIndexOf(name));
}
inline bool CsvReader::isNull(char const *name) const {
    return isNull(getIndexOf(name));
}

template <typename T> inline T const CsvReader::get(int i) const {
    // force a compile time error for unsupported types
    static int const typeAllowed = boost::mpl::or_<
                                       boost::is_same<T, char const *>,
                                       boost::is_same<T, std::string>,
                                       boost::is_integral<T>,
                                       boost::is_floating_point<T>
                                   >::value;
    BOOST_STATIC_ASSERT(typeAllowed);
    if (isNull(i)) {
        return _null<T>();
    }
    // _get specializations live in the implementation file
    return _get<T>(_record.get() + _fields[i]);
}
template <typename T> inline T const CsvReader::get(std::string const &name) const {
    return get<T>(getIndexOf(name));
}
template <typename T> inline T const CsvReader::get(char const *name) const {
    return get<T>(getIndexOf(name));
}

inline std::string const CsvReader::get(int i) const {
    return get<std::string>(i);
}
inline std::string const CsvReader::get(std::string const &name) const {
    return get<std::string>(getIndexOf(name));
}
inline std::string const CsvReader::get(char const *name) const {
    return get<std::string>(getIndexOf(name));
}

// NULL values for various types
template <typename T> inline T CsvReader::_null() {
    BOOST_STATIC_ASSERT(sizeof(T) == 0);
}
template <> inline std::string CsvReader::_null<std::string>() {
    return std::string();
}
template <> inline char const * CsvReader::_null<char const *>() {
    return 0;
}
template <> inline bool CsvReader::_null<bool>() {
    return false;
}
template <> inline char CsvReader::_null<char>() {
    return '\0';
}

#define LSST_SPECIALIZE_NULL(T) \
    template <> inline T CsvReader::_null<T>() { \
        return std::numeric_limits<T>::min(); \
    }
LSST_SPECIALIZE_NULL(signed char)
LSST_SPECIALIZE_NULL(short)
LSST_SPECIALIZE_NULL(int)
LSST_SPECIALIZE_NULL(long)
LSST_SPECIALIZE_NULL(long long)
#undef LSST_SPECIALIZE_NULL

#define LSST_SPECIALIZE_NULL(T) \
    template <> inline T CsvReader::_null<T>() { \
        return std::numeric_limits<T>::max(); \
    }
LSST_SPECIALIZE_NULL(unsigned char)
LSST_SPECIALIZE_NULL(unsigned short)
LSST_SPECIALIZE_NULL(unsigned int)
LSST_SPECIALIZE_NULL(unsigned long)
LSST_SPECIALIZE_NULL(unsigned long long)
#undef LSST_SPECIALIZE_NULL

#define LSST_SPECIALIZE_NULL(T) \
    template <> inline T CsvReader::_null<T>() { \
        return std::numeric_limits<T>::quiet_NaN(); \
    }
LSST_SPECIALIZE_NULL(float)
LSST_SPECIALIZE_NULL(double)
LSST_SPECIALIZE_NULL(long double)
#undef LSST_SPECIALIZE_NULL

// Trivial _get implementations
template <>
inline char const * CsvReader::_get<char const *>(char const *field) const {
    return field;
}
template <>
inline std::string CsvReader::_get<std::string>(char const *field) const {
    return std::string(field);
}


// -- CsvWriter inlines ----

inline CsvControl const & CsvWriter::getControl() const {
    return _control;
}

inline void CsvWriter::flush() {
    _out->flush();
}

inline size_t CsvWriter::getNumLines() const {
    return _numLines;
}

inline size_t CsvWriter::getNumRecords() const {
    return _numRecords;
}

inline size_t CsvWriter::getNumFields() const {
    return _numFields;
}

inline void CsvWriter::appendField(std::string const &v) {
    _write(v.c_str());
}

inline void CsvWriter::appendField(char const *v) {
    if (v == 0) {
        appendNull();
    } else {
        _write(v);
    }
}

inline void CsvWriter::appendField(bool v) {
    _write(v ? "1" : "0");
}

inline void CsvWriter::appendField(char v) {
    char s[2];
    s[0] = v;
    s[1] = '\0';
    _write(s);
}

inline void CsvWriter::write(std::string const &s) {
    _out->write(s.c_str(), s.size());
}
inline void CsvWriter::write(char c) {
    _out->put(c);
}


// -- STL-style output for CsvWriter ----

template <typename T>
inline CsvWriter & operator<<(CsvWriter &w, T const &v) {
    w.appendField(v);
    return w;
}

inline CsvWriter & endr(CsvWriter &w) {
    w.endRecord();
    return w;
}

inline CsvWriter & flush(CsvWriter &w) {
    w.flush();
    return w;
}

inline CsvWriter & nullf(CsvWriter &w) {
    w.appendNull();
    return w;
}

template <typename T>
inline CsvWriter& operator<<(CsvWriter& w, CsvWriter& (*manip)(CsvWriter&)) {
    return manip(w);
}

}}} // namespace lsst::ap::utils

#endif // LSST_AP_UTILS_CSV_CC