void Description::setVisualization(const VariantHandle & visualization) { if (! visualization.isValid()) throw WrongArgument("Visualization of a description must be a valid variant."); m_visualization = visualization; }
MatrixParameter::MatrixParameter(const unsigned int id, const VariantHandle& variant, ParameterGroup* const group) : Parameter(id, variant, group), m_rows(0), m_cols(0) { if(! variant.isVariant(Variant::MATRIX)) throw WrongArgument("The variant of a matrix parameter must be a matrix variant."); }
void ImageWrapper::validate(const unsigned int width, const unsigned int height, const unsigned int stride, const uint8_t*const data, const runtime::Image::PixelType pixelType) const { if(width == 0 || height == 0) return; // check row length if(width * depth(pixelType) * numChannels(pixelType) > stride) throw WrongArgument("Too small stride."); // check total data size unsigned int dataSize = stride * (height - 1) + width; if(data + dataSize > m_buffer + m_bufferSize) throw WrongArgument("Too small buffer."); }
DataContainerImpl::DataContainerImpl(Data* data) : m_readAccessCounter(0), m_writeAccess(false), m_recycleAccess(0), m_data(data) { if(! data) throw WrongArgument(); }
void OperatorKernel::setConnectorType(const unsigned int id, const Description::Type type, const Parameter::UpdateBehavior updateBehavior) { const Description* description = findDescription(id); if (description->originalType() == Description::PARAMETER) throw WrongArgument("Can not set the connector type of parameters which are not originally connectors."); switch (type) { case Description::INPUT: if (description->originalType() != Description::INPUT) throw WrongArgument("Descriptions can only be turned into inputs if their original type is INPUT."); break; case Description::OUTPUT: if (description->originalType() != Description::OUTPUT) throw WrongArgument("Descriptions can only be turned into outputs if their original type is OUTPUT."); break; case Description::PARAMETER: if (description->originalType() == Description::INPUT && updateBehavior == Description::PULL) { throw WrongArgument("Inputs can not be turned into pull parameters."); } if (description->originalType() == Description::OUTPUT && updateBehavior == Description::PUSH) { throw WrongArgument("Outputs can not be turned into push parameters."); } break; default: break; } m_typeMap[id] = type; m_behaviorMap[id] = updateBehavior; updateVisibleDescriptions(true); }
void Factory::registerData(const Data* data) { boost::lock_guard<boost::mutex> lock(m_mutex->mutex()); if(data == 0) { throw WrongArgument("Invalid argument: Null pointer."); } for(std::vector<const Data*>::iterator iter = m_dataTypes.begin(); iter != m_dataTypes.end(); ++iter) { if(data->type() == (*iter)->type() && data->package() == (*iter)->package()) { throw WrongArgument("Invalid argument: Data (" + data->package() + ", " + data->type() + ") has already been registered."); } } m_dataTypes.push_back(data); }
void Factory::registerOperator(const OperatorKernel*const op) { boost::lock_guard<boost::mutex> lock(m_mutex->mutex()); if(op == 0) { throw WrongArgument("Invalid argument: Null pointer."); } for(std::vector<const OperatorKernel*>::iterator iter = m_operators.begin(); iter != m_operators.end(); ++iter) { if(op->type() == (*iter)->type() && op->package() == (*iter)->package()) { throw WrongArgument("Invalid argument: Operator (" + op->package() + ", " + op->type() + ") has already been registered."); } } m_operators.push_back(op); }
const Description* OperatorKernel::findDescription(const unsigned int id) const { std::map<unsigned int, const Input*>::const_iterator inputIter = m_inputMap.find(id); if (inputIter != m_inputMap.end()) return inputIter->second; std::map<unsigned int, const Output*>::const_iterator outputIter = m_outputMap.find(id); if (outputIter != m_outputMap.end()) return outputIter->second; std::map<unsigned int, const Parameter*>::const_iterator parameterIter = m_parameterMap.find(id); if (parameterIter != m_parameterMap.end()) return parameterIter->second; throw WrongArgument("No description for ID exists for this operator."); }
void DataContainerImpl::getRecycleAccess(Recycler*const recycler) { if(! recycler) throw WrongArgument(); unique_lock_t lock(m_mutex); try { while(m_recycleAccess) m_cond.wait(lock); } catch(boost::thread_interrupted&) { throw Interrupt(); } m_recycleAccess = recycler; }
void OperatorKernel::validateDescriptions(const std::vector<const Input*>& inputs, const std::vector<const Output*>& outputs, const std::vector<const Parameter*>& parameters) { std::set<unsigned int> existingIds; std::set<unsigned int> newIds; std::set<const Parameter*> allParameters; // collect all existing IDs for(std::vector<const Input*>::const_iterator iter = m_inputs.begin(); iter != m_inputs.end(); ++iter) { existingIds.insert((*iter)->id()); } for(std::vector<const Output*>::const_iterator iter = m_outputs.begin(); iter != m_outputs.end(); ++iter) { existingIds.insert((*iter)->id()); } for(std::vector<const Parameter*>::const_iterator iter = m_parameters.begin(); iter != m_parameters.end(); ++iter) { existingIds.insert((*iter)->id()); allParameters.insert(*iter); } // collect all new IDs for(std::vector<const Input*>::const_iterator iter = inputs.begin(); iter != inputs.end(); ++iter) { if(newIds.count((*iter)->id())) throw WrongArgument("ID " + boost::lexical_cast<std::string>((*iter)->id()) + " appears twice."); newIds.insert((*iter)->id()); } for(std::vector<const Output*>::const_iterator iter = outputs.begin(); iter != outputs.end(); ++iter) { if(newIds.count((*iter)->id())) throw WrongArgument("ID " + boost::lexical_cast<std::string>((*iter)->id()) + " appears twice."); newIds.insert((*iter)->id()); } for(std::vector<const Parameter*>::const_iterator iter = parameters.begin(); iter != parameters.end(); ++iter) { if(newIds.count((*iter)->id())) throw WrongArgument("ID " + boost::lexical_cast<std::string>((*iter)->id()) + " appears twice."); newIds.insert((*iter)->id()); allParameters.insert(*iter); } // check if any of the new IDs matches an existing ID for(std::set<unsigned int>::const_iterator iter = newIds.begin(); iter != newIds.end(); ++iter) { if(existingIds.count(*iter)) throw WrongArgument("Descriptor with ID " + boost::lexical_cast<std::string>(*iter) + " has already been added."); } // check if all groups of the new parameters are part of this operator for(std::vector<const Parameter*>::const_iterator iter = parameters.begin(); iter != parameters.end(); ++iter) { if((*iter)->group()) { if(! allParameters.count((*iter)->group())) throw WrongArgument("Parameter with ID " + boost::lexical_cast<std::string>(*iter) + " references a group which has not been added to the operator."); } } }