Csv.h

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_H
#define LSST_AP_UTILS_CSV_H

#include <fstream>
#include <string>
#include <vector>

#include "lsst/tr1/unordered_map.h"

#include "boost/scoped_ptr.hpp"
#include "boost/scoped_array.hpp"

#include "lsst/pex/config.h"

#include "CsvControl.h"


namespace lsst { namespace ap { namespace utils {

class CsvReader {
public:
    CsvReader(std::string const &path,
              CsvControl const &control,
              bool namesInFirstRecord=false);
    CsvReader(std::istream &in,
              CsvControl const &control,
              bool namesInFirstRecord=false);
    ~CsvReader();

    inline CsvControl const & getControl() const;

    // Return the number of lines/records read
    inline size_t getNumLines() const;
    inline size_t getNumRecords() const;

    // Get/set field names
    inline std::vector<std::string> const & getFieldNames() const;
    void setFieldNames(std::vector<std::string> const & names);
    void setFieldNames(std::string const & names,
                       std::string const & regex,
                       bool stripWhitespace=true);

    // Map field names to field indexes
    inline int getIndexOf(std::string const &name) const;
    inline int getIndexOf(char const *name) const;

    // Have all records been read?
    inline bool isDone() const;

    // Advance to the next record
    inline void nextRecord();


    inline int getNumFields() const;

    inline bool isNull(int i) const;
    inline bool isNull(std::string const &name) const;
    inline bool isNull(char const *name) const;

    inline std::string const get(int i) const;
    inline std::string const get(std::string const &name) const;
    inline std::string const get(char const *name) const;

    // Get and convert a field value. Allowed types are std::string, bool,
    // built-in integral and floating point types, and char const *. The
    // pointers returned by get<char const *>() are invalidated by a call
    // to nextRecord().
    template <typename T> inline T const get(int i) const;
    template <typename T> inline T const get(std::string const &name) const;
    template <typename T> inline T const get(char const *name) const;

private:
    typedef std::tr1::unordered_map<std::string, int> FieldIndexes;

    static std::string const WHITESPACE;
    static int const MAX_RECORD_LENGTH;
    static int const DEFAULT_CAPACITY;

    enum State {
        START_RECORD = 0,
        START_FIELD,
        IN_FIELD,
        IN_QUOTED_FIELD,
        INITIAL_ESCAPE,
        ESCAPE,
        EMBEDDED_QUOTE
    };

    // disable copy construction/assignment
    CsvReader(CsvReader const &);
    CsvReader & operator=(CsvReader const &);

    void _ioError(char const *msg) const;
    void _runtimeError(char const *msg) const;
    bool _readLine(int offset);
    void _readRecord();
    void _checkWhitespace(char const *s, char const *msg) const;
    template <typename T> static inline T _null();
    template <typename T> T _get(char const *value) const; 

    std::string _path;                  
    CsvControl _control;                
    std::vector<std::string> _names;    
    FieldIndexes _indexes;              

    boost::scoped_ptr<std::ifstream> _stream; 
    std::istream *_in;                  
    size_t _numLines;                   
    size_t _numRecords;                 
    boost::scoped_array<char> _record;  
    int _capacity;                      
    bool _done;                         
    std::vector<int> _fields;           
};

class CsvWriter {
public:
    CsvWriter(std::string const &path,
              CsvControl const &control,
              bool truncate=false,
              bool append=false);
    CsvWriter(std::ostream &out,
              CsvControl const &control);
    ~CsvWriter();

    inline CsvControl const & getControl() const;

    // End the current record
    void endRecord();

    // Flush the underlying output stream without ending the current record
    inline void flush();

    // Return the number of lines/records/fields written
    inline size_t getNumLines() const;
    inline size_t getNumRecords() const;
    inline size_t getNumFields() const;


    void appendFields(std::vector<std::string> const &fields);
    inline void appendField(std::string const &v);
    inline void appendField(char const *v);
    inline void appendField(bool v);
    inline void appendField(char v);
    void appendField(signed char v);
    void appendField(short v);
    void appendField(int v);
    void appendField(long v);
    void appendField(long long v);
    void appendField(unsigned char v);
    void appendField(unsigned short v);
    void appendField(unsigned int v);
    void appendField(unsigned long v);
    void appendField(unsigned long long v);
    void appendField(float v);
    void appendField(double v);
    void appendField(long double v);

    void appendNull();

    // Raw writes. Beware: these bypass all output formatting!
    inline void write(std::string const &v);
    inline void write(char c);

private:
    // disable copy construction/assignment
    CsvWriter(CsvWriter const &);
    CsvWriter & operator=(CsvWriter const &);

    void _write(char const *s);
    void _writeQuoted(char const *s);
    void _writeUnquoted(char const *s);

    boost::scoped_ptr<std::ofstream> _stream; 
    std::ostream *_out;                       
    CsvControl _control;                      
    size_t _numRecords;                       
    size_t _numLines;                         
    size_t _numFields;                        
};

// STL-style output for CsvWriter
inline CsvWriter & endr(CsvWriter &);
inline CsvWriter & flush(CsvWriter &);
inline CsvWriter & nullf(CsvWriter &);
template <typename T> inline CsvWriter & operator<<(CsvWriter &, T const &);
template <typename T> inline CsvWriter& operator<<(CsvWriter&, CsvWriter& (*)(CsvWriter&));

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

#include "Csv.cc" // for inline/template members

#endif // LSST_AP_UTILS_CSV_H