Mercurial > hg > orthanc
comparison Plugins/Engine/OrthancPlugins.cpp @ 3712:2a170a8f1faf
replacing std::auto_ptr by std::unique_ptr
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Mon, 02 Mar 2020 15:32:45 +0100 |
parents | 1f4910999fe7 |
children | 56f2397f027a |
comparison
equal
deleted
inserted
replaced
3709:1f4910999fe7 | 3712:2a170a8f1faf |
---|---|
365 } | 365 } |
366 } | 366 } |
367 | 367 |
368 public: | 368 public: |
369 DicomWebBinaryFormatter(const _OrthancPluginEncodeDicomWeb& parameters) : | 369 DicomWebBinaryFormatter(const _OrthancPluginEncodeDicomWeb& parameters) : |
370 callback_(parameters.callback) | 370 callback_(parameters.callback) |
371 { | 371 { |
372 } | 372 } |
373 | 373 |
374 virtual DicomWebJsonVisitor::BinaryMode Format(std::string& bulkDataUri, | 374 virtual DicomWebJsonVisitor::BinaryMode Format(std::string& bulkDataUri, |
375 const std::vector<DicomTag>& parentTags, | 375 const std::vector<DicomTag>& parentTags, |
433 MultipartState_SecondPart, | 433 MultipartState_SecondPart, |
434 MultipartState_NextParts | 434 MultipartState_NextParts |
435 }; | 435 }; |
436 | 436 |
437 HttpOutput& output_; | 437 HttpOutput& output_; |
438 std::auto_ptr<std::string> errorDetails_; | 438 std::unique_ptr<std::string> errorDetails_; |
439 bool logDetails_; | 439 bool logDetails_; |
440 MultipartState multipartState_; | 440 MultipartState multipartState_; |
441 std::string multipartSubType_; | 441 std::string multipartSubType_; |
442 std::string multipartContentType_; | 442 std::string multipartContentType_; |
443 std::string multipartFirstPart_; | 443 std::string multipartFirstPart_; |
663 _OrthancPluginChunkedRestCallback parameters_; | 663 _OrthancPluginChunkedRestCallback parameters_; |
664 boost::regex regex_; | 664 boost::regex regex_; |
665 | 665 |
666 public: | 666 public: |
667 ChunkedRestCallback(_OrthancPluginChunkedRestCallback parameters) : | 667 ChunkedRestCallback(_OrthancPluginChunkedRestCallback parameters) : |
668 parameters_(parameters), | 668 parameters_(parameters), |
669 regex_(parameters.pathRegularExpression) | 669 regex_(parameters.pathRegularExpression) |
670 { | 670 { |
671 } | 671 } |
672 | 672 |
673 const boost::regex& GetRegularExpression() const | 673 const boost::regex& GetRegularExpression() const |
674 { | 674 { |
688 boost::mutex::scoped_lock lock_; | 688 boost::mutex::scoped_lock lock_; |
689 ServerContext* context_; | 689 ServerContext* context_; |
690 | 690 |
691 public: | 691 public: |
692 ServerContextLock(PImpl& that) : | 692 ServerContextLock(PImpl& that) : |
693 lock_(that.contextMutex_), | 693 lock_(that.contextMutex_), |
694 context_(that.context_) | 694 context_(that.context_) |
695 { | 695 { |
696 if (context_ == NULL) | 696 if (context_ == NULL) |
697 { | 697 { |
698 throw OrthancException(ErrorCode_DatabaseNotInitialized); | 698 throw OrthancException(ErrorCode_DatabaseNotInitialized); |
699 } | 699 } |
738 JobsUnserializers jobsUnserializers_; | 738 JobsUnserializers jobsUnserializers_; |
739 _OrthancPluginMoveCallback moveCallbacks_; | 739 _OrthancPluginMoveCallback moveCallbacks_; |
740 IncomingHttpRequestFilters incomingHttpRequestFilters_; | 740 IncomingHttpRequestFilters incomingHttpRequestFilters_; |
741 IncomingHttpRequestFilters2 incomingHttpRequestFilters2_; | 741 IncomingHttpRequestFilters2 incomingHttpRequestFilters2_; |
742 RefreshMetricsCallbacks refreshMetricsCallbacks_; | 742 RefreshMetricsCallbacks refreshMetricsCallbacks_; |
743 std::auto_ptr<StorageAreaFactory> storageArea_; | 743 std::unique_ptr<StorageAreaFactory> storageArea_; |
744 | 744 |
745 boost::recursive_mutex restCallbackMutex_; | 745 boost::recursive_mutex restCallbackMutex_; |
746 boost::recursive_mutex storedCallbackMutex_; | 746 boost::recursive_mutex storedCallbackMutex_; |
747 boost::recursive_mutex changeCallbackMutex_; | 747 boost::recursive_mutex changeCallbackMutex_; |
748 boost::mutex findCallbackMutex_; | 748 boost::mutex findCallbackMutex_; |
753 boost::recursive_mutex invokeServiceMutex_; | 753 boost::recursive_mutex invokeServiceMutex_; |
754 | 754 |
755 Properties properties_; | 755 Properties properties_; |
756 int argc_; | 756 int argc_; |
757 char** argv_; | 757 char** argv_; |
758 std::auto_ptr<OrthancPluginDatabase> database_; | 758 std::unique_ptr<OrthancPluginDatabase> database_; |
759 PluginsErrorDictionary dictionary_; | 759 PluginsErrorDictionary dictionary_; |
760 | 760 |
761 PImpl() : | 761 PImpl() : |
762 context_(NULL), | 762 context_(NULL), |
763 findCallback_(NULL), | 763 findCallback_(NULL), |
773 | 773 |
774 class OrthancPlugins::WorklistHandler : public IWorklistRequestHandler | 774 class OrthancPlugins::WorklistHandler : public IWorklistRequestHandler |
775 { | 775 { |
776 private: | 776 private: |
777 OrthancPlugins& that_; | 777 OrthancPlugins& that_; |
778 std::auto_ptr<HierarchicalMatcher> matcher_; | 778 std::unique_ptr<HierarchicalMatcher> matcher_; |
779 std::auto_ptr<ParsedDicomFile> filtered_; | 779 std::unique_ptr<ParsedDicomFile> filtered_; |
780 ParsedDicomFile* currentQuery_; | 780 ParsedDicomFile* currentQuery_; |
781 | 781 |
782 void Reset() | 782 void Reset() |
783 { | 783 { |
784 matcher_.reset(); | 784 matcher_.reset(); |
887 { | 887 { |
888 throw OrthancException(ErrorCode_Plugin); | 888 throw OrthancException(ErrorCode_Plugin); |
889 } | 889 } |
890 | 890 |
891 ParsedDicomFile f(dicom, size); | 891 ParsedDicomFile f(dicom, size); |
892 std::auto_ptr<ParsedDicomFile> summary(matcher_->Extract(f)); | 892 std::unique_ptr<ParsedDicomFile> summary(matcher_->Extract(f)); |
893 reinterpret_cast<DicomFindAnswers*>(answers)->Add(*summary); | 893 reinterpret_cast<DicomFindAnswers*>(answers)->Add(*summary); |
894 } | 894 } |
895 }; | 895 }; |
896 | 896 |
897 | 897 |
898 class OrthancPlugins::FindHandler : public IFindRequestHandler | 898 class OrthancPlugins::FindHandler : public IFindRequestHandler |
899 { | 899 { |
900 private: | 900 private: |
901 OrthancPlugins& that_; | 901 OrthancPlugins& that_; |
902 std::auto_ptr<DicomArray> currentQuery_; | 902 std::unique_ptr<DicomArray> currentQuery_; |
903 | 903 |
904 void Reset() | 904 void Reset() |
905 { | 905 { |
906 currentQuery_.reset(NULL); | 906 currentQuery_.reset(NULL); |
907 } | 907 } |
1349 std::vector<std::string> groups_; | 1349 std::vector<std::string> groups_; |
1350 std::vector<const char*> cgroups_; | 1350 std::vector<const char*> cgroups_; |
1351 | 1351 |
1352 public: | 1352 public: |
1353 RestCallbackMatcher(const UriComponents& uri) : | 1353 RestCallbackMatcher(const UriComponents& uri) : |
1354 flatUri_(Toolbox::FlattenUri(uri)) | 1354 flatUri_(Toolbox::FlattenUri(uri)) |
1355 { | 1355 { |
1356 } | 1356 } |
1357 | 1357 |
1358 bool IsMatch(const boost::regex& re) | 1358 bool IsMatch(const boost::regex& re) |
1359 { | 1359 { |
2354 *reinterpret_cast<const _OrthancPluginBufferCompression*>(parameters); | 2354 *reinterpret_cast<const _OrthancPluginBufferCompression*>(parameters); |
2355 | 2355 |
2356 std::string result; | 2356 std::string result; |
2357 | 2357 |
2358 { | 2358 { |
2359 std::auto_ptr<DeflateBaseCompressor> compressor; | 2359 std::unique_ptr<DeflateBaseCompressor> compressor; |
2360 | 2360 |
2361 switch (p.compression) | 2361 switch (p.compression) |
2362 { | 2362 { |
2363 case OrthancPluginCompressionType_Zlib: | 2363 case OrthancPluginCompressionType_Zlib: |
2364 { | 2364 { |
2404 | 2404 |
2405 CopyToMemoryBuffer(*p.target, result); | 2405 CopyToMemoryBuffer(*p.target, result); |
2406 } | 2406 } |
2407 | 2407 |
2408 | 2408 |
2409 static OrthancPluginImage* ReturnImage(std::auto_ptr<ImageAccessor>& image) | 2409 static OrthancPluginImage* ReturnImage(std::unique_ptr<ImageAccessor>& image) |
2410 { | 2410 { |
2411 // Images returned to plugins are assumed to be writeable. If the | 2411 // Images returned to plugins are assumed to be writeable. If the |
2412 // input image is read-only, we return a copy so that it can be modified. | 2412 // input image is read-only, we return a copy so that it can be modified. |
2413 | 2413 |
2414 if (image->IsReadOnly()) | 2414 if (image->IsReadOnly()) |
2415 { | 2415 { |
2416 std::auto_ptr<Image> copy(new Image(image->GetFormat(), image->GetWidth(), image->GetHeight(), false)); | 2416 std::unique_ptr<Image> copy(new Image(image->GetFormat(), image->GetWidth(), image->GetHeight(), false)); |
2417 ImageProcessing::Copy(*copy, *image); | 2417 ImageProcessing::Copy(*copy, *image); |
2418 image.reset(NULL); | 2418 image.reset(NULL); |
2419 return reinterpret_cast<OrthancPluginImage*>(copy.release()); | 2419 return reinterpret_cast<OrthancPluginImage*>(copy.release()); |
2420 } | 2420 } |
2421 else | 2421 else |
2427 | 2427 |
2428 void OrthancPlugins::UncompressImage(const void* parameters) | 2428 void OrthancPlugins::UncompressImage(const void* parameters) |
2429 { | 2429 { |
2430 const _OrthancPluginUncompressImage& p = *reinterpret_cast<const _OrthancPluginUncompressImage*>(parameters); | 2430 const _OrthancPluginUncompressImage& p = *reinterpret_cast<const _OrthancPluginUncompressImage*>(parameters); |
2431 | 2431 |
2432 std::auto_ptr<ImageAccessor> image; | 2432 std::unique_ptr<ImageAccessor> image; |
2433 | 2433 |
2434 switch (p.format) | 2434 switch (p.format) |
2435 { | 2435 { |
2436 case OrthancPluginImageFormat_Png: | 2436 case OrthancPluginImageFormat_Png: |
2437 { | 2437 { |
2811 void OrthancPlugins::ConvertPixelFormat(const void* parameters) | 2811 void OrthancPlugins::ConvertPixelFormat(const void* parameters) |
2812 { | 2812 { |
2813 const _OrthancPluginConvertPixelFormat& p = *reinterpret_cast<const _OrthancPluginConvertPixelFormat*>(parameters); | 2813 const _OrthancPluginConvertPixelFormat& p = *reinterpret_cast<const _OrthancPluginConvertPixelFormat*>(parameters); |
2814 const ImageAccessor& source = *reinterpret_cast<const ImageAccessor*>(p.source); | 2814 const ImageAccessor& source = *reinterpret_cast<const ImageAccessor*>(p.source); |
2815 | 2815 |
2816 std::auto_ptr<ImageAccessor> target(new Image(Plugins::Convert(p.targetFormat), source.GetWidth(), source.GetHeight(), false)); | 2816 std::unique_ptr<ImageAccessor> target(new Image(Plugins::Convert(p.targetFormat), source.GetWidth(), source.GetHeight(), false)); |
2817 ImageProcessing::Convert(*target, source); | 2817 ImageProcessing::Convert(*target, source); |
2818 | 2818 |
2819 *(p.target) = ReturnImage(target); | 2819 *(p.target) = ReturnImage(target); |
2820 } | 2820 } |
2821 | 2821 |
2864 const void* parameters) | 2864 const void* parameters) |
2865 { | 2865 { |
2866 const _OrthancPluginDicomToJson& p = | 2866 const _OrthancPluginDicomToJson& p = |
2867 *reinterpret_cast<const _OrthancPluginDicomToJson*>(parameters); | 2867 *reinterpret_cast<const _OrthancPluginDicomToJson*>(parameters); |
2868 | 2868 |
2869 std::auto_ptr<ParsedDicomFile> dicom; | 2869 std::unique_ptr<ParsedDicomFile> dicom; |
2870 | 2870 |
2871 if (service == _OrthancPluginService_DicomBufferToJson) | 2871 if (service == _OrthancPluginService_DicomBufferToJson) |
2872 { | 2872 { |
2873 dicom.reset(new ParsedDicomFile(p.buffer, p.size)); | 2873 dicom.reset(new ParsedDicomFile(p.buffer, p.size)); |
2874 } | 2874 } |
2929 { | 2929 { |
2930 OrthancConfiguration::ReaderLock lock; | 2930 OrthancConfiguration::ReaderLock lock; |
2931 privateCreator = lock.GetConfiguration().GetDefaultPrivateCreator(); | 2931 privateCreator = lock.GetConfiguration().GetDefaultPrivateCreator(); |
2932 } | 2932 } |
2933 | 2933 |
2934 std::auto_ptr<ParsedDicomFile> file | 2934 std::unique_ptr<ParsedDicomFile> file |
2935 (ParsedDicomFile::CreateFromJson(json, static_cast<DicomFromJsonFlags>(p.flags), | 2935 (ParsedDicomFile::CreateFromJson(json, static_cast<DicomFromJsonFlags>(p.flags), |
2936 privateCreator)); | 2936 privateCreator)); |
2937 | 2937 |
2938 if (p.pixelData) | 2938 if (p.pixelData) |
2939 { | 2939 { |
2993 const void* parameters) | 2993 const void* parameters) |
2994 { | 2994 { |
2995 const _OrthancPluginCreateImage& p = | 2995 const _OrthancPluginCreateImage& p = |
2996 *reinterpret_cast<const _OrthancPluginCreateImage*>(parameters); | 2996 *reinterpret_cast<const _OrthancPluginCreateImage*>(parameters); |
2997 | 2997 |
2998 std::auto_ptr<ImageAccessor> result; | 2998 std::unique_ptr<ImageAccessor> result; |
2999 | 2999 |
3000 switch (service) | 3000 switch (service) |
3001 { | 3001 { |
3002 case _OrthancPluginService_CreateImage: | 3002 case _OrthancPluginService_CreateImage: |
3003 result.reset(new Image(Plugins::Convert(p.format), p.width, p.height, false)); | 3003 result.reset(new Image(Plugins::Convert(p.format), p.width, p.height, false)); |
4479 pluginOutput.Close(error, errorDictionary_); | 4479 pluginOutput.Close(error, errorDictionary_); |
4480 } | 4480 } |
4481 }; | 4481 }; |
4482 | 4482 |
4483 | 4483 |
4484 bool OrthancPlugins::CreateChunkedRequestReader(std::auto_ptr<IChunkedRequestReader>& target, | 4484 bool OrthancPlugins::CreateChunkedRequestReader(std::unique_ptr<IChunkedRequestReader>& target, |
4485 RequestOrigin origin, | 4485 RequestOrigin origin, |
4486 const char* remoteIp, | 4486 const char* remoteIp, |
4487 const char* username, | 4487 const char* username, |
4488 HttpMethod method, | 4488 HttpMethod method, |
4489 const UriComponents& uri, | 4489 const UriComponents& uri, |