PropertyHint.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_PROPERTYHINT_H_
#define _MIRA_PROPERTYHINT_H_

#include <assert.h>

#include <list>
#include <string>
#include <utility>

#include <utils/ToString.h>

namespace mira {


class PropertyHint
{
public:

    typedef std::list<std::pair<std::string, std::string>> AttributeValueList;

public:

    PropertyHint()  : mAttributes(NULL) {}

    PropertyHint(const std::string& attribute, const std::string& value) {
        mAttributes = new AttributeValueList;
        mAttributes->push_back(std::make_pair(attribute, value));
    }

    PropertyHint(PropertyHint&& other) noexcept : mAttributes(NULL) {
        std::swap(mAttributes, other.mAttributes);
    }

    ~PropertyHint() {
        delete mAttributes;
    }

public:

    AttributeValueList toList() const {
        return mAttributes ? *mAttributes : AttributeValueList();
    }

    void fromList(const AttributeValueList& list) {

        if(list.empty()) {
            delete mAttributes;
            mAttributes = NULL;
            return;
        }

        if(!mAttributes)
            mAttributes = new AttributeValueList;

        *mAttributes = list;
    }

public:

    PropertyHint& operator=(PropertyHint&& other) noexcept {
        std::swap(mAttributes, other.mAttributes);
        return *this;
    }


public:

    PropertyHint clone() const
    {
        PropertyHint copy;
        if(mAttributes!=NULL) {
            copy.mAttributes = new AttributeValueList;
            *copy.mAttributes = *mAttributes;
        }
        return copy;
    }

public:

    bool has(const std::string& attribute) const
    {
        if(mAttributes!=NULL) {
            for(auto it=mAttributes->begin(); it!=mAttributes->end(); ++it)
            {
                if(it->first==attribute)
                    return true;
            }
        }
        return false;
    }

    template <typename T>
    T get(const std::string& attribute, const T& defaultValue = T()) const
    {
        if(mAttributes!=NULL) {
            for(auto it=mAttributes->begin(); it!=mAttributes->end(); ++it)
            {
                if(it->first==attribute)
                    return fromString<T>(it->second);
            }
        }
        return defaultValue;
    }

public:

    friend PropertyHint operator|(PropertyHint&& hint, PropertyHint&& otherHint)
    {
        if(otherHint.mAttributes==NULL)
            return std::move(hint);

        if(hint.mAttributes==NULL) {
            std::swap(hint.mAttributes, otherHint.mAttributes);
            return std::move(hint);
        }

        assert(hint.mAttributes);
        assert(otherHint.mAttributes);

        // move attributes from otherHint to hint
        hint.mAttributes->splice(hint.mAttributes->begin(), *otherHint.mAttributes,
                otherHint.mAttributes->begin(), otherHint.mAttributes->end());
        return std::move(hint);
    }

private:
    PropertyHint(PropertyHint& other);
    PropertyHint& operator=(PropertyHint& other);

    AttributeValueList* mAttributes;
};

namespace PropertyHints {


template <typename T>
inline PropertyHint minimum(const T& min) {
    return PropertyHint("minimum",toString(min));
}

template <typename T>
inline PropertyHint maximum(const T& max) {
    return PropertyHint("maximum",toString(max));
}

template <typename T>
inline PropertyHint step(const T& step) {
    return PropertyHint("step",toString(step));
}

template <typename T>
inline PropertyHint limits(const T& min, const T& max) {
    return minimum<T>(min) | maximum<T>(max);
}

inline PropertyHint precision(int p) {
    return PropertyHint("precision", toString(p));
}

inline PropertyHint type(const std::string& t) {
    return PropertyHint("type", t);
}

inline PropertyHint enumeration(const std::string& values) {
    return PropertyHint("enumeration", values);
}

template <typename T>
inline PropertyHint slider(const T& min, const T& max, const T& s) {
    return type("slider") | limits<T>(min,max) | step<T>(s);
}

template <typename T>
inline PropertyHint spin(const T& min, const T& max, const T& s) {
    return type("spin") | limits<T>(min,max) | step<T>(s);
}


} // namespace


} // namespace

#endif /* _MIRA_PROPERTYHINT_H_ */