arg_list.h

Go to the documentation of this file.

/*
 *  OGF/Graphite: Geometry and Graphics Programming Library + Utilities
 *  Copyright (C) 2000 Bruno Levy
 *
 *  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 2 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 GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  If you modify this software, you should include a notice giving the
 *  name of the person performing the modification, the date of modification,
 *  and the reason for such modification.
 *
 *  Contact: Bruno Levy
 *
 *     levy@loria.fr
 *
 *     ISA Project
 *     LORIA, INRIA Lorraine, 
 *     Campus Scientifique, BP 239
 *     54506 VANDOEUVRE LES NANCY CEDEX 
 *     FRANCE
 *
 *  Note that the GNU General Public License does not permit incorporating
 *  the Software into proprietary programs. 
 */
 
#ifndef H_OGF_BASIC_TYPES_ARG_LIST_H
#define H_OGF_BASIC_TYPES_ARG_LIST_H
 
#include <OGF/gom/common/common.h>
#include <OGF/gom/types/any.h>
#include <geogram/basic/string.h>
#include <geogram/basic/memory.h>
#include <iostream>
#include <type_traits>
 
namespace OGF {
 
    class NameBase {
    };
    
    class GOM_API ArgList {
        
    public:
 
        ArgList() {
            argval_.reserve(4);
            argname_.reserve(4);
        }
 
        ArgList(const ArgList& rhs) :
           argval_(rhs.argval_), argname_(rhs.argname_) {
        }
 
        ArgList& operator=(const ArgList& rhs) {
            argval_ = rhs.argval_;
            argname_ = rhs.argname_;
            return *this;
        }
 
        index_t nb_args() const {
            return argname_.size();
        }
 
        bool has_unnamed_args() const {
            if(nb_args() == 0) {
                return false;
            }
            for(index_t i=0; i<nb_args(); ++i) {
                if(ith_arg_name(i) != "arg#" + String::to_string(i)) {
                    return false;
                }
            }
            return true;
        }
        
        bool has_arg(const std::string& name) const {
            return (find_arg_index(name) != index_t(-1));
        }
 
        index_t find_arg_index(const std::string& name) const;
 
        void delete_ith_arg(index_t index) {
            geo_debug_assert(index < nb_args());
            argval_.erase(argval_.begin()+index);
            argname_.erase(argname_.begin()+index);
        }
 
        const std::string& ith_arg_name(index_t i) const {
            geo_debug_assert(i < nb_args());
            return argname_[i];
        }
 
        template <class T> T ith_arg_value(index_t i) const {
            geo_debug_assert(i < nb_args());
            T result;
            if(
                !argval_[i].get_value(result) &&
                !get_name(argval_[i], result)
            ) {
                arg_type_error(i, typeid(T).name());
            }
            return result;
        }
 
        const Any& ith_arg_value(index_t i) const {
            geo_debug_assert(i < nb_args());
            return argval_[i];
        }
 
        Any& ith_arg_value(index_t i) {
            geo_debug_assert(i < nb_args());
            return argval_[i];
        }
        
        const Any& arg_value(const std::string& name) const {
            index_t i = find_arg_index(name);
            geo_debug_assert(i != index_t(-1));
            return argval_[i];
        }
 
         Any& arg_value(const std::string& name) {
            index_t i = find_arg_index(name);
            geo_debug_assert(i != index_t(-1));
            return argval_[i];
        }
 
        
        MetaType* ith_arg_type(index_t i) const {
            geo_debug_assert(i < nb_args());
            return argval_[i].meta_type();
        }
 
        Any& create_arg(const std::string& name) {
            geo_debug_assert(!has_arg(name));
            argval_.push_back(Any());
            argname_.push_back(name);
            return *(argval_.rbegin());
        }
 
        Any& create_unnamed_arg() {
            geo_debug_assert(nb_args() == 0 || has_unnamed_args());
            return create_arg("arg#" + String::to_string(nb_args()));
        }
        
        template <class T> void create_arg(
            const std::string& name, const T& value
        ) {
            geo_debug_assert(!has_arg(name));
            argval_.push_back(Any());
            argname_.push_back(name);
            argval_.rbegin()->set_value(value);
        }
 
        void create_arg(
            const std::string& name, const char* value
        ) {
            create_arg<std::string>(name, value);
        }
 
        void create_arg(
            const std::string& name, const Any& value
        ) {
            geo_debug_assert(!has_arg(name));
            argval_.push_back(value);
            argname_.push_back(name);
        }
        
        template <class T> void set_arg(
            const std::string& name, const T& value
        ) {
            index_t i = find_arg_index(name);
            if(i == index_t(-1)) {
                create_arg(name, value);
            } else {
                argval_[i].set_value(value);
            }
        }
 
        void set_arg(const std::string& name, const char* value) {
            set_arg<std::string>(name, value);
        }
 
 
        void set_arg(const std::string& name, const Any& value) {
            index_t i = find_arg_index(name);
            if(i == index_t(-1)) {
                create_arg(name, value);
            } else {
                argval_[i] = value;
            }
        }
        
        template<class T> void set_ith_arg(index_t i, const T& value) {
            geo_debug_assert(i < nb_args());
            argval_[i].set_value(value);
        }
 
        void set_ith_arg(index_t i, const char* value) {
            set_ith_arg<std::string>(i, value);
        }
        
        std::string get_arg(const std::string& name) const {
            index_t i = find_arg_index(name);
            geo_debug_assert(i != index_t(-1));
            return argval_[i].as_string();
        }
 
        template <class T> T get_arg(const std::string& name) const {
            index_t i = find_arg_index(name);
            geo_debug_assert(i != index_t(-1));
            T result;
            if(
                !argval_[i].get_value(result) &&
                !get_name(argval_[i], result)
            ) {
                arg_type_error(i, typeid(T).name());
            }
            return result;
        }
 
        MetaType* get_arg_type(const std::string& name) const {
            index_t i = find_arg_index(name);
            geo_debug_assert(i != index_t(-1));
            return argval_[i].meta_type();
        }
        
        void clear() {
            argval_.resize(0);
            argname_.resize(0);
        }
 
        void append(const ArgList& rhs, bool overwrite = true);
 
        void append_ith_arg(
            const ArgList& rhs, index_t i, bool overwrite = true
        );
 
        void serialize(std::ostream& out) const;
 
        void arg_type_error(
            index_t i, const std::string& expected_typeid_name
        ) const;
 
 
        template <class T> static bool get_name(const Any& argval, T& name) {
            if(!std::is_base_of<NameBase, T>::value) {
                return false;
            }
            Any name_prop;
            if(!get_object_name(argval, name_prop)) {
                return false;
            }
            return name_prop.get_value(name);
        }
 
        static bool get_object_name(const Any& object, Any& name);
 
        
    private:
        vector<Any> argval_;
        vector<std::string> argname_;
    };
 
 
    inline std::ostream& operator<<(std::ostream& out, const ArgList& args) {
        args.serialize(out);
        return out;
    }
}
 
#endif