C++ Watcher类代码示例

// Demultiplexing the I/O events
// Must be called in the loop thread.
int KqueueSelect::select(int timeout, WatcherList *activeList) {
    int ret = -1;
    ret = kevent(_kqueuefd, NULL, 0, _events, _evSize, NULL);
    if (ret == -1)
    {
        // EINTR indicates epoll_wait was interrupted by a signal handler before
        // any of the requested events occurred or the timeout expired.
        if (errno != EINTR)
        {
            return -1;
        }
        return 0;
    }
    
    // Check what of the reqeusted events occurred on the file descriptors.
    for (int i = 0; i < ret; ++i)
    {
        Watcher *w = (Watcher *)_events[i].udata;
        int events = 0;
        int filter = _events[i].filter;
        
        if (filter == EVFILT_READ)
        {
            events |= kReadEvent;
        }
        if (filter == EVFILT_WRITE)
        {
            events |= kWriteEvent;
        }
        
        w->setActiveEvents(events);
        activeList->push_back(w);
    }
    return 0;
}

tABC_CC ABC_BridgeWatcherConnect(Wallet &self, tABC_Error *pError)
{
    tABC_CC cc = ABC_CC_Ok;
    tABC_GeneralInfo *ppInfo = NULL;
    const char *szServer = FALLBACK_OBELISK;

    Watcher *watcher = nullptr;
    ABC_CHECK_NEW(watcherFind(watcher, self));

    // Pick a server:
    if (isTestnet())
    {
        szServer = TESTNET_OBELISK;
    }
    else if (ABC_CC_Ok == ABC_GeneralGetInfo(&ppInfo, pError) &&
        0 < ppInfo->countObeliskServers)
    {
        ++gLastObelisk;
        if (ppInfo->countObeliskServers <= gLastObelisk)
            gLastObelisk = 0;
        szServer = ppInfo->aszObeliskServers[gLastObelisk];
    }

    // Connect:
    ABC_DebugLog("Wallet %s connecting to %s", self.id().c_str(), szServer);
    watcher->connect(szServer);

exit:
    ABC_GeneralFreeInfo(ppInfo);
    return cc;
}

void Watcher::notify(std::string name, std::string event) {
	Watchers& w = gWatchers[name];
	for (Watchers::iterator it=w.begin(); it!=w.end(); it++) {
		Watcher * rw = *it;
		rw->onEvent(name, event);
	}
}

tABC_CC ABC_BridgePrioritizeAddress(Wallet &self,
                                    const char *szAddress,
                                    tABC_Error *pError)
{
    tABC_CC cc = ABC_CC_Ok;
    bc::payment_address addr;

    Watcher *watcher = nullptr;
    ABC_CHECK_NEW(watcherFind(watcher, self));

    if (szAddress)
    {
        if (!addr.set_encoded(szAddress))
        {
            cc = ABC_CC_Error;
            ABC_DebugLog("Invalid szAddress %s\n", szAddress);
            goto exit;
        }
    }

    watcher->prioritize_address(addr);

exit:
    return cc;
}

int main(int argc, char *argv[])
{
	Watcher w;
	cout<<w.init((char *)"../../shared/", NULL)<<endl;
	w.watch();
	return 0;
}

/**
 * Filters a transaction list, removing any that aren't found in the
 * watcher database.
 * @param aTransactions The array to filter. This will be modified in-place.
 * @param pCount        The array length. This will be updated upon return.
 */
tABC_CC ABC_BridgeFilterTransactions(Wallet &self,
                                     tABC_TxInfo **aTransactions,
                                     unsigned int *pCount,
                                     tABC_Error *pError)
{
    tABC_CC cc = ABC_CC_Ok;
    tABC_TxInfo *const *end = aTransactions + *pCount;
    tABC_TxInfo *const *si = aTransactions;
    tABC_TxInfo **di = aTransactions;

    Watcher *watcher = nullptr;
    ABC_CHECK_NEW(watcherFind(watcher, self));

    while (si < end)
    {
        tABC_TxInfo *pTx = *si++;

        int height;
        bc::hash_digest txid;
        if (!bc::decode_hash(txid, pTx->szMalleableTxId))
            ABC_RET_ERROR(ABC_CC_ParseError, "Bad txid");
        if (watcher->get_tx_height(txid, height))
        {
            *di++ = pTx;
        }
        else
        {
            ABC_TxFreeTransaction(pTx);
        }
    }
    *pCount = di - aTransactions;

exit:
    return cc;
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Watcher w;
    w.show();
    
    return a.exec();
}

/**
 *  Callback method that is called when child process changes status
 *  @param  loop        The loop in which the event was triggered
 *  @param  watcher     Internal watcher object
 *  @param  revents     Events triggered
 */
static void onStatusChange(struct ev_loop *loop, ev_child *watcher, int revents)
{
    // retrieve the reader
    Watcher *object = (Watcher *)watcher->data;

    // call it
    object->invoke();
}

Status
bridgeWatcherStop(Wallet &self)
{
    Watcher *watcher = nullptr;
    ABC_CHECK(watcherFind(watcher, self));

    watcher->stop();

    return Status();
}

Status
bridgeWatcherDisconnect(Wallet &self)
{
    Watcher *watcher = nullptr;
    ABC_CHECK(watcherFind(watcher, self));

    watcher->disconnect();

    return Status();
}

Status
watcherSend(Wallet &self, StatusCallback status, DataSlice tx)
{
    Watcher *watcher = nullptr;
    ABC_CHECK(watcherFind(watcher, self));

    watcher->sendTx(status, tx);

    return Status();
}

Status
watcherSave(Wallet &self)
{
    Watcher *watcher = nullptr;
    ABC_CHECK(watcherFind(watcher, self));

    auto data = watcher->serialize();;
    ABC_CHECK(fileSave(data, watcherPath(self)));

    return Status();
}

tABC_CC ABC_BridgeWatcherDisconnect(Wallet &self, tABC_Error *pError)
{
    tABC_CC cc = ABC_CC_Ok;

    Watcher *watcher = nullptr;
    ABC_CHECK_NEW(watcherFind(watcher, self));

    watcher->disconnect();

exit:
    return cc;
}

static Status
watcherLoad(Wallet &self)
{
    Watcher *watcher = nullptr;
    ABC_CHECK(watcherFind(watcher, self));

    DataChunk data;
    ABC_CHECK(fileLoad(data, watcherPath(self)));
    if (!watcher->load(data))
        return ABC_ERROR(ABC_CC_Error, "Unable to load serialized watcher");

    return Status();
}

void Reactor_loop(Reactor self, int32_t to) {
	fd_t kqfd = self->poll.fileno;
	struct kevent events[MAXEVENT];
	void* fds[MAXEVENT];
	uint8_t wr_end, rd_begin;
	struct kevent* ev_end;
	Watcher wt;
	uint32_t* sig = &self->signal;
	struct timespec ts;
	struct timespec* timeout = NULL;
	if(to != -1) {
		time_t sec = to / 1000;
		long nsec  = (to - sec * 1000) * 1000000000;
		ts.tv_sec  = sec;
		ts.tv_nsec = nsec;
		timeout = &ts;
	}
	int32_t count;
	while(*sig == 0) {
		wr_end = 0;
		rd_begin = MAXEVENT;
		count =  kevent(kqfd, NULL, 0, events, MAXEVENT, timeout);
		if(count == -1) {
			if(errno == EINTR) {
				return;
			}
			perror("Reactor_loop");
			exit(-1);
		}

		ev_end = events + count;
		for(struct kevent* p = events; p < ev_end; ++p) {
			if(p->filter & EVFILT_WRITE) {
				fds[wr_end++] = p->udata;
			} else if(p->filter & EVFILT_READ) {
				fds[--rd_begin] = p->udata;
			}
		}

		for(uint8_t i = 0; i < wr_end; ++i) {
			wt = (Watcher)fds[i];
			wt->onCall(wt);
		}
		for(uint8_t i = rd_begin; i < MAXEVENT; ++i) {
			wt = (Watcher)fds[i];
			wt->onCall(wt);
		}
	}
}