-///////////////////////////////////////////////////////////////////////////////\r
-//\r
-// File : $Id: events.cpp,v 1.1 2007/05/05 17:00:42 faust Exp $\r
-// Subject : IBPP, internal EventsImpl class implementation\r
-//\r
-///////////////////////////////////////////////////////////////////////////////\r
-//\r
-// (C) Copyright 2000-2006 T.I.P. Group S.A. and the IBPP Team (www.ibpp.org)\r
-//\r
-// The contents of this file are subject to the IBPP License (the "License");\r
-// you may not use this file except in compliance with the License. You may\r
-// obtain a copy of the License at http://www.ibpp.org or in the 'license.txt'\r
-// file which must have been distributed along with this file.\r
-//\r
-// This software, distributed under the License, is distributed on an "AS IS"\r
-// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the\r
-// License for the specific language governing rights and limitations\r
-// under the License.\r
-//\r
-///////////////////////////////////////////////////////////////////////////////\r
-//\r
-// COMMENTS\r
-// * Tabulations should be set every four characters when editing this file.\r
-//\r
-// SPECIAL WARNING COMMENT (by Olivier Mascia, 2000 Nov 12)\r
-// The way this source file handles events is not publicly documented, in\r
-// the ibase.h header file or in the IB 6.0 documentation. This documentation\r
-// suggests to use the API isc_event_block to construct vectors of events.\r
-// Unfortunately, this API takes a variable number of parameters to specify\r
-// the list of event names. In addition, the documentation warn on not using\r
-// more than 15 names. This is a sad limitation, partly because the maximum\r
-// number of parameters safely processed in such an API is very compiler\r
-// dependant and also because isc_event_counts() is designed to return counts\r
-// through the IB status vector which is a vector of 20 32-bits integers !\r
-// From reverse engineering of the isc_event_block() API in\r
-// source file jrd/alt.c (as available on fourceforge.net/project/InterBase as\r
-// of 2000 Nov 12), it looks like the internal format of those EPB is simple.\r
-// An EPB starts by a byte with value 1. A version identifier of some sort.\r
-// Then a small cluster is used for each event name. The cluster starts with\r
-// a byte for the length of the event name (no final '\0'). Followed by the N\r
-// characters of the name itself (no final '\0'). The cluster ends with 4 bytes\r
-// preset to 0.\r
-//\r
-// SPECIAL CREDIT (July 2004) : this is a complete re-implementation of this\r
-// class, directly based on work by Val Samko.\r
-// The whole event handling has then be completely redesigned, based on the old\r
-// EPB class to bring up the current IBPP::Events implementation.\r
-//\r
-///////////////////////////////////////////////////////////////////////////////\r
-\r
-#ifdef _MSC_VER\r
-#pragma warning(disable: 4786 4996)\r
-#ifndef _DEBUG\r
-#pragma warning(disable: 4702)\r
-#endif\r
-#endif\r
-\r
-#include "_ibpp.h"\r
-\r
-#ifdef HAS_HDRSTOP\r
-#pragma hdrstop\r
-#endif\r
-\r
-using namespace ibpp_internals;\r
-\r
-const size_t EventsImpl::MAXEVENTNAMELEN = 127;\r
-\r
-// (((((((( OBJECT INTERFACE IMPLEMENTATION ))))))))\r
-\r
-void EventsImpl::Add(const std::string& eventname, IBPP::EventInterface* objref)\r
-{\r
- if (eventname.size() == 0)\r
- throw LogicExceptionImpl("Events::Add", _("Zero length event names not permitted"));\r
- if (eventname.size() > MAXEVENTNAMELEN)\r
- throw LogicExceptionImpl("Events::Add", _("Event name is too long"));\r
- if ((mEventBuffer.size() + eventname.length() + 5) > 32766) // max signed 16 bits integer minus one\r
- throw LogicExceptionImpl("Events::Add",\r
- _("Can't add this event, the events list would overflow IB/FB limitation"));\r
-\r
- Cancel();\r
-\r
- // 1) Alloc or grow the buffers\r
- size_t prev_buffer_size = mEventBuffer.size();\r
- size_t needed = ((prev_buffer_size==0) ? 1 : 0) + eventname.length() + 5;\r
- // Initial alloc will require one more byte, we need 4 more bytes for\r
- // the count itself, and one byte for the string length prefix\r
-\r
- mEventBuffer.resize(mEventBuffer.size() + needed);\r
- mResultsBuffer.resize(mResultsBuffer.size() + needed);\r
- if (prev_buffer_size == 0)\r
- mEventBuffer[0] = mResultsBuffer[0] = 1; // First byte is a 'one'. Documentation ??\r
-\r
- // 2) Update the buffers (append)\r
- {\r
- Buffer::iterator it = mEventBuffer.begin() +\r
- ((prev_buffer_size==0) ? 1 : prev_buffer_size); // Byte after current content\r
- *(it++) = static_cast<char>(eventname.length());\r
- it = std::copy(eventname.begin(), eventname.end(), it);\r
- // We initialize the counts to (uint32_t)(-1) to initialize properly, see FireActions()\r
- *(it++) = -1; *(it++) = -1; *(it++) = -1; *it = -1;\r
- }\r
-\r
- // copying new event to the results buffer to keep event_buffer_ and results_buffer_ consistant,\r
- // otherwise we might get a problem in `FireActions`\r
- // Val Samko, val@digiways.com\r
- std::copy(mEventBuffer.begin() + prev_buffer_size,\r
- mEventBuffer.end(), mResultsBuffer.begin() + prev_buffer_size);\r
-\r
- // 3) Alloc or grow the objref array and update the objref array (append)\r
- mObjectReferences.push_back(objref);\r
-\r
- Queue();\r
-}\r
-\r
-void EventsImpl::Drop(const std::string& eventname)\r
-{\r
- if (eventname.size() == 0)\r
- throw LogicExceptionImpl("EventsImpl::Drop", _("Zero length event names not permitted"));\r
- if (eventname.size() > MAXEVENTNAMELEN)\r
- throw LogicExceptionImpl("EventsImpl::Drop", _("Event name is too long"));\r
-\r
- if (mEventBuffer.size() <= 1) return; // Nothing to do, but not an error\r
-\r
- Cancel();\r
-\r
- // 1) Find the event in the buffers\r
- typedef EventBufferIterator<Buffer::iterator> EventIterator;\r
- EventIterator eit(mEventBuffer.begin()+1);\r
- EventIterator rit(mResultsBuffer.begin()+1);\r
-\r
- for (ObjRefs::iterator oit = mObjectReferences.begin();\r
- oit != mObjectReferences.end();\r
- ++oit, ++eit, ++rit)\r
- {\r
- if (eventname != eit.get_name()) continue;\r
- \r
- // 2) Event found, remove it\r
- mEventBuffer.erase(eit.begin(), eit.end());\r
- mResultsBuffer.erase(rit.begin(), rit.end());\r
- mObjectReferences.erase(oit);\r
- break;\r
- }\r
-\r
- Queue();\r
-}\r
-\r
-void EventsImpl::List(std::vector<std::string>& events)\r
-{\r
- events.clear();\r
- \r
- if (mEventBuffer.size() <= 1) return; // Nothing to do, but not an error\r
-\r
- typedef EventBufferIterator<Buffer::iterator> EventIterator;\r
- EventIterator eit(mEventBuffer.begin()+1);\r
-\r
- for (ObjRefs::iterator oit = mObjectReferences.begin();\r
- oit != mObjectReferences.end();\r
- ++oit, ++eit)\r
- {\r
- events.push_back(eit.get_name());\r
- }\r
-}\r
-\r
-void EventsImpl::Clear()\r
-{\r
- Cancel();\r
- \r
- mObjectReferences.clear();\r
- mEventBuffer.clear();\r
- mResultsBuffer.clear();\r
-}\r
-\r
-void EventsImpl::Dispatch()\r
-{\r
- // If no events registered, nothing to do of course.\r
- if (mEventBuffer.size() == 0) return;\r
-\r
- // Let's fire the events actions for all the events which triggered, if any, and requeue.\r
- FireActions();\r
- Queue();\r
-}\r
-\r
-IBPP::Database EventsImpl::DatabasePtr() const\r
-{\r
- if (mDatabase == 0) throw LogicExceptionImpl("Events::DatabasePtr",\r
- _("No Database is attached."));\r
- return mDatabase;\r
-}\r
-\r
-IBPP::IEvents* EventsImpl::AddRef()\r
-{\r
- ASSERTION(mRefCount >= 0);\r
- ++mRefCount;\r
- return this;\r
-}\r
-\r
-void EventsImpl::Release()\r
-{\r
- // Release cannot throw, except in DEBUG builds on assertion\r
- ASSERTION(mRefCount >= 0);\r
- --mRefCount;\r
- try { if (mRefCount <= 0) delete this; }\r
- catch (...) { }\r
-}\r
-\r
-// (((((((( OBJECT INTERNAL METHODS ))))))))\r
-\r
-void EventsImpl::Queue()\r
-{\r
- if (! mQueued)\r
- {\r
- if (mDatabase->GetHandle() == 0)\r
- throw LogicExceptionImpl("EventsImpl::Queue",\r
- _("Database is not connected"));\r
-\r
- IBS vector;\r
- mTrapped = false;\r
- mQueued = true;\r
- (*gds.Call()->m_que_events)(vector.Self(), mDatabase->GetHandlePtr(), &mId,\r
- short(mEventBuffer.size()), &mEventBuffer[0],\r
- (isc_callback)EventHandler, (char*)this);\r
-\r
- if (vector.Errors())\r
- {\r
- mId = 0; // Should be, but better be safe\r
- mQueued = false;\r
- throw SQLExceptionImpl(vector, "EventsImpl::Queue",\r
- _("isc_que_events failed"));\r
- }\r
- }\r
-}\r
-\r
-void EventsImpl::Cancel()\r
-{\r
- if (mQueued)\r
- {\r
- if (mDatabase->GetHandle() == 0) throw LogicExceptionImpl("EventsImpl::Cancel",\r
- _("Database is not connected"));\r
-\r
- IBS vector;\r
-\r
- // A call to cancel_events will call *once* the handler routine, even\r
- // though no events had fired. This is why we first set mEventsQueued\r
- // to false, so that we can be sure to dismiss those unwanted callbacks\r
- // subsequent to the execution of isc_cancel_events().\r
- mTrapped = false;\r
- mQueued = false;\r
- (*gds.Call()->m_cancel_events)(vector.Self(), mDatabase->GetHandlePtr(), &mId);\r
-\r
- if (vector.Errors())\r
- {\r
- mQueued = true; // Need to restore this as cancel failed\r
- throw SQLExceptionImpl(vector, "EventsImpl::Cancel",\r
- _("isc_cancel_events failed"));\r
- }\r
-\r
- mId = 0; // Should be, but better be safe\r
- }\r
-}\r
-\r
-void EventsImpl::FireActions()\r
-{\r
- if (mTrapped)\r
- {\r
- typedef EventBufferIterator<Buffer::iterator> EventIterator;\r
- EventIterator eit(mEventBuffer.begin()+1);\r
- EventIterator rit(mResultsBuffer.begin()+1);\r
-\r
- for (ObjRefs::iterator oit = mObjectReferences.begin();\r
- oit != mObjectReferences.end();\r
- ++oit, ++eit, ++rit)\r
- {\r
- if (eit == EventIterator(mEventBuffer.end())\r
- || rit == EventIterator(mResultsBuffer.end()))\r
- throw LogicExceptionImpl("EventsImpl::FireActions", _("Internal buffer size error"));\r
- uint32_t vnew = rit.get_count();\r
- uint32_t vold = eit.get_count();\r
- if (vnew > vold)\r
- {\r
- // Fire the action\r
- try\r
- {\r
- (*oit)->ibppEventHandler(this, eit.get_name(), (int)(vnew - vold));\r
- }\r
- catch (...)\r
- {\r
- std::copy(rit.begin(), rit.end(), eit.begin());\r
- throw;\r
- }\r
- std::copy(rit.begin(), rit.end(), eit.begin());\r
- }\r
- // This handles initialization too, where vold == (uint32_t)(-1)\r
- // Thanks to M. Hieke for this idea and related initialization to (-1)\r
- if (vnew != vold)\r
- std::copy(rit.begin(), rit.end(), eit.begin());\r
- }\r
- }\r
-}\r
-\r
-// This function must keep this prototype to stay compatible with\r
-// what isc_que_events() expects\r
-\r
-void EventsImpl::EventHandler(const char* object, short size, const char* tmpbuffer)\r
-{\r
- // >>>>> This method is a STATIC member !! <<<<<\r
- // Consider this method as a kind of "interrupt handler". It should do as\r
- // few work as possible as quickly as possible and then return.\r
- // Never forget: this is called by the Firebird client code, on *some*\r
- // thread which might not be (and won't probably be) any of your application\r
- // thread. This function is to be considered as an "interrupt-handler" of a\r
- // hardware driver.\r
-\r
- // There can be spurious calls to EventHandler from FB internal. We must\r
- // dismiss those calls.\r
- if (object == 0 || size == 0 || tmpbuffer == 0) return;\r
- \r
- EventsImpl* evi = (EventsImpl*)object; // Ugly, but wanted, c-style cast\r
-\r
- if (evi->mQueued)\r
- {\r
- try\r
- {\r
- char* rb = &evi->mResultsBuffer[0];\r
- if (evi->mEventBuffer.size() < (unsigned)size) size = (short)evi->mEventBuffer.size();\r
- for (int i = 0; i < size; i++)\r
- rb[i] = tmpbuffer[i];\r
- evi->mTrapped = true;\r
- evi->mQueued = false;\r
- }\r
- catch (...) { }\r
- }\r
-}\r
-\r
-void EventsImpl::AttachDatabaseImpl(DatabaseImpl* database)\r
-{\r
- if (database == 0) throw LogicExceptionImpl("EventsImpl::AttachDatabase",\r
- _("Can't attach a null Database object."));\r
-\r
- if (mDatabase != 0) mDatabase->DetachEventsImpl(this);\r
- mDatabase = database;\r
- mDatabase->AttachEventsImpl(this);\r
-}\r
-\r
-void EventsImpl::DetachDatabaseImpl()\r
-{\r
- if (mDatabase == 0) return;\r
-\r
- mDatabase->DetachEventsImpl(this);\r
- mDatabase = 0;\r
-}\r
-\r
-EventsImpl::EventsImpl(DatabaseImpl* database)\r
- : mRefCount(0)\r
-{\r
- mDatabase = 0;\r
- mId = 0;\r
- mQueued = mTrapped = false;\r
- AttachDatabaseImpl(database);\r
-}\r
-\r
-EventsImpl::~EventsImpl()\r
-{\r
- try { Clear(); }\r
- catch (...) { }\r
- \r
- try { if (mDatabase != 0) mDatabase->DetachEventsImpl(this); }\r
- catch (...) { }\r
-}\r
-\r
-//\r
-// EOF\r
-//\r
git.stg.codes / stg.git / blobdiff