(C) Zeriph Enterprises
omni/application.hpp
001:
002:
003:
004:
005:
006:
007:
008:
009:
010:
011:
012:
013:
014:
015:
016:
017:
018:
019:
020:
021:
022:
023:
024:
025:
026:
027:
028:
029:
030:
031:
032:
033:
034:
035:
036:
037:
038:
039:
040:
041:
042:
043:
044:
045:
046:
047:
048:
049:
050:
051:
052:
053:
054:
055:
056:
057:
058:
059:
060:
061:
062:
063:
064:
065:
066:
067:
068:
069:
070:
071:
072:
073:
074:
075:
076:
077:
078:
079:
080:
081:
082:
083:
084:
085:
086:
087:
088:
089:
090:
091:
092:
093:
094:
095:
096:
097:
098:
099:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602:
603:
604:
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645:
646:
647:
648:
649:
650:
651:
652:
653:
654:
Min/Max













































































































































































































































































































































































































































































































































































































































































/*
* 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_APPLICATION_HPP)
#define OMNI_APPLICATION_HPP 1
#include <omni/types/char_t.hpp>
#include <omni/delegate/0.hpp>
#include <omni/delegate/1.hpp>
#include <omni/argparser.hpp>
#include <omni/exception.hpp>
#include <omni/sync/threadpool.hpp>
#include <string>
#include <csignal>

namespace omni {
    namespace application {
        namespace signal_handler {
            typedef omni::delegate1<void, int> callback;
            
            void attach(const omni::application::signal_handler::callback& sig_func);
            
            void detach(const omni::application::signal_handler::callback& sig_func);
            
            void ignore(bool doignore);
        }
        
        namespace exit_handler {
            void attach(const omni::callback& exit_func);
            
            void detach(const omni::callback& exit_func);
        }
        
        namespace startup_handler {
            void attach(const omni::callback& start_func);
            
            void detach(const omni::callback& start_func);
        }
        
        namespace shutdown_handler {
            void attach(const omni::callback& shutdown_func);
            
            void detach(const omni::callback& shutdown_func);
        }
        
        namespace terminate_handler {
            void attach(const omni::callback& terminate_func);
            
            void detach(const omni::callback& terminate_func);
        }

        class run_type
        {
            public:
                typedef enum enum_t {
                    NONE = 0,
                    EXIT_WITH_WORK_THREAD = 1,
                    KILL_WORKER_ON_SIGNAL = 2
                } enum_t;

                static inline unsigned short COUNT()
                {
                    return 3;
                }

                static inline enum_t DEFAULT_VALUE()
                {
                    return NONE;
                }
                
                static std::string to_string(enum_t v)
                {
                    return _to_val<std::stringstream>(v);
                }
            
                static std::wstring to_wstring(enum_t v)
                {
                    return _to_val<std::wstringstream>(v);
                }

                static enum_t parse(const std::string& val)
                {
                    return _parse(val);
                }

                static enum_t parse(const std::wstring& val)
                {
                    return _parse(val);
                }

                static bool try_parse(const std::string& val, enum_t& out)
                {
                    return _try_parse(val, out);
                }

                static bool try_parse(const std::wstring& val, enum_t& out)
                {
                    return _try_parse(val, out);
                }

                static bool try_parse(const std::string& val, run_type& out)
                {
                    return _try_parse(val, out);
                }

                static bool try_parse(const std::wstring& val, run_type& out)
                {
                    return _try_parse(val, out);
                }

                static bool is_valid(int32_t val)
                {
                    return _valid(val);
                }
                
                run_type() :
                    OMNI_CTOR_FW(omni::application::run_type)
                    m_val(DEFAULT_VALUE())
                { }

                run_type(const run_type& cp) :
                    OMNI_CPCTOR_FW(cp)
                    m_val(cp.m_val)
                { }

                run_type(enum_t val) :
                    OMNI_CTOR_FW(omni::application::run_type)
                    m_val(val)
                { }

                run_type(int val) :
                    OMNI_CTOR_FW(omni::application::run_type)
                    m_val(static_cast<enum_t>(val))
                { }

                ~run_type()
                {
                    OMNI_TRY_FW
                    OMNI_DTOR_FW
                    OMNI_CATCH_FW
                    OMNI_D5_FW("destroyed");
                }
                
                unsigned short count()
                {
                    return COUNT();
                }
                
                enum_t value() const
                {
                    return this->m_val;
                }

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

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

                bool operator!=(const run_type& val) const
                {
                    return !(*this == val);
                }
                
                bool operator!=(enum_t val) const
                {
                    return (this->m_val != val);
                }
                
                run_type& operator=(const run_type& val)
                {
                    if (this != &val) {
                        OMNI_ASSIGN_FW(val)
                        this->m_val = val.m_val;
                    }
                    return *this;
                }

                run_type& operator=(enum_t val)
                {
                    this->m_val = val;
                    return *this;
                }

                run_type& operator=(int32_t val)
                {
                    if (!run_type::is_valid(val)) {
                        OMNI_ERR_RET_FW("Invalid enumeration value specified.", omni::exceptions::invalid_enum(val));
                    } else {
                        this->m_val = static_cast<enum_t>(val);
                    }
                    return *this;
                }

                run_type operator|(const run_type& val)
                {
                    return run_type(static_cast<enum_t>(this->m_val | val.m_val));
                }

                run_type operator|(enum_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val | val));
                }

                run_type operator|(int32_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val | val));
                }

                run_type& operator|=(const run_type& val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val | val.m_val);
                    return *this;
                }

                run_type& operator|=(enum_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val | val);
                    return *this;
                }

                run_type& operator|=(int32_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val | val);
                    return *this;
                }

                run_type operator&(const run_type& val)
                {
                    return run_type(static_cast<enum_t>(this->m_val & val.m_val));
                }

                run_type operator&(enum_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val & val));
                }

                run_type operator&(int32_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val & val));
                }

                run_type& operator&=(const run_type& val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val & val.m_val);
                    return *this;
                }

                run_type& operator&=(enum_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val & val);
                    return *this;
                }

                run_type& operator&=(int32_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val & val);
                    return *this;
                }
                
                run_type& operator++()
                {
                    this->m_val = static_cast<enum_t>(this->m_val + 1);
                    return *this;
                }

                run_type operator++(int dummy)
                {
                    OMNI_UNUSED(dummy);
                    run_type ret(this->m_val);
                    this->m_val = static_cast<enum_t>(this->m_val + 1);
                    return ret;
                }

                run_type& operator--()
                {
                    this->m_val = static_cast<enum_t>(this->m_val - 1);
                    return *this;
                }

                run_type operator--(int dummy)
                {
                    OMNI_UNUSED(dummy);
                    run_type ret(this->m_val);
                    this->m_val = static_cast<enum_t>(this->m_val - 1);
                    return ret;
                }

                run_type operator~()
                {
                    return run_type(static_cast<enum_t>(~static_cast<int32_t>(this->m_val)));
                }

                run_type operator^(const run_type& val)
                {
                    return run_type(static_cast<enum_t>(this->m_val ^ val.m_val));
                }

                run_type operator^(enum_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val ^ val));
                }

                run_type operator^(int32_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val ^ val));
                }

                run_type& operator^=(const run_type& val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val ^ val.m_val);
                    return *this;
                }

                run_type& operator^=(enum_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val ^ val);
                    return *this;
                }

                run_type& operator^=(int32_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val ^ val);
                    return *this;
                }

                run_type operator<<(const run_type& val)
                {
                    return run_type(static_cast<enum_t>(this->m_val << val.m_val));
                }

                run_type operator<<(enum_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val << val));
                }

                run_type operator<<(int32_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val << val));
                }

                run_type& operator<<=(const run_type& val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val << val.m_val);
                    return *this;
                }

                run_type& operator<<=(enum_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val << val);
                    return *this;
                }

                run_type& operator<<=(int32_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val << val);
                    return *this;
                }

                run_type operator>>(const run_type& val)
                {
                    return run_type(static_cast<enum_t>(this->m_val >> val.m_val));
                }

                run_type operator>>(enum_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val >> val));
                }

                run_type operator>>(int32_t val)
                {
                    return run_type(static_cast<enum_t>(this->m_val >> val));
                }

                run_type& operator>>=(const run_type& val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val >> val.m_val);
                    return *this;
                }

                run_type& operator>>=(enum_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val >> val);
                    return *this;
                }

                run_type& operator>>=(int32_t val)
                {
                    this->m_val = static_cast<enum_t>(this->m_val >> val);
                    return *this;
                }

                bool operator<(const run_type& val) const
                {
                    return this->m_val < val.m_val;
                }

                bool operator<(enum_t val) const
                {
                    return this->m_val < val;
                }

                bool operator<(int32_t val) const
                {
                    return this->m_val < static_cast<enum_t>(val);
                }

                bool operator>(const run_type& val) const
                {
                    return this->m_val > val.m_val;
                }

                bool operator>(enum_t val) const
                {
                    return this->m_val > val;
                }

                bool operator>(int32_t val) const
                {
                    return this->m_val > val;
                }

                bool operator==(const run_type& val) const
                {
                    if (this == &val) { return true; }
                    return this->m_val == val.m_val
                            OMNI_EQUAL_FW(val);
                }

                bool operator==(enum_t val) const
                {
                    return this->m_val == val;
                }

                bool operator==(int32_t val) const
                {
                    return this->m_val == val;
                }

                operator enum_t() const
                {
                    return this->m_val;
                }

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

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

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

                OMNI_OSTREAM_FW(omni::application::run_type)
                OMNI_OSTREAM_FN_FW(enum_t)

            private:
                enum_t m_val;

                template < typename S >
                static enum_t _parse(const S& val)
                {
                    enum_t ret;
                    if (_try_parse(val, ret)) { return ret; }
                    OMNI_ERR_FW("invalid enum parse", omni::exceptions::invalid_enum())
                    return DEFAULT_VALUE();
                }

                template < typename S >
                static bool _try_parse(const S& str, enum_t& out)
                {
                    return _try_parse(omni::string::util::to_upper(str), out);
                }

                template < typename S >
                static bool _try_parse(const S& val, run_type& out)
                {
                    enum_t tmp;
                    if (_try_parse(val, tmp)) {
                        out.m_val = tmp;
                        return true;
                    }
                    return false;
                }

                static bool _try_parse(const std::wstring& val, enum_t& out)
                {
                    return _try_parse(omni::string::util::to_string(val), out);
                }

                static bool _try_parse(const std::string& val, enum_t& out)
                {
                    if (!val.empty()) {
                        OMNI_S2E_FW(NONE)
                        OMNI_S2E_FW(EXIT_WITH_WORK_THREAD)
                        OMNI_S2E_FW(KILL_WORKER_ON_SIGNAL)
                    }
                    return false;
                }

                template < typename S >
                static std::basic_string< typename S::char_type > _to_val(enum_t v)
                {
                    S ss;
                    switch (v) {
                        OMNI_E2SS_FW(NONE);
                        OMNI_E2SS_FW(EXIT_WITH_WORK_THREAD);
                        OMNI_E2SS_FW(KILL_WORKER_ON_SIGNAL);
                        default:
                            ss << "UNKNOWN (" << static_cast<int>(v) << ")";
                            break;
                    }
                    return ss.str();
                }

                static bool _valid(int32_t val)
                {
                    return (
                        OMNI_I2EV_FW(NONE) ||
                        OMNI_I2EV_FW(EXIT_WITH_WORK_THREAD) ||
                        OMNI_I2EV_FW(KILL_WORKER_ON_SIGNAL)
                    );
                }
        };
        
        omni::application::argparser& args();
        
        inline uint32_t bit_width()
        { return OMNI_SIZEOF_BITS(char*); }
        
        void exit(int exit_status);
        
        inline void exit()
        { omni::application::exit(0); }
        
        int last_signal();
        
        int run();

        int run(const int& argc, const char** argv);

        int run(const int& argc, const wchar_t** argv);
        
        int run(const omni::sync::thread_start& start_func);
        
        int run(const omni::sync::thread_start& start_func, bool exit_with_work_thread);
        
        int run(const omni::sync::thread_start& start_func, bool exit_with_work_thread, bool kill_worker_on_signal);

        inline int run(const omni::sync::thread_start& start_func, const omni::application::run_type& run_type)
        {
            return omni::application::run(start_func,
                (run_type & omni::application::run_type::EXIT_WITH_WORK_THREAD),
                (run_type & omni::application::run_type::KILL_WORKER_ON_SIGNAL)
            );
        }

        int run(const int& argc, const char** argv, const omni::sync::thread_start& start_func, bool exit_with_work_thread);
        
        int run(const int& argc, const char** argv, const omni::sync::thread_start& start_func, bool exit_with_work_thread, bool kill_worker_on_signal);
        
        inline int run(const int& argc, const char** argv, const omni::sync::thread_start& start_func, const omni::application::run_type& run_type)
        {
            return omni::application::run(argc, argv, start_func,
                (run_type & omni::application::run_type::EXIT_WITH_WORK_THREAD),
                (run_type & omni::application::run_type::KILL_WORKER_ON_SIGNAL)
            );
        }

        int run(const int& argc, const wchar_t** argv, const omni::sync::thread_start& start_func, bool exit_with_work_thread);
        
        int run(const int& argc, const wchar_t** argv, const omni::sync::thread_start& start_func, bool exit_with_work_thread, bool kill_worker_on_signal);

        inline int run(const int& argc, const wchar_t** argv, const omni::sync::thread_start& start_func, const omni::application::run_type& run_type)
        {
            return omni::application::run(argc, argv, start_func,
                (run_type & omni::application::run_type::EXIT_WITH_WORK_THREAD),
                (run_type & omni::application::run_type::KILL_WORKER_ON_SIGNAL)
            );
        }

        int run(const omni::sync::parameterized_thread_start& start_func);
        
        int run(const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs);
        
        int run(const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs, bool exit_with_work_thread);
        
        int run(const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs, bool exit_with_work_thread, bool kill_worker_on_signal);
        
        inline int run(const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs, const omni::application::run_type& run_type)
        {
            return omni::application::run(start_func, targs,
                (run_type & omni::application::run_type::EXIT_WITH_WORK_THREAD),
                (run_type & omni::application::run_type::KILL_WORKER_ON_SIGNAL)
            );
        }

        int run(const int& argc, const char** argv, const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs, bool exit_with_work_thread);
        
        int run(const int& argc, const char** argv, const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs, bool exit_with_work_thread, bool kill_worker_on_signal);

        inline int run(const int& argc, const char** argv, const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs, const omni::application::run_type& run_type)
        {
            return omni::application::run(argc, argv, start_func, targs,
                (run_type & omni::application::run_type::EXIT_WITH_WORK_THREAD),
                (run_type & omni::application::run_type::KILL_WORKER_ON_SIGNAL)
            );
        }
        
        int run(const int& argc, const wchar_t** argv, const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs, bool exit_with_work_thread);
        
        int run(const int& argc, const wchar_t** argv, const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs, bool exit_with_work_thread, bool kill_worker_on_signal);

        inline int run(const int& argc, const wchar_t** argv, const omni::sync::parameterized_thread_start& start_func, omni::generic_ptr targs, const omni::application::run_type& run_type)
        {
            return omni::application::run(argc, argv, start_func, targs,
                (run_type & omni::application::run_type::EXIT_WITH_WORK_THREAD),
                (run_type & omni::application::run_type::KILL_WORKER_ON_SIGNAL)
            );
        }
        
        void set_return_code(int return_code);
        
        void set_args(int argc, const char** argv);
        
        void set_args(int argc, const wchar_t** argv);
        
        void stop();
    }
}

#endif // OMNI_APPLICATION_HPP