/*!
* Returns the element for the pair (p1, p2), either by retrieving an
* existing element (see \ref retrieveElement) or by creating a new one, if
* no element for that pair exists yet.
*
* \return Either the value of \ref retrieveElement or a new element for
* (p1,p2), if \ref retrieveElement returns NULL.
*/
CollisionCacheElement* CollisionCache::retrieveOrAddElement(Proxy* p1, Proxy* p2) {
if (!p1) {
throw NullPointerException("p1");
}
if (!p2) {
throw NullPointerException("p2");
}
CollisionCacheElement* element = retrieveElement(p1, p2);
if (element) {
return element;
}
element = new CollisionCacheElement(p1, p2);
element->mCachePosition1 = mMap.insert(std::make_pair(p1, element));
//insert the second element only for non-selfcollisions
if (p1 != p2) {
element->mCachePosition2 = mMap.insert(std::make_pair(p2, element));
} else {
element->mCachePosition2 = element->mCachePosition1;
}
return element;
}
std::istream& RouteCost::load(std::istream& input)
{
// if (CityMap::Instance().fileLength < 5*sizeof(int)) {
// throw NullPointerException();
// }
// CityMap::Instance().fileLength -= 5*sizeof(int);
char intBuf[sizeof(int)];
memset(intBuf,0,sizeof(int));
input.read(intBuf, sizeof(int));
moneyCost = *(reinterpret_cast<int*>(intBuf));
std::cout << "read moneyCost "<<moneyCost<<std::endl;
int hour,min,sec;
input.read(intBuf, sizeof(int));
hour = *(reinterpret_cast<int*>(intBuf));
input.read(intBuf, sizeof(int));
min = *(reinterpret_cast<int*>(intBuf));
input.read(intBuf, sizeof(int));
sec = *(reinterpret_cast<int*>(intBuf));
this->timeCost = QTime(hour, min, sec);
std::cout << "read time "<<hour<<" "<<min<<" "<<sec<<std::endl;
input.read(intBuf, sizeof(int));
unsigned int interestsCount = *(reinterpret_cast<int*>(intBuf));
interests = std::set<Interest>();
if (interestsCount > 20) {
throw NullPointerException();
}
std::cout<<"read interests count "<<interestsCount << std::endl;
for (int i = 0; i < interestsCount; i++) {
input.read(intBuf, sizeof(int));
Interest interest = *(reinterpret_cast<Interest*>(intBuf));
interests.insert(interest);
}
input.read(intBuf, sizeof(int));
unsigned int transportsCount = *(reinterpret_cast<int*>(intBuf));
transports = std::set<Transport>();
if (transportsCount > 20) {
throw NullPointerException();
}
std::cout<<"read transports count "<<transportsCount << std::endl;
for (int i = 0; i < transportsCount; i++) {
input.read(intBuf, sizeof(int));
Transport transport = *(reinterpret_cast<Transport*>(intBuf));
transports.insert((Transport) transport);
}
return input;
}
/** Add one thread.
* Add the given thread to the thread manager. The thread is initialized
* as appropriate and started. See the class documentation for supported
* specialisations of threads and the performed initialisation steps.
* If the thread initializer cannot initalize the thread it is not added.
* @param thread thread to add
* @param lock if true the environment is locked before adding the thread
* @exception CannotInitializeThreadException thrown if at least the
* thread could not be initialised
*/
void
ThreadManager::add_maybelocked(Thread *thread, bool lock)
{
if ( thread == NULL ) {
throw NullPointerException("FawkesThreadMananger: cannot add NULL as thread");
}
if ( ! (__initializer && __finalizer) ) {
throw NullPointerException("ThreadManager: initializer/finalizer not set");
}
try {
__initializer->init(thread);
} catch (CannotInitializeThreadException &e) {
thread->notify_of_failed_init();
e.append("Adding thread in ThreadManager failed");
throw;
}
// if the thread's init() method fails, we need to finalize that very
// thread only with the finalizer, already initialized threads muts be
// fully finalized
try {
thread->init();
} catch (CannotInitializeThreadException &e) {
thread->notify_of_failed_init();
__finalizer->finalize(thread);
throw;
} catch (Exception &e) {
thread->notify_of_failed_init();
CannotInitializeThreadException
cite("Could not initialize thread '%s'", thread->name());
cite.append(e);
__finalizer->finalize(thread);
throw cite;
} catch (std::exception &e) {
thread->notify_of_failed_init();
CannotInitializeThreadException
cite("Could not initialize thread '%s'", thread->name());
cite.append("Caught std::exception or derivative: %s", e.what());
__finalizer->finalize(thread);
throw cite;
} catch (...) {
thread->notify_of_failed_init();
CannotInitializeThreadException
cite("Could not initialize thread '%s'", thread->name());
cite.append("Unknown exception caught");
__finalizer->finalize(thread);
throw cite;
}
thread->start();
MutexLocker locker(__threads.mutex(), lock);
internal_add_thread(thread);
}
void BvHierarchyAlgorithm::translateProxy(Proxy* proxy, const Vector3& translateBy) {
if (!proxy) {
throw NullPointerException("proxy");
}
BvHierarchyProxyData* data = static_cast<BvHierarchyProxyData*>(proxy->getDetectorDeformProxyData(getProxyDataIndex()));
if (!data) {
throw NullPointerException("data");
}
data->mDeformableNode->translate(translateBy);
}
void BvHierarchyAlgorithm::deformProxy(Proxy* proxy, const std::vector<Vector3>& vertexMoveArray) {
if (!proxy) {
throw NullPointerException("proxy");
}
BvHierarchyProxyData* data = static_cast<BvHierarchyProxyData*>(proxy->getDetectorDeformProxyData(getProxyDataIndex()));
if (!data) {
throw NullPointerException("data");
}
DCOLLIDE_UNUSED(vertexMoveArray);
data->mDeformableNode->deform(/*vertexMoveArray*/);
}
void BvHierarchyAlgorithm::setProxyMatrix(Proxy* proxy, const Matrix& newMatrix) {
if (!proxy) {
throw NullPointerException("proxy");
}
BvHierarchyProxyData* data = static_cast<BvHierarchyProxyData*>(proxy->getDetectorDeformProxyData(getProxyDataIndex()));
if (!data) {
throw NullPointerException("data");
}
DCOLLIDE_UNUSED(newMatrix);
data->mDeformableNode->changeMatrix(/*newMatrix*/);
}
void BvHierarchyAlgorithm::rotateProxy(Proxy* proxy, const Matrix& rotation) {
if (!proxy) {
throw NullPointerException("proxy");
}
BvHierarchyProxyData* data = static_cast<BvHierarchyProxyData*>(proxy->getDetectorDeformProxyData(getProxyDataIndex()));
if (!data) {
throw NullPointerException("data");
}
DCOLLIDE_UNUSED(rotation);
data->mDeformableNode->rotate(/*rotation*/);
}
/*!
* Create \ref PipelineThreadJobCollection object that uses \p
* pipeline nd starts its jobs in \p phase (see \ref Pipeline::Phase).
*/
PipelineThreadJobCollection::PipelineThreadJobCollection(Pipeline* pipeline, Pipeline::Phase phase) {
mPipeline = pipeline;
if (!mPipeline) {
throw NullPointerException("mPipeline");
}
mPhase = phase;
}
/** Remove the given thread.
* The thread manager tries to finalize and stop the thread and then removes the
* thread from the internal structures.
*
* This may fail if the thread cannot be finalized, for
* example if prepare_finalize() returns false or if the thread finalizer cannot
* finalize the thread. In this case a CannotFinalizeThreadException is thrown.
*
* @param thread thread to remove.
* @exception CannotFinalizeThreadException At least one thread cannot be safely
* finalized
*/
void
ThreadManager::remove_maybelocked(Thread *thread, bool lock)
{
if ( thread == NULL ) return;
if ( ! (__initializer && __finalizer) ) {
throw NullPointerException("ThreadManager: initializer/finalizer not set");
}
MutexLocker locker(__threads.mutex(), lock);
try {
if ( ! thread->prepare_finalize() ) {
thread->cancel_finalize();
throw CannotFinalizeThreadException("Thread '%s'cannot be finalized", thread->name());
}
} catch (CannotFinalizeThreadException &e) {
e.append("ThreadManager cannot stop thread '%s'", thread->name());
thread->cancel_finalize();
throw;
}
thread->cancel();
thread->join();
__finalizer->finalize(thread);
thread->finalize();
internal_remove_thread(thread);
}
/** Add threads.
* Add the given threads to the thread manager. The threads are initialised
* as appropriate and started. See the class documentation for supported
* specialisations of threads and the performed initialisation steps.
* If the thread initializer cannot initalize one or more threads no thread
* is added. In this regard the operation is atomic, either all threads are
* added or none.
* @param tl thread list with threads to add
* @exception CannotInitializeThreadException thrown if at least one of the
* threads could not be initialised
*/
void
ThreadManager::add_maybelocked(ThreadList &tl, bool lock)
{
if ( ! (__initializer && __finalizer) ) {
throw NullPointerException("ThreadManager: initializer/finalizer not set");
}
if ( tl.sealed() ) {
throw Exception("Not accepting new threads from list that is not fresh, "
"list '%s' already sealed", tl.name());
}
tl.lock();
// Try to initialise all threads
try {
tl.init(__initializer, __finalizer);
} catch (Exception &e) {
tl.unlock();
throw;
}
tl.seal();
tl.start();
// All thread initialized, now add threads to internal structure
MutexLocker locker(__threads.mutex(), lock);
for (ThreadList::iterator i = tl.begin(); i != tl.end(); ++i) {
internal_add_thread(*i);
}
tl.unlock();
}
/** Run dialog and try to connect.
* This runs the service chooser dialog and connects to the given service
* with the attached FawkesNetworkClient. If the connection couldn't be established
* an error dialog is shown. You should not rely on the connection to be
* active after calling this method, rather you should use a ConnectionDispatcher
* to get the "connected" signal.
*/
void
ServiceChooserDialog::run_and_connect()
{
if (! __client) throw NullPointerException("FawkesNetworkClient not set");
if (__client->connected()) throw Exception("Client is already connected");
if ( run() ) {
try {
Glib::ustring name;
Glib::ustring hostname;
Glib::ustring ipaddr;
unsigned short int port;
get_selected_service(name, hostname, ipaddr, port);
if ( port == 0 ) port = 1910;
__client->connect(hostname.c_str(), ipaddr.c_str(), port);
} catch (Exception &e) {
Glib::ustring message = *(e.begin());
Gtk::MessageDialog md(__parent, message, /* markup */ false,
Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK,
/* modal */ true);
md.set_title("Connection failed");
md.run();
}
}
}
//==============================================================================
BufferedOutputStream::BufferedOutputStream(OutputStream* pOutputStream, size_t bufSize) :
m_rpOutputStream(pOutputStream)
{
if(!pOutputStream) throw NullPointerException();
init(bufSize ? bufSize : DefaultBufferSize);
}
/*!
* \brief Create a new BoundingVolume object.
*
* This method creates and returns a new BoundingVolume object, according to
* the preferred BoundingVolume-type settings.
*
* \param parent The BvhNode that the BoundingVolume should be in. See \ref
* setHierarchyNode.
*
* \return A new BoundingVolume object. The caller is responsible for
* deleting it.
*/
BoundingVolume* BoundingVolume::createBoundingVolume(World* world, BvhNode* parent) {
if (!world) {
throw NullPointerException("Parameter world");
}
BoundingVolume* bv = 0;
switch (getCreateRigidBoundingVolumeType(world)) {
case BV_TYPE_AABB:
bv = new Aabb();
break;
case BV_TYPE_KDOP:
bv = new Kdop();
break;
case BV_TYPE_SPHERE:
bv = new BoundingSphere();
break;
case BV_TYPE_OBB:
bv = new Obb();
break;
default:
// TODO: exception!!
std::cerr << dc_funcinfo << "FATAL ERROR: bounding volume type " << getCreateRigidBoundingVolumeType(world) << " not supported" << std::endl;
exit(1);
return 0;
}
bv->setHierarchyNode(parent);
return bv;
}
/*!
* Add \p job to the \ref ThreadPool, see \ref setPool.
*
* This method is NOT thread safe and assumes that it will always be called
* from the main thread only.
*/
void ThreadJobCollection::startJob(ThreadJob* job) {
if (!mThreadPool) {
throw NullPointerException("mThreadPool");
}
mThreadPool->addJob(job);
}
void Expression::addOperator(OperationCode *opcode, Token *token) {
if (!token) {
throw NullPointerException("Token cannot be nil");
}
if ((token->aType & Token::OPERATOR) == 0) {
throw InvalidTokenException("Expected an operator, got: " + token->token);
}
byte oper = 0;
string s = token->token;
if (s == "+") {
oper = OP_ADD;
} else if (s == "-") {
oper = OP_SUB;
} else if (s == "*") {
oper = OP_MUL;
} else if (s == "/") {
oper = OP_DIV;
} else if (s == "%") {
oper = OP_MOD;
} else {
throw NotImplementedException("Operator is not implemented: " + s);
}
opcode->addInterop(new ByteOperation(oper));
}
//==============================================================================
BufferedOutputStream::BufferedOutputStream(OutputStream* pOutputStream) :
m_rpOutputStream(pOutputStream)
{
if(!pOutputStream) throw NullPointerException();
init(DefaultBufferSize);
}
//==============================================================================
// SystemUtils::TestBufferIsValid
//
// Test that the passed buffer is appropriate for calls to read() operations.
//==============================================================================
void SystemUtils::TestBufferIsValid(const void* pBuffer, size_t& bufLen)
{
if(!pBuffer) throw NullPointerException();
if(!bufLen) throw IllegalArgumentException(QC_T("zero buffer length"));
if(bufLen > LONG_MAX)
bufLen = LONG_MAX;
}
//==============================================================================
void BufferedOutputStream::write(const Byte* pBuffer, size_t bufLen)
{
if(!pBuffer) throw NullPointerException();
if(!m_rpOutputStream) throw IOException(QC_T("stream closed"));
if(m_used + bufLen > m_bufferSize)
{
QC_DBG_ASSERT(m_pBuffer!=0);
// Write our buffer without flushing out the stream
writeBuffer();
QC_DBG_ASSERT(0 == m_used);
}
if(bufLen > m_bufferSize)
{
QC_DBG_ASSERT(0 == m_used);
m_rpOutputStream->write(pBuffer, bufLen);
}
else
{
QC_DBG_ASSERT(m_pBuffer!=0);
QC_DBG_ASSERT(bufLen + m_used <= m_bufferSize);
::memcpy(m_pBuffer+m_used, pBuffer, bufLen);
m_used+=bufLen;
}
}
void MultiInterventionEventCoordinator::DistributeInterventionsToNodes( INodeEventContext* event_context )
{
const json::Array & interventions_array = json::QuickInterpreter( intervention_config._json ).As<json::Array>();
LOG_DEBUG_F( "interventions array size = %d\n", interventions_array.Size() );
for( int idx = 0; idx < interventions_array.Size(); idx++ )
{
const json::Object& actualIntervention = json_cast<const json::Object&>(interventions_array[ idx ]);
Configuration * config = Configuration::CopyFromElement( actualIntervention );
assert( config );
LOG_DEBUG_F( "Attempting to instantiate intervention of class %s\n",
std::string( (*config)[ "class" ].As<json::String>() ).c_str() );
INodeDistributableIntervention *ndi = InterventionFactory::getInstance()->CreateNDIIntervention( config );
if( ndi == nullptr )
{
throw NullPointerException( __FILE__, __LINE__, __FUNCTION__, "Should have constructed a node-level intervention." );
}
if( ndi->Distribute( event_context, this ) )
{
LOG_INFO_F( "UpdateNodes() distributed '%s' intervention to node %d\n", ndi->GetName().c_str(), event_context->GetId().data );
}
ndi->Release();
delete config;
config = nullptr;
}
}
/** Register BB event listener.
* @param listener BlackBoard event listener to register
* @param flag flags what to register for
*/
void
BlackBoard::register_listener(BlackBoardInterfaceListener *listener, ListenerRegisterFlag flag)
{
if (!notifier_)
throw NullPointerException("BlackBoard initialized without notifier");
notifier_->register_listener(listener, flag);
}
void
DiagnosticTreatNeg::onPatientDefault()
{
LOG_DEBUG_F( "Individual %d got the test but defaulted, receiving Defaulters intervention without waiting for days_to_diagnosis (actually means days_to_intervention) \n", parent->GetSuid().data );
// Important: Use the instance method to obtain the intervention factory obj instead of static method to cross the DLL boundary
IGlobalContext *pGC = nullptr;
const IInterventionFactory* ifobj = nullptr;
if (s_OK == parent->QueryInterface(GET_IID(IGlobalContext), (void**)&pGC))
{
ifobj = pGC->GetInterventionFactory();
}
if (!ifobj)
{
throw NullPointerException( __FILE__, __LINE__, __FUNCTION__, "parent->GetInterventionFactoryObj()" );
}
if( !defaulters_event.IsUninitialized() )
{
if( defaulters_event != NO_TRIGGER_STR )
{
INodeTriggeredInterventionConsumer* broadcaster = nullptr;
if (s_OK != parent->GetEventContext()->GetNodeEventContext()->QueryInterface(GET_IID(INodeTriggeredInterventionConsumer), (void**)&broadcaster))
{
throw QueryInterfaceException( __FILE__, __LINE__, __FUNCTION__, "parent->GetEventContext()->GetNodeEventContext()", "INodeTriggeredInterventionConsumer", "INodeEventContext" );
}
broadcaster->TriggerNodeEventObserversByString( parent->GetEventContext(), defaulters_event );
}
}
else if( defaulters_config._json.Type() != ElementType::NULL_ELEMENT )
{
auto tmp_config = Configuration::CopyFromElement(defaulters_config._json);
// Distribute the defaulters intervention, right away (do not use the days_to_diagnosis
IDistributableIntervention *di = const_cast<IInterventionFactory*>(ifobj)->CreateIntervention( tmp_config );
delete tmp_config;
tmp_config = nullptr;
ICampaignCostObserver* pICCO;
// Now make sure cost of the test-positive intervention is reported back to node
if (s_OK == parent->GetEventContext()->GetNodeEventContext()->QueryInterface(GET_IID(ICampaignCostObserver), (void**)&pICCO) )
{
di->Distribute( parent->GetInterventionsContext(), pICCO );
pICCO->notifyCampaignEventOccurred( (IBaseIntervention*)di, (IBaseIntervention*)this, parent );
}
else
{
throw QueryInterfaceException( __FILE__, __LINE__, __FUNCTION__, "parent->GetEventContext()->GetNodeEventContext()", "ICampaignCostObserver", "INodeEventContext" );
}
}
else
{
throw GeneralConfigurationException( __FILE__, __LINE__, __FUNCTION__, "neither event or config defined" );
}
}
void vmtkImageFeature::BuildFWHMBasedFeatureImage(vtkImageData*originalData,vtkImageData* res)
{
log4cpp::Category& rootLog = log4cpp::Category::getRoot();
log4cpp::Category& subLog = log4cpp::Category::getInstance(std::string("sub1"));
if(res == 0||res->GetReferenceCount() < 1)
{
throw NullPointerException("BuildFWHMBasedFeatureImage(vtkImageData*originalData,vtkImageData* res)：res是空指针，请初始化");
}
rootLog.info("void vmtkImageFeature::BuildFWHMBasedFeatureImage(vtkImageData*originalData,vtkImageData* res) start......");
subLog.info("void vmtkImageFeature::BuildFWHMBasedFeatureImage(vtkImageData*originalData,vtkImageData* res) start.......");
vtkSmartPointer<vtkImageCast> cast = vtkSmartPointer<vtkImageCast>::New();
cast->SetInputData(originalData);
cast->SetOutputScalarTypeToFloat();
cast->Update();
vtkSmartPointer<vtkvmtkFWHMFeatureImageFilter> fwhmFeatureImageFilter = vtkSmartPointer<vtkvmtkFWHMFeatureImageFilter>::New();
//fwhmFeatureImageFilter->SetInputConnection(cast->GetOutputPort());
fwhmFeatureImageFilter->SetInputData(cast->GetOutput());
int _FWHMRadius[3];
for(int i = 0; i < 3;i++)
{
_FWHMRadius[i] = FWHMRadius[i];
}
fwhmFeatureImageFilter->SetRadius(_FWHMRadius);
fwhmFeatureImageFilter->SetBackgroundValue(FWHMBackgroundValue);
fwhmFeatureImageFilter->Update();
res->DeepCopy(fwhmFeatureImageFilter->GetOutput());
}
/** Unregister BB interface observer.
* This will remove the given BlackBoard event listener from any event that it was
* previously registered for.
* @param observer BlackBoard event listener to remove
*/
void
BlackBoard::unregister_observer(BlackBoardInterfaceObserver *observer)
{
if (! __notifier) throw NullPointerException("BlackBoard initialized without notifier");
if (! observer) return;
__notifier->unregister_observer(observer);
}
/** Unregister BB interface listener.
* This will remove the given BlackBoard interface listener from any
* event that it was previously registered for.
* @param listener BlackBoard event listener to remove
*/
void
BlackBoard::unregister_listener(BlackBoardInterfaceListener *listener)
{
if (! __notifier) throw NullPointerException("BlackBoard initialized without notifier");
if (! listener) return;
__notifier->unregister_listener(listener);
}
/*!
* \brief adjusts this bounding volume to an given shape
* (top-down processing)
*/
void BoundingVolume::adjustToShape(const Shape* shape) {
if (!shape) {
throw NullPointerException("Parameter \"const Shape* shape\"");
}
if (!shape->getProxy()) {
throw NullPointerException("shape->getProxy()");
}
Matrix worldState(shape->getProxy()->getWorldTransformation());
switch(shape->getShapeType()) {
case Shape::SHAPE_TYPE_BOX:
adjustToBox(&worldState,
static_cast<const Box*>(shape));
break;
case Shape::SHAPE_TYPE_CONE:
adjustToCone(&worldState,
static_cast<const Cone*>(shape));
break;
case Shape::SHAPE_TYPE_CYLINDER:
adjustToCylinder(&worldState,
static_cast<const Cylinder*>(shape));
break;
case Shape::SHAPE_TYPE_MESH:
adjustToMesh(static_cast<const Mesh*>(shape));
break;
case Shape::SHAPE_TYPE_MESH_PART:
adjustToMeshPart(static_cast<const MeshPart*>(shape));
break;
case Shape::SHAPE_TYPE_SPHERE:
adjustToSphere(&worldState,
static_cast<const Sphere*>(shape));
break;
case Shape::SHAPE_TYPE_WEDGE:
adjustToWedge(&worldState,
static_cast<const Wedge*>(shape));
break;
default:
throw UnsupportedShapeException(
"Cannot adjust Aabb to unknown Shape");
}
}
/** Wakeup threads and wait for them to finish.
* This assumes that all threads are in wait-for-wakeup mode. The threads are woken
* up with an internally maintained barrier. The method will return when all threads
* have finished one loop() iteration.
* @param timeout_sec timeout in seconds
* @param timeout_nanosec timeout in nanoseconds
* @exception NullPointerException thrown, if no internal barrier is maintained. Make sure
* you use the proper constructor.
*/
void
ThreadList::wakeup_and_wait(unsigned int timeout_sec, unsigned int timeout_nanosec)
{
if ( ! __wnw_barrier ) {
throw NullPointerException("ThreadList::wakeup_and_wait() can only be called if "
"barrier is maintained");
}
MutexLocker lock(mutex());
try {
wakeup_unlocked(__wnw_barrier);
} catch (Exception &e) {
throw;
}
if ( ! __wnw_barrier->wait(timeout_sec, timeout_nanosec) ) {
// timeout, we have a bad thread, flag it
RefPtr<ThreadList> passed_threads = __wnw_barrier->passed_threads();
ThreadList bad_threads;
for (iterator i = begin(); i != end(); ++i) {
if ((*i)->flagged_bad()) {
// thread is already flagged as bad, don't add it to bad_threads
continue;
}
bool ok = false;
for (iterator j = passed_threads->begin(); j != passed_threads->end(); ++j) {
if (*j == *i) {
ok = true;
break;
}
}
if (! ok) {
bad_threads.push_back(*i);
(*i)->set_flag(Thread::FLAG_BAD);
}
}
__wnw_bad_barriers.push_back(make_pair(__wnw_barrier, bad_threads));
__wnw_barrier = NULL;
update_barrier();
// Formulate exception
std::string s;
if ( bad_threads.size() > 1 ) {
s = "Multiple threads did not finish in time, flagging as bad: ";
for (iterator i = bad_threads.begin(); i != bad_threads.end(); ++i) {
s += std::string((*i)->name()) + " ";
}
} else if (bad_threads.size() == 0) {
s = "Timeout happened, but no bad threads recorded.";
} else {
throw Exception("Thread %s did not finish in time (max %f), flagging as bad",
bad_threads.front()->name(),
(float)timeout_sec + (float)timeout_nanosec / 1000000000.);
}
throw Exception("%s", s.c_str());
}
}
//==============================================================================
BufferedWriter::BufferedWriter(Writer* pWriter, size_t bufSize) :
m_rpWriter(pWriter)
{
if(!pWriter) throw NullPointerException();
m_rpLock = pWriter->getLock();
init(bufSize ? bufSize : DefaultBufferSize);
}
void Group::AddObserver(INotifiableSystem* pObserver)
{
if(!pObserver){
throw NullPointerException("Group::AddObserver", "Observer is null");
}
m_pObservers.push_back(pObserver);
}
/** Update BB event listener.
* @param listener BlackBoard event listener to update
* @param flag flags what to update for
*/
void
BlackBoard::update_listener(BlackBoardInterfaceListener *listener,
ListenerRegisterFlag flag)
{
if (! __notifier) throw NullPointerException("BlackBoard initialized without notifier");
if (! listener) return;
__notifier->update_listener(listener, flag);
}
/** Return payload size
* @return payload size
* @exception NullPointerException thrown if _payload does not point to a valid
* buffer or if _payload_size is zero.
*/
size_t
FawkesNetworkMessageContent::payload_size()
{
if ( (_payload == NULL) || (_payload_size == 0) ) {
throw NullPointerException("Payload in network message content may not be NULL");
}
return _payload_size;
}
