orthanc: Plugins/Engine/OrthancPlugins.cpp comparison

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

-:1f4910999fe7
+:2a170a8f1faf
 }
 }
 public:
 DicomWebBinaryFormatter(const _OrthancPluginEncodeDicomWeb& parameters) :
 callback_(parameters.callback)
 {
 }
 virtual DicomWebJsonVisitor::BinaryMode Format(std::string& bulkDataUri,
 const std::vector<DicomTag>& parentTags,
 MultipartState_SecondPart,
 MultipartState_NextParts
 };
 HttpOutput&                 output_;
-std::auto_ptr<std::string>  errorDetails_;
+std::unique_ptr<std::string>  errorDetails_;
 bool                        logDetails_;
 MultipartState              multipartState_;
 std::string                 multipartSubType_;
 std::string                 multipartContentType_;
 std::string                 multipartFirstPart_;
 _OrthancPluginChunkedRestCallback parameters_;
 boost::regex                      regex_;
 public:
 ChunkedRestCallback(_OrthancPluginChunkedRestCallback parameters) :
 parameters_(parameters),
 regex_(parameters.pathRegularExpression)
 {
 }
 const boost::regex& GetRegularExpression() const
 {
 boost::mutex::scoped_lock  lock_;
 ServerContext* context_;
 public:
 ServerContextLock(PImpl& that) :
 lock_(that.contextMutex_),
 context_(that.context_)
 {
 if (context_ == NULL)
 {
 throw OrthancException(ErrorCode_DatabaseNotInitialized);
 }
 JobsUnserializers  jobsUnserializers_;
 _OrthancPluginMoveCallback moveCallbacks_;
 IncomingHttpRequestFilters  incomingHttpRequestFilters_;
 IncomingHttpRequestFilters2 incomingHttpRequestFilters2_;
 RefreshMetricsCallbacks refreshMetricsCallbacks_;
-std::auto_ptr<StorageAreaFactory>  storageArea_;
+std::unique_ptr<StorageAreaFactory>  storageArea_;
 boost::recursive_mutex restCallbackMutex_;
 boost::recursive_mutex storedCallbackMutex_;
 boost::recursive_mutex changeCallbackMutex_;
 boost::mutex findCallbackMutex_;
 boost::recursive_mutex invokeServiceMutex_;
 Properties properties_;
 int argc_;
 char** argv_;
-std::auto_ptr<OrthancPluginDatabase>  database_;
+std::unique_ptr<OrthancPluginDatabase>  database_;
 PluginsErrorDictionary  dictionary_;
 PImpl() :
 context_(NULL),
 findCallback_(NULL),
 class OrthancPlugins::WorklistHandler : public IWorklistRequestHandler
 {
 private:
 OrthancPlugins&  that_;
-std::auto_ptr<HierarchicalMatcher> matcher_;
+std::unique_ptr<HierarchicalMatcher> matcher_;
-std::auto_ptr<ParsedDicomFile>     filtered_;
+std::unique_ptr<ParsedDicomFile>     filtered_;
 ParsedDicomFile* currentQuery_;
 void Reset()
 {
 matcher_.reset();
 {
 throw OrthancException(ErrorCode_Plugin);
 }
 ParsedDicomFile f(dicom, size);
-std::auto_ptr<ParsedDicomFile> summary(matcher_->Extract(f));
+std::unique_ptr<ParsedDicomFile> summary(matcher_->Extract(f));
 reinterpret_cast<DicomFindAnswers*>(answers)->Add(*summary);
 }
 };
 class OrthancPlugins::FindHandler : public IFindRequestHandler
 {
 private:
 OrthancPlugins&            that_;
-std::auto_ptr<DicomArray>  currentQuery_;
+std::unique_ptr<DicomArray>  currentQuery_;
 void Reset()
 {
 currentQuery_.reset(NULL);
 }
 std::vector<std::string>  groups_;
 std::vector<const char*>  cgroups_;
 public:
 RestCallbackMatcher(const UriComponents& uri) :
 flatUri_(Toolbox::FlattenUri(uri))
 {
 }
 bool IsMatch(const boost::regex& re)
 {
 *reinterpret_cast<const _OrthancPluginBufferCompression*>(parameters);
 std::string result;
 {
-std::auto_ptr<DeflateBaseCompressor> compressor;
+std::unique_ptr<DeflateBaseCompressor> compressor;
 switch (p.compression)
 {
 case OrthancPluginCompressionType_Zlib:
 {
 CopyToMemoryBuffer(*p.target, result);
 }
-static OrthancPluginImage* ReturnImage(std::auto_ptr<ImageAccessor>& image)
+static OrthancPluginImage* ReturnImage(std::unique_ptr<ImageAccessor>& image)
 {
 // Images returned to plugins are assumed to be writeable. If the
 // input image is read-only, we return a copy so that it can be modified.
 if (image->IsReadOnly())
 {
-std::auto_ptr<Image> copy(new Image(image->GetFormat(), image->GetWidth(), image->GetHeight(), false));
+std::unique_ptr<Image> copy(new Image(image->GetFormat(), image->GetWidth(), image->GetHeight(), false));
 ImageProcessing::Copy(*copy, *image);
 image.reset(NULL);
 return reinterpret_cast<OrthancPluginImage*>(copy.release());
 }
 else
 void OrthancPlugins::UncompressImage(const void* parameters)
 {
 const _OrthancPluginUncompressImage& p = *reinterpret_cast<const _OrthancPluginUncompressImage*>(parameters);
-std::auto_ptr<ImageAccessor> image;
+std::unique_ptr<ImageAccessor> image;
 switch (p.format)
 {
 case OrthancPluginImageFormat_Png:
 {
 void OrthancPlugins::ConvertPixelFormat(const void* parameters)
 {
 const _OrthancPluginConvertPixelFormat& p = *reinterpret_cast<const _OrthancPluginConvertPixelFormat*>(parameters);
 const ImageAccessor& source = *reinterpret_cast<const ImageAccessor*>(p.source);
-std::auto_ptr<ImageAccessor> target(new Image(Plugins::Convert(p.targetFormat), source.GetWidth(), source.GetHeight(), false));
+std::unique_ptr<ImageAccessor> target(new Image(Plugins::Convert(p.targetFormat), source.GetWidth(), source.GetHeight(), false));
 ImageProcessing::Convert(*target, source);
 *(p.target) = ReturnImage(target);
 }
 const void* parameters)
 {
 const _OrthancPluginDicomToJson& p =
 *reinterpret_cast<const _OrthancPluginDicomToJson*>(parameters);
-std::auto_ptr<ParsedDicomFile> dicom;
+std::unique_ptr<ParsedDicomFile> dicom;
 if (service == _OrthancPluginService_DicomBufferToJson)
 {
 dicom.reset(new ParsedDicomFile(p.buffer, p.size));
 }
 {
 OrthancConfiguration::ReaderLock lock;
 privateCreator = lock.GetConfiguration().GetDefaultPrivateCreator();
 }
-std::auto_ptr<ParsedDicomFile> file
+std::unique_ptr<ParsedDicomFile> file
 (ParsedDicomFile::CreateFromJson(json, static_cast<DicomFromJsonFlags>(p.flags),
 privateCreator));
 if (p.pixelData)
 {
 const void* parameters)
 {
 const _OrthancPluginCreateImage& p =
 *reinterpret_cast<const _OrthancPluginCreateImage*>(parameters);
-std::auto_ptr<ImageAccessor> result;
+std::unique_ptr<ImageAccessor> result;
 switch (service)
 {
 case _OrthancPluginService_CreateImage:
 result.reset(new Image(Plugins::Convert(p.format), p.width, p.height, false));
 pluginOutput.Close(error, errorDictionary_);
 }
 };
-bool OrthancPlugins::CreateChunkedRequestReader(std::auto_ptr<IChunkedRequestReader>& target,
+bool OrthancPlugins::CreateChunkedRequestReader(std::unique_ptr<IChunkedRequestReader>& target,
 RequestOrigin origin,
 const char* remoteIp,
 const char* username,
 HttpMethod method,
 const UriComponents& uri,

Mercurial > hg > orthanc

comparison Plugins/Engine/OrthancPlugins.cpp @ 3712:2a170a8f1faf