orthanc: OrthancServer/Plugins/Engine/OrthancPlugins.cpp comparison

comparison OrthancServer/Plugins/Engine/OrthancPlugins.cpp @ 4204:318c16cfccab

cppcheck

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 17 Sep 2020 16:18:01 +0200
parents	2d5209153b32
children	3d6f14a05db1

comparison

equal deleted inserted replaced

-:4d42408da117
+:318c16cfccab
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
 }
 public:
-DicomWebBinaryFormatter(OrthancPluginDicomWebBinaryCallback callback) :
+explicit DicomWebBinaryFormatter(OrthancPluginDicomWebBinaryCallback callback) :
 oldCallback_(callback),
 newCallback_(NULL),
-newPayload_(NULL)
+newPayload_(NULL),
+currentMode_(DicomWebJsonVisitor::BinaryMode_Ignore)
 {
 }
 DicomWebBinaryFormatter(OrthancPluginDicomWebBinaryCallback2 callback,
 void* payload) :
 oldCallback_(NULL),
 newCallback_(callback),
-newPayload_(payload)
+newPayload_(payload),
+currentMode_(DicomWebJsonVisitor::BinaryMode_Ignore)
 {
 }
 virtual DicomWebJsonVisitor::BinaryMode Format(std::string& bulkDataUri,
 const std::vector<DicomTag>& parentTags,
 const std::vector<size_t>& parentIndexes,
 const DicomTag& tag,
-ValueRepresentation vr)
+ValueRepresentation vr) ORTHANC_OVERRIDE
 {
 if (oldCallback_ == NULL &&
 newCallback_ == NULL)
 {
 return DicomWebJsonVisitor::BinaryMode_InlineBinary;
 }
 }
 void Apply(char** target,
 bool isJson,
-ParsedDicomFile& dicom)
+const ParsedDicomFile& dicom)
 {
 DicomWebJsonVisitor visitor;
 visitor.SetFormatter(*this);
 dicom.Apply(visitor);
 MultipartState              multipartState_;
 std::string                 multipartSubType_;
 std::string                 multipartContentType_;
 std::string                 multipartFirstPart_;
 std::map<std::string, std::string>  multipartFirstHeaders_;
 public:
-PluginHttpOutput(HttpOutput& output) :
+explicit PluginHttpOutput(HttpOutput& output) :
 output_(output),
 logDetails_(false),
 multipartState_(MultipartState_None)
 {
 }
 private:
 _OrthancPluginChunkedRestCallback parameters_;
 boost::regex                      regex_;
 public:
-ChunkedRestCallback(_OrthancPluginChunkedRestCallback parameters) :
+explicit ChunkedRestCallback(_OrthancPluginChunkedRestCallback parameters) :
 parameters_(parameters),
 regex_(parameters.pathRegularExpression)
 {
 }
 assert(handler_ != NULL);
 parameters_.destructor(handler_);
 handler_ = NULL;
 }
-virtual StorageCommitmentFailureReason Lookup(const std::string& sopClassUid,
+virtual StorageCommitmentFailureReason Lookup(
-const std::string& sopInstanceUid)
+const std::string& sopClassUid,
+const std::string& sopInstanceUid) ORTHANC_OVERRIDE
 {
 assert(handler_ != NULL);
 OrthancPluginStorageCommitmentFailureReason reason =
 OrthancPluginStorageCommitmentFailureReason_Success;
 OrthancPluginErrorCode error = parameters_.lookup(
 };
 _OrthancPluginRegisterStorageCommitmentScpCallback  parameters_;
 public:
-StorageCommitmentScp(_OrthancPluginRegisterStorageCommitmentScpCallback parameters) :
+explicit StorageCommitmentScp(_OrthancPluginRegisterStorageCommitmentScpCallback parameters) :
 parameters_(parameters)
 {
 }
 virtual ILookupHandler* CreateStorageCommitment(
 private:
 boost::mutex::scoped_lock  lock_;
 ServerContext* context_;
 public:
-ServerContextLock(PImpl& that) :
+explicit ServerContextLock(PImpl& that) :
 lock_(that.contextMutex_),
 context_(that.context_)
 {
 if (context_ == NULL)
 {
 filtered_.reset();
 currentQuery_ = NULL;
 }
 public:
-WorklistHandler(OrthancPlugins& that) : that_(that)
+explicit WorklistHandler(OrthancPlugins& that) : that_(that)
 {
 Reset();
 }
 virtual void Handle(DicomFindAnswers& answers,
 const std::string& remoteIp,
 const std::string& remoteAet,
 const std::string& calledAet,
 ModalityManufacturer manufacturer)
 {
-static const char* LUA_CALLBACK = "IncomingWorklistRequestFilter";
+{
+static const char* LUA_CALLBACK = "IncomingWorklistRequestFilter";
-{
 PImpl::ServerContextLock lock(*that_.pimpl_);
 LuaScripting::Lock lua(lock.GetContext().GetLuaScripting());
 if (!lua.GetLua().IsExistingFunction(LUA_CALLBACK))
 {
 {
 currentQuery_.reset(NULL);
 }
 public:
-FindHandler(OrthancPlugins& that) : that_(that)
+explicit FindHandler(OrthancPlugins& that) : that_(that)
 {
 Reset();
 }
 virtual void Handle(DicomFindAnswers& answers,
 }
 public:
-MoveHandler(OrthancPlugins& that)
+explicit MoveHandler(OrthancPlugins& that)
 {
 boost::recursive_mutex::scoped_lock lock(that.pimpl_->invokeServiceMutex_);
 params_ = that.pimpl_->moveCallbacks_;
 if (params_.callback == NULL ||
 params_(params),
 errorDictionary_(errorDictionary)
 {
 }
-virtual bool ReadNextChunk(std::string& chunk)
+virtual bool ReadNextChunk(std::string& chunk) ORTHANC_OVERRIDE
 {
 if (params_.requestIsDone(params_.request))
 {
 return false;
 }
 errorDictionary_(errorDictionary)
 {
 }
 virtual void AddHeader(const std::string& key,
-const std::string& value)
+const std::string& value) ORTHANC_OVERRIDE
 {
 OrthancPluginErrorCode error = params_.answerAddHeader(params_.answer, key.c_str(), value.c_str());
 if (error != OrthancPluginErrorCode_Success)
 {
 throw OrthancException(static_cast<ErrorCode>(error));
 }
 }
 virtual void AddChunk(const void* data,
-size_t size)
+size_t size) ORTHANC_OVERRIDE
 {
 OrthancPluginErrorCode error = params_.answerAddChunk(params_.answer, data, size);
 if (error != OrthancPluginErrorCode_Success)
 {
 std::string               flatUri_;
 std::vector<std::string>  groups_;
 std::vector<const char*>  cgroups_;
 public:
-RestCallbackMatcher(const UriComponents& uri) :
+explicit RestCallbackMatcher(const UriComponents& uri) :
 flatUri_(Toolbox::FlattenUri(uri))
 {
 }
 bool IsMatch(const boost::regex& re)
 {
 private:
 const DicomInstanceToStore&  instance_;
 public:
-DicomInstanceFromCallback(const DicomInstanceToStore& instance) :
+explicit DicomInstanceFromCallback(const DicomInstanceToStore& instance) :
 instance_(instance)
 {
 }
 virtual bool CanBeFreed() const ORTHANC_OVERRIDE
 private:
 std::unique_ptr<ParsedDicomFile>  parsed_;
 DicomInstanceToStore              instance_;
 public:
-DicomInstanceFromTranscoded(IDicomTranscoder::DicomImage& transcoded) :
+explicit DicomInstanceFromTranscoded(IDicomTranscoder::DicomImage& transcoded) :
 parsed_(transcoded.ReleaseAsParsedDicomFile())
 {
 instance_.SetParsedDicomFile(*parsed_);
 instance_.SetOrigin(DicomInstanceOrigin::FromPlugins());
 }
 void OrthancPlugins::DrawText(const void* parameters)
 {
 const _OrthancPluginDrawText& p = *reinterpret_cast<const _OrthancPluginDrawText*>(parameters);
-ImageAccessor& target = *reinterpret_cast<ImageAccessor*>(p.image);
 {
 OrthancConfiguration::ReaderLock lock;
 const Font& font = lock.GetConfiguration().GetFontRegistry().GetFont(p.fontIndex);
+ImageAccessor& target = *reinterpret_cast<ImageAccessor*>(p.image);
 font.Draw(target, p.utf8Text, p.x, p.y, p.r, p.g, p.b);
 }
 }
 assert(reader_ != NULL);
 parameters_.finalize(reader_);
 }
 virtual void AddBodyChunk(const void* data,
-size_t size)
+size_t size) ORTHANC_OVERRIDE
 {
 if (static_cast<uint32_t>(size) != size)
 {
 throw OrthancException(ErrorCode_NotEnoughMemory, ERROR_MESSAGE_64BIT);
 }
 assert(reader_ != NULL);
 parameters_.addChunk(reader_, data, size);
 }
-virtual void Execute(HttpOutput& output)
+virtual void Execute(HttpOutput& output) ORTHANC_OVERRIDE
 {
 assert(reader_ != NULL);
 PImpl::PluginHttpOutput pluginOutput(output);

Mercurial > hg > orthanc

comparison OrthancServer/Plugins/Engine/OrthancPlugins.cpp @ 4204:318c16cfccab