PropertyList.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_DAF_BASE_PROPERTYLIST
#define LSST_DAF_BASE_PROPERTYLIST

 
#include <list>
#include <memory>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <vector>
 
#include "boost/any.hpp"
 
#include "lsst/base.h"
#include "lsst/daf/base/PropertySet.h"
 
namespace lsst {
namespace daf {
namespace base {
 
#if defined(__ICC)
#pragma warning(push)
#pragma warning(disable : 444)
#endif
 
class LSST_EXPORT PropertyList : public PropertySet {
public:
    // Typedefs
    typedef std::shared_ptr<PropertyList> Ptr;
    typedef std::shared_ptr<PropertyList const> ConstPtr;

    PropertyList();

    virtual ~PropertyList() noexcept;
 
    // Accessors

    virtual std::shared_ptr<PropertySet> deepCopy() const;
 
    // I can't make copydoc work for this so...
    template <typename T>
    T get(std::string const& name) const;
 
    // I can't make copydoc work for this so...
    template <typename T>
    T get(std::string const& name, T const& defaultValue) const;

    template <typename T>
    std::vector<T> getArray(std::string const& name) const;

    std::string const& getComment(std::string const& name) const;

    std::vector<std::string> getOrderedNames() const;

    std::list<std::string>::const_iterator begin() const;

    std::list<std::string>::const_iterator end() const;

    virtual std::string toString(bool topLevelOnly = false, std::string const& indent = "") const;
 
    // Modifiers

    template <typename T>
    void set(std::string const& name, T const& value);

    void set(std::string const& name, std::shared_ptr<PropertySet> const& value);

    template <typename T>
    void set(std::string const& name, std::vector<T> const& value);

    void set(std::string const& name, char const* value);

    template <typename T>
    void add(std::string const& name, T const& value);

    template <typename T>
    void add(std::string const& name, std::vector<T> const& value);

    void add(std::string const& name, char const* value);

    template <typename T>
    void set(std::string const& name, T const& value, std::string const& comment);

    template <typename T>
    void set(std::string const& name, std::vector<T> const& value, std::string const& comment);

    void set(std::string const& name, char const* value, std::string const& comment);

    template <typename T>
    void add(std::string const& name, T const& value, std::string const& comment);

    template <typename T>
    void add(std::string const& name, std::vector<T> const& value, std::string const& comment);

    void add(std::string const& name, char const* value, std::string const& comment);

    template <typename T>
    void set(std::string const& name, T const& value, char const* comment) {
        set(name, value, std::string(comment));
    }

    template <typename T>
    void set(std::string const& name, std::vector<T> const& value, char const* comment) {
        set(name, value, std::string(comment));
    }

    void set(std::string const& name, char const* value, char const* comment) {
        set(name, value, std::string(comment));
    }

    template <typename T>
    void add(std::string const& name, T const& value, char const* comment) {
        add(name, value, std::string(comment));
    }

    template <typename T>
    void add(std::string const& name, std::vector<T> const& value, char const* comment) {
        add(name, value, std::string(comment));
    }

    void add(std::string const& name, char const* value, char const* comment) {
        add(name, value, std::string(comment));
    }


    virtual void copy(std::string const& dest, PropertySet const & source, std::string const& name,
                      bool asScalar = false);


    virtual void combine(PropertySet const & source);

    virtual void remove(std::string const& name);
 
private:
 
    typedef std::unordered_map<std::string, std::string> CommentMap;
 
    virtual void _set(std::string const& name, std::shared_ptr<std::vector<std::any> > vp);
    virtual void _moveToEnd(std::string const& name);
    virtual void _commentOrderFix(std::string const& name, std::string const& comment);
 
    CommentMap _comments;
    std::list<std::string> _order;
};
 
#if defined(__ICC)
#pragma warning(pop)
#endif
}
}  // namespace daf
}  // namespace lsst
 
#endif