Omni C++ Library - omni/argparser.hpp

omni/argparser.hpp


01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:

60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:

80:
81:
82:
83:
84:
































































































/*
 * Copyright (c), Zeriph Enterprises

 * All rights reserved.

 * 

 * Contributor(s):

 * Zechariah Perez, omni (at) zeriph (dot) com

 * 

 * THIS SOFTWARE IS PROVIDED BY ZERIPH AND CONTRIBUTORS "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 ZERIPH AND 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.

 */

#if !defined(OMNI_ARGPARSER_HPP)

#define OMNI_ARGPARSER_HPP 1

#include <omni/defs/class_macros.hpp>

#include <omni/sequence.hpp>

#include <omni/strings.hpp>

#include <omni/ostream.hpp>

#include <string>



namespace omni {

    namespace application {

        class argparser

        {

            public:

                argparser();

                argparser(const omni::application::argparser& cp);

                argparser(uint32_t ac, const char** av);

                argparser(uint32_t ac, const wchar_t** av);

                OMNI_EXPLICIT argparser(const omni::seq::std_string_t& av);

                OMNI_EXPLICIT argparser(const omni::seq::std_wstring_t& av);

                ~argparser();

                

                uint32_t argc() const { return static_cast<uint32_t>(this->m_argc); }

                omni::seq::string_t argv() const;

                omni::string_t at(uint32_t index) const;

                bool contains(const std::wstring& sw) const;

                bool contains(const std::string& sw) const;

                omni::string_t get_arg(uint32_t index) const;

                omni::string_t get_switch(const std::wstring& sw) const;

                omni::string_t get_switch(const std::string& sw) const;

                omni::seq::string_t get_switches(const omni::string_t& sw) const;

                uint32_t get_switch_count(const omni::string_t& sw) const;

                omni::seq::string_t get_range(std::size_t start, std::size_t end) const;

                std::size_t size() const { return static_cast<std::size_t>(this->m_argc); }

                void set(uint32_t ac, const char** av);

                void set(uint32_t ac, const wchar_t** av);

                void set(const omni::seq::string_t& av);

                omni::string_t to_string_t() const;

                omni::string_t to_string_t(bool include_first_arg) const;

                std::string to_string() const;

                std::string to_string(bool include_first_arg) const;

                std::wstring to_wstring() const;

                std::wstring to_wstring(bool include_first_arg) const;

                operator std::string() const { return this->to_string(false); }

                operator std::wstring() const { return this->to_wstring(false); }

                omni::string_t operator[](const std::string& sw) const;

                omni::string_t operator[](const std::wstring& sw) const;

                omni::string_t operator[](uint32_t index) const;

                omni::application::argparser& operator=(const omni::application::argparser& ap);

                bool operator==(const omni::application::argparser& o) const;

                bool operator!=(const omni::application::argparser& o) const;

                

                OMNI_MEMBERS_FW(omni::application::argparser) // disposing,name,type(),hash()



                OMNI_OSTREAM_FW(omni::application::argparser)

                

            private:

                omni::seq::string_t m_args;

                uint64_t m_argc;

                

                omni::seq::string_t::const_iterator _find(omni::seq::string_t::const_iterator it, const omni::string_t& f) const;

        };

    }

}



#endif // OMNI_ARGPARSER_HPP