PropertyPrinter.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_PEX_PROPERTYPRINTER_H
#define LSST_PEX_PROPERTYPRINTER_H

#include <string>
#include <ostream>
#include <sstream>
#include <vector>
#include <typeinfo>

#include "lsst/daf/base/PropertySet.h"
#include "lsst/daf/base/DateTime.h"
#include "boost/any.hpp"

namespace lsst {
namespace pex {
namespace logging {


class PrinterIter {
public:

    virtual ~PrinterIter()=0;

    virtual std::ostream& write(std::ostream *strm) const=0;

    virtual PrinterIter& operator++()=0;

    virtual PrinterIter& operator--()=0;

    virtual bool operator==(const PrinterIter& that) const=0;

    virtual bool operator!=(const PrinterIter& that) const=0;

    virtual bool notAtEnd() const=0;

    virtual bool notLTBegin() const=0;

    const std::string operator*() const {
        std::ostringstream out;
        write(&out);
        return out.str();
    }
};


template <class T>
class BaseTmplPrinterIter : public PrinterIter {
public:
    BaseTmplPrinterIter(typename std::vector<T>::const_iterator listiter,
                        typename std::vector<T>::const_iterator beginiter,
                        typename std::vector<T>::const_iterator enditer) 
        : _it(listiter), _begin(beginiter), _end(enditer) { }
    virtual ~BaseTmplPrinterIter();
    virtual PrinterIter& operator++();
    virtual PrinterIter& operator--();
    virtual bool operator==(const PrinterIter& that) const;
    virtual bool operator!=(const PrinterIter& that) const;
    virtual bool notAtEnd() const;
    virtual bool notLTBegin() const;
    bool operator==(const BaseTmplPrinterIter& that) const { 
        return (this->_it == that._it); 
    }
    bool operator!=(const BaseTmplPrinterIter& that) const { 
        return (this->_it != that._it); 
    }
protected:
    typename std::vector<T>::const_iterator _it, _begin, _end;
};

template <class T>
BaseTmplPrinterIter<T>::~BaseTmplPrinterIter() { }
template <class T>
PrinterIter& BaseTmplPrinterIter<T>::operator++() { ++_it; return *this; }
template <class T>
PrinterIter& BaseTmplPrinterIter<T>::operator--() { --_it; return *this; }
template <class T>
bool BaseTmplPrinterIter<T>::operator==(const PrinterIter& that) const {
    const BaseTmplPrinterIter<T> *thit = 
        dynamic_cast<const BaseTmplPrinterIter<T>*>(&that);
    return (thit == 0) ? false : (*this == *thit);
}
template <class T>
bool BaseTmplPrinterIter<T>::operator!=(const PrinterIter& that) const {
    const BaseTmplPrinterIter<T> *thit = 
        dynamic_cast<const BaseTmplPrinterIter<T>*>(&that);
    return (thit == 0) ? true : (*this != *thit);
}
template <class T>
bool BaseTmplPrinterIter<T>::notAtEnd() const { return (_it != _end); }
template <class T>
bool BaseTmplPrinterIter<T>::notLTBegin() const { return (_it >= _begin); } 

template <class T>
class TmplPrinterIter : public BaseTmplPrinterIter<T> {
public:
    TmplPrinterIter(typename std::vector<T>::const_iterator listiter,
                    typename std::vector<T>::const_iterator beginiter,
                    typename std::vector<T>::const_iterator enditer) 
        : BaseTmplPrinterIter<T>(listiter, beginiter, enditer) { }
    virtual std::ostream& write(std::ostream *strm) const;
};

template <class T>
std::ostream& TmplPrinterIter<T>::write(std::ostream *strm) const { 
    (*strm) << *(this->_it); 
    return *strm;
}


class WrappedPrinterIter : public PrinterIter {
public:
    WrappedPrinterIter(std::shared_ptr<PrinterIter> iter) : _it(iter) { }
    virtual ~WrappedPrinterIter();
    virtual std::ostream& write(std::ostream *strm) const;
    virtual PrinterIter& operator++();
    virtual PrinterIter& operator--();
    virtual bool operator==(const PrinterIter& that) const;
    virtual bool operator!=(const PrinterIter& that) const;
    virtual bool notAtEnd() const;
    virtual bool notLTBegin() const;
private:
    std::shared_ptr<PrinterIter> _it;
};

class PrinterList {
public:
    typedef WrappedPrinterIter iterator;

    virtual ~PrinterList();

    virtual iterator begin() const=0;

    virtual iterator last() const=0;

    virtual size_t valueCount() const=0;
};

template <class T>
class BaseTmplPrinterList : public PrinterList {
public:
    BaseTmplPrinterList(const lsst::daf::base::PropertySet& prop, 
                        const std::string& name)
        : _list(prop.getArray<T>(name)) { }

    virtual ~BaseTmplPrinterList();
    virtual size_t valueCount() const;

protected:
    std::vector<T> _list;
};

template <class T>
BaseTmplPrinterList<T>::~BaseTmplPrinterList() { }
template <class T>
size_t BaseTmplPrinterList<T>::valueCount() const { return _list.size(); }

template <class T>
class TmplPrinterList : public BaseTmplPrinterList<T> {
public:
    TmplPrinterList(const lsst::daf::base::PropertySet& prop, const std::string& name)
        : BaseTmplPrinterList<T>(prop, name) { }

    virtual PrinterList::iterator begin() const;
    virtual PrinterList::iterator last() const;

private:
    typedef TmplPrinterIter<T> delegateIter;
};

template <class T>
typename PrinterList::iterator TmplPrinterList<T>::begin() const { 
    PrinterIter *it = new delegateIter(BaseTmplPrinterList<T>::_list.begin(), 
                                       BaseTmplPrinterList<T>::_list.begin(), 
                                       BaseTmplPrinterList<T>::_list.end());
    return PrinterList::iterator(std::shared_ptr<PrinterIter>(it));
}
template <class T>
typename PrinterList::iterator TmplPrinterList<T>::last() const { 
    PrinterIter *it = new delegateIter(BaseTmplPrinterList<T>::_list.end()-1, 
                                       BaseTmplPrinterList<T>::_list.begin(), 
                                       BaseTmplPrinterList<T>::_list.end());
    return PrinterList::iterator(std::shared_ptr<PrinterIter>(it));
}

template <class T> 
PrinterList* makePrinter(const lsst::daf::base::PropertySet& prop, 
                         const std::string& name) {
    return new TmplPrinterList<T>(prop, name);
}

class DateTimePrinterIter : public BaseTmplPrinterIter<lsst::daf::base::DateTime> {
public:
    DateTimePrinterIter(std::vector<lsst::daf::base::DateTime>::const_iterator listiter,
                        std::vector<lsst::daf::base::DateTime>::const_iterator beginiter,
                        std::vector<lsst::daf::base::DateTime>::const_iterator enditer)
        : BaseTmplPrinterIter<lsst::daf::base::DateTime>(listiter, beginiter, enditer) 
    { }

    virtual ~DateTimePrinterIter();
    virtual std::ostream& write(std::ostream *strm) const;
};

class DateTimePrinterList : public BaseTmplPrinterList<lsst::daf::base::DateTime> {
public:
    DateTimePrinterList(const lsst::daf::base::PropertySet& prop, 
                        const std::string& name) 
        : BaseTmplPrinterList<lsst::daf::base::DateTime>(prop, name) { }

    virtual ~DateTimePrinterList();
    virtual iterator begin() const;
    virtual iterator last() const;
};

PrinterList* makeDateTimePrinter(const lsst::daf::base::PropertySet& prop, 
                                 const std::string& name);

class BoolPrinterIter : public BaseTmplPrinterIter<bool> {
public:
    BoolPrinterIter(std::vector<bool>::const_iterator listiter,
                        std::vector<bool>::const_iterator beginiter,
                        std::vector<bool>::const_iterator enditer)
        : BaseTmplPrinterIter<bool>(listiter, beginiter, enditer) { }
    virtual ~BoolPrinterIter();
    virtual std::ostream& write(std::ostream *strm) const;
};

class BoolPrinterList : public BaseTmplPrinterList<bool> {
public:
    BoolPrinterList(const lsst::daf::base::PropertySet& prop, const std::string& name) 
        : BaseTmplPrinterList<bool>(prop, name) { }

    virtual ~BoolPrinterList();
    virtual iterator begin() const;
    virtual iterator last() const;
};

PrinterList* makeBoolPrinter(const lsst::daf::base::PropertySet& prop, 
                             const std::string& name);

class PrinterFactory {
public: 
    typedef PrinterList* 
        (*factoryFuncPtr)(const lsst::daf::base::PropertySet&, const std::string&);
        
    PrinterFactory(bool loadDefaults=false) : _factFuncs() { 
        if (loadDefaults) _loadDefaults();
    }

    void add(const std::type_info& tp, factoryFuncPtr func) { 
        _factFuncs[tp.name()] = func; 
    }

    PrinterList* makePrinter(const lsst::daf::base::PropertySet& prop, 
                             const std::string& name) const 
    {
        Lookup::const_iterator fi = _factFuncs.find(prop.typeOf(name).name());
        return (fi == _factFuncs.end()) ? 0 : (*(fi->second))(prop, name);
    }

private:
    void _loadDefaults();

    typedef std::map<std::string, factoryFuncPtr> Lookup;
    Lookup _factFuncs;
};

class PropertyPrinter {
public:

    typedef PrinterList::iterator iterator;

    static PrinterFactory defaultPrinterFactory;

    PropertyPrinter(const lsst::daf::base::PropertySet& prop, const std::string& name, 
                    const PrinterFactory& fact=defaultPrinterFactory);

    iterator begin();

    iterator last();

    size_t valueCount() { return _list.get()->valueCount(); }


private:
    std::shared_ptr<PrinterList> _list;
};

}}}     // end lsst::pex::logging

#endif  // end LSST_PEX_PROPERTYPRINTER_H