OptionHandler.hpp

Go to the documentation of this file.

/*
# Copyright (c) 2014-2016, NVIDIA CORPORATION. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#  * Neither the name of NVIDIA CORPORATION nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef NVXIO_OPTIONHANDLER_HPP
#define NVXIO_OPTIONHANDLER_HPP

#include <NVXIO/Export.hpp>

#include "Range.hpp"

namespace nvxio
{
class NVXIO_EXPORT OptionHandler
{
private:
    template <typename T>
    struct PairList
    {
        typedef std::initializer_list<std::pair<std::string, T>> type;
    };

public:
    typedef std::unique_ptr<OptionHandler> ptr;

    virtual ~OptionHandler();

    virtual std::string getPlaceholder() const = 0;

    virtual std::string getConstraintString() const;

    virtual std::string getDefaultString() const = 0;

    virtual std::string processValue(const std::string &valueStr) const = 0;

    static ptr string(std::string *result);

    static ptr integer(int *result, const Range<int> &validRange = ranges::all<int>());

    static ptr unsignedInteger(unsigned *result, const Range<unsigned> &validRange = ranges::all<unsigned>());

    static ptr real(float *result, const Range<float> &validRange = ranges::all<float>());

    static ptr real(double *result, const Range<double> &validRange = ranges::all<double>());

    static ptr oneOf(std::string *result, std::initializer_list<std::string> allowedValues);

    template <typename T, typename It>
    static ptr oneOf(T *result, It first, It last);

    /* The roundabout way of specifying the second parameter's type is due to an apparent bug in VC++ 2013.
       If specified directly as std::initializer_list<std::pair<std::string, T>>, VC++ insists on deducing
       T from the second argument, and fails. Indirecting it through a metafunction like this is enough to
       persuade it to deduce T from the first argument instead. */
    template <typename T>
    static ptr oneOf(T *result, typename PairList<T>::type allowedValues);
};

}

#include "detail/OptionHandler.hpp"

#endif // NVXIO_OPTIONHANDLER_HPP