Omni C++ Framework - queue

queue_timer.cpp


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:











































































































































































































































































































/*
 * This file is part of the Omni C++ framework

 * 

 * Copyright (c) 2016, Zeriph Enterprises, LLC

 * 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 Zeriph, Zeriph Enterprises, LLC, 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 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.

 */

#include <omni/chrono/queue_timer.hpp>

#include <omni/defs/timer_def.hpp>



#if defined(OMNI_SAFE_QUEUE_TIMER)

    #include <omni/sync/scoped_lock.hpp>

    #define OMNI_SAFE_QTMQMTX_FW OMNI_SAFE_TCTRMTX_FW m_qmtx(),

    #define OMNI_TMR_ALOCK_FW    OMNI_TMRALOCK_FW

    #define OMNI_TMR_MLOCK_FW    OMNI_TMRLOCK_FW

    #define OMNI_TMR_ULOCK_FW    OMNI_TMRUNLOCK_FW

#else

    #define OMNI_SAFE_QTMQMTX_FW

    #define OMNI_TMR_ALOCK_FW

    #define OMNI_TMR_MLOCK_FW

    #define OMNI_TMR_ULOCK_FW

#endif



#define OMNI_TIMER_T_FW queue_timer

#define OMNI_TIMER_EX_STOP_FW if (this->m_qthread != OMNI_NULL) { delete this->m_qthread; this->m_qthread = OMNI_NULL; }

#define OMNI_TIMER_EX_RUN_BEG_FW this->m_qthread = new omni::sync::basic_thread(omni::sync::thread_start::bind< omni::chrono::queue_timer, &omni::chrono::queue_timer::_run_queued >(this), omni::sync::thread_start_type::USER);   

// this->m_qmtx.lock();  if (!this->m_que.empty()) { this->m_que.clear(); } this->m_qmtx.unlock();

#define OMNI_TIMER_EX_RUN_END_FW this->m_qthread->join(); delete this->m_qthread; this->m_qthread = OMNI_NULL;

#include <omni/xx/timer.hxx>



omni::chrono::queue_timer::queue_timer() : 

    state_object(),

    tick(),

    OMNI_CTOR_FW(omni::chrono::queue_timer)

    OMNI_SAFE_QTMQMTX_FW

    m_que(),

    m_thread(OMNI_NULL),

    m_qthread(OMNI_NULL),

    m_int(100),

    m_auto(true),

    m_isrun(false),

    m_stopreq(false)

{

    OMNI_DV5_FW("created with interval of ", this->m_int);

}



omni::chrono::queue_timer::queue_timer(const omni::chrono::queue_timer& cp) : 

    state_object(),

    tick(),

    OMNI_CPCTOR_FW(cp)

    OMNI_SAFE_QTMQMTX_FW

    m_que(cp.m_que),

    m_thread(OMNI_NULL),

    m_qthread(OMNI_NULL),

    m_int(cp.m_int),

    m_auto(cp.m_auto),

    m_isrun(cp.m_isrun),

    m_stopreq(cp.m_stopreq)

{

    #if defined(OMNI_SAFE_QUEUE_TIMER)

        cp.m_mtx.lock();

        cp.m_qmtx.lock();

    #endif

    this->state_object = cp.state_object;

    this->tick = cp.tick;

    this->m_que = cp.m_que;

    this->m_int = cp.m_int;

    this->m_auto = cp.m_auto;

    if (cp.m_isrun && !cp.m_stopreq) { this->start(); }

    #if defined(OMNI_SAFE_QUEUE_TIMER)

        cp.m_qmtx.unlock();

        cp.m_mtx.unlock();

    #endif

    OMNI_D5_FW("copied");

}



omni::chrono::queue_timer::queue_timer(std::size_t interval_ms) : 

    state_object(),

    tick(),

    OMNI_CTOR_FW(omni::chrono::queue_timer)

    OMNI_SAFE_QTMQMTX_FW

    m_que(),

    m_thread(OMNI_NULL),

    m_qthread(OMNI_NULL),

    m_int(interval_ms),

    m_auto(true),

    m_isrun(false),

    m_stopreq(false)

{

    OMNI_DV5_FW("created with interval of ", this->m_int);

}



omni::chrono::queue_timer::queue_timer(std::size_t interval_ms, const omni::chrono::timer_delegate& fn) : 

    state_object(),

    tick(fn),

    OMNI_CTOR_FW(omni::chrono::queue_timer)

    OMNI_SAFE_QTMQMTX_FW

    m_que(),

    m_thread(OMNI_NULL),

    m_qthread(OMNI_NULL),

    m_int(interval_ms),

    m_auto(true),

    m_isrun(false),

    m_stopreq(false)

{

    OMNI_DV5_FW("created with interval of ", this->m_int);

}



omni::chrono::queue_timer::queue_timer(std::size_t interval_ms,

                           const omni::chrono::timer_delegate& fn,

                           bool autoreset) : 

    state_object(),

    tick(fn),

    OMNI_CTOR_FW(omni::chrono::queue_timer)

    OMNI_SAFE_QTMQMTX_FW

    m_que(),

    m_thread(OMNI_NULL),

    m_qthread(OMNI_NULL),

    m_int(interval_ms),

    m_auto(autoreset),

    m_isrun(false),

    m_stopreq(false)

{

    OMNI_DV5_FW("created with interval of ", this->m_int);

}



omni::chrono::queue_timer::queue_timer(std::size_t interval_ms,

                           const omni::chrono::timer_delegate& fn,

                           bool autoreset,

                           std::size_t delay) : 

    state_object(),

    tick(fn),

    OMNI_CTOR_FW(omni::chrono::queue_timer)

    OMNI_SAFE_QTMQMTX_FW

    m_que(),

    m_thread(OMNI_NULL),

    m_qthread(OMNI_NULL),

    m_int(interval_ms),

    m_auto(autoreset),

    m_isrun(false),

    m_stopreq(false)

{

    OMNI_DV5_FW("created with interval of ", this->m_int);

    this->start(delay);

}



omni::chrono::queue_timer& omni::chrono::queue_timer::operator=(const omni::chrono::queue_timer& other)

{

    if (this != &other) {

        this->stop();

        OMNI_ASSIGN_FW(other)

        #if defined(OMNI_SAFE_QUEUE_TIMER)

            this->m_mtx.lock();

            this->m_qmtx.lock();

            other.m_mtx.lock();

            other.m_qmtx.lock();

        #endif

        bool isrun = other.m_isrun;

        bool stopreq = other.m_stopreq;

        this->m_isrun = false;

        this->m_stopreq = false;

        this->state_object = other.state_object;

        this->tick = other.tick;

        this->m_int = other.m_int;

        this->m_que = other.m_que;

        this->m_auto = other.m_auto;

        #if defined(OMNI_SAFE_QUEUE_TIMER)

            other.m_qmtx.unlock();

            other.m_mtx.unlock();

            this->m_qmtx.unlock();

            this->m_mtx.unlock();

        #endif

        if (isrun && !stopreq) { this->start(); }

    }

    return *this;

}



bool omni::chrono::queue_timer::operator==(const omni::chrono::queue_timer &o) const

{

    if (this == &o) { return true; }

    #if defined(OMNI_SAFE_QUEUE_TIMER)

        omni::sync::scoped_lock<omni::sync::basic_lock> mlock(&this->m_mtx);

        omni::sync::scoped_lock<omni::sync::basic_lock> qlock(&this->m_qmtx);

        omni::sync::scoped_lock<omni::sync::basic_lock> omlock(&o.m_mtx);

        omni::sync::scoped_lock<omni::sync::basic_lock> oqlock(&o.m_qmtx);

    #endif

    return (this->state_object == o.state_object &&

            this->tick == o.tick &&

            this->m_que == o.m_que && 

            (((this->m_thread != OMNI_NULL) && (o.m_thread != OMNI_NULL)) ?

            (*this->m_thread == *o.m_thread)

            : (this->m_thread == o.m_thread)) &&

            (((this->m_qthread != OMNI_NULL) && (o.m_qthread != OMNI_NULL)) ?

            (*this->m_qthread == *o.m_qthread)

            : (this->m_qthread == o.m_qthread)) &&

            this->m_int == o.m_int &&

            this->m_auto == o.m_auto &&

            this->m_isrun == o.m_isrun &&

            this->m_stopreq == o.m_stopreq)

            OMNI_EQUAL_FW(o);

}



void omni::chrono::queue_timer::_do_tick()

{

    // queue up the event and spawn a thread to do the queue if necessary

    #if defined(OMNI_SAFE_QUEUE_TIMER)

        this->m_qmtx.lock();

    #endif

    omni::chrono::timer_args tea(omni::chrono::monotonic_tick(), this->state_object);

    this->m_que.push_back(tea);

    if (!this->m_qthread->is_alive()) {

        // restart the basic_thread (detach/start)

        this->m_qthread->detach();

        this->m_qthread->start();

    }

    #if defined(OMNI_SAFE_QUEUE_TIMER)

        this->m_qmtx.unlock();

    #endif

}



void omni::chrono::queue_timer::_run_queued()

{

    #if defined(OMNI_SAFE_QUEUE_TIMER)

        this->m_qmtx.lock();

        while (!this->m_que.empty()) {

            omni::chrono::timer_args arg(this->m_que.front());

            this->m_qmtx.unlock();

            if (this->tick) { this->tick(arg.signal_time, arg.state_object); }

            this->m_qmtx.lock();

            // don't pop until we're done

            this->m_que.pop_front();

        }

        this->m_qmtx.unlock();

    #else

        while (!this->m_que.empty()) {

            omni::chrono::timer_args arg(this->m_que.front());

            if (this->tick) { this->tick(arg.signal_time, arg.state_object); }

            // don't pop until we're done

            this->m_que.pop_front();

        }

    #endif

}



bool omni::chrono::queue_timer::_queue_empty() const

{

    #if defined(OMNI_SAFE_QUEUE_TIMER)

        omni::sync::scoped_lock<omni::sync::basic_lock> qlock(&this->m_qmtx);

    #endif

    return this->m_que.empty();

}



#undef OMNI_TIMER_T_FW

#undef OMNI_TMR_ALOCK_FW

#undef OMNI_TMR_MLOCK_FW

#undef OMNI_TMR_ULOCK_FW