Added ResourceLimits class.

diff --git a/Magick++/Makefile.am b/Magick++/Makefile.am
index 25e9c4114c3a4986d027382613e0291caebb08f3..645cc82a61d1fa9ed6e08eff34ef498ac6f74bae 100644 (file)
--- a/Magick++/Makefile.am
+++ b/Magick++/Makefile.am
@@ -126,6 +126,7 @@ MAGICKPP_INCHEADERS_OPT = \
        Magick++/lib/Magick++/Include.h \
        Magick++/lib/Magick++/Montage.h \
        Magick++/lib/Magick++/Pixels.h \
+       Magick++/lib/Magick++/ResourceLimits.h \
        Magick++/lib/Magick++/STL.h \
        Magick++/lib/Magick++/TypeMetric.h
 

diff --git a/Magick++/lib/Functions.cpp b/Magick++/lib/Functions.cpp
index 671995eca66881f2535b07a8af62d272e8a12e00..a9397ce4d4ce587f1a0c4d1cccc0036167b992e0 100644 (file)
--- a/Magick++/lib/Functions.cpp
+++ b/Magick++/lib/Functions.cpp
@@ -32,16 +32,6 @@ void Magick::CloneString(char **destination_, const std::string &source_)
   MagickCore::CloneString(destination_,source_.c_str());
 }
 
-MagickPPExport void Magick::CacheThreshold(const MagickSizeType threshold_)
-{
-  (void) SetMagickResourceLimit(MemoryResource,threshold_);
-}
-
-MagickPPExport MagickCore::MagickSizeType Magick::CacheThreshold(void)
-{
-  return GetMagickResourceLimit(MemoryResource);
-}
-
 MagickPPExport void Magick::DisableOpenCL(void)
 {
   GetPPException;

diff --git a/Magick++/lib/Magick++.h b/Magick++/lib/Magick++.h
index 740d51ef5dc6d93379e051de6443ff17c01fb53f..7df92cfc39da1bda766b7bdfaef769fac99cba9d 100644 (file)
--- a/Magick++/lib/Magick++.h
+++ b/Magick++/lib/Magick++.h
@@ -10,6 +10,7 @@
 #include <Magick++/Functions.h>
 #include <Magick++/Image.h>
 #include <Magick++/Pixels.h>
+#include <Magick++/ResourceLimits.h>
 #include <Magick++/STL.h>
 #define MagickPlusPlus_Header
 #endif // MagickPlusPlus_Header

diff --git a/Magick++/lib/Magick++/Functions.h b/Magick++/lib/Magick++/Functions.h
index 938a58882cbbba11ca4df520afd3ff6e1cbe6f89..ec6ff4fe567238d83d5ae4d2af82f1a456b6f03f 100644 (file)
--- a/Magick++/lib/Magick++/Functions.h
+++ b/Magick++/lib/Magick++/Functions.h
@@ -14,11 +14,6 @@
 
 namespace Magick
 {
-  // Pixel cache threshold in bytes. Once this memory threshold is exceeded,
-  // all subsequent pixels cache operations are to/from disk
-  MagickPPExport void CacheThreshold(const MagickSizeType threshold_);
-  MagickPPExport MagickSizeType CacheThreshold(void);
-
   // Clone C++ string as allocated C string, de-allocating any existing string
   MagickPPExport void CloneString(char **destination_,
     const std::string &source_);

diff --git a/Magick++/lib/Magick++/Include.h b/Magick++/lib/Magick++/Include.h
index d0b08735e007e0d4a6921466dac8e0497a848be6..35ece4edb92b4d7a1378b54bfb37ba38f1187605 100644 (file)
--- a/Magick++/lib/Magick++/Include.h
+++ b/Magick++/lib/Magick++/Include.h
@@ -843,7 +843,12 @@ namespace Magick
   using MagickCore::RelativeIntent;
   
   // Resource types
+  using MagickCore::ResourceType;
+  using MagickCore::AreaResource;
+  using MagickCore::DiskResource;
+  using MagickCore::MapResource;
   using MagickCore::MemoryResource;
+  using MagickCore::ThreadResource;
 
   // Resolution units
   using MagickCore::ResolutionType;

diff --git a/Magick++/lib/Magick++/ResourceLimits.h b/Magick++/lib/Magick++/ResourceLimits.h
new file mode 100644 (file)
index 0000000..6f0c137
--- /dev/null
+++ b/Magick++/lib/Magick++/ResourceLimits.h
@@ -0,0 +1,51 @@
+// This may look like C code, but it is really -*- C++ -*-
+//
+// Copyright Dirk Lemstra, 2014
+//
+// Definition of resource limits.
+//
+
+#if !defined(Magick_ResourceLimits_header)
+#define Magick_ResourceLimits_header
+
+#include "Magick++/Include.h"
+
+namespace Magick
+{
+  class MagickPPExport ResourceLimits
+  {
+  public:
+
+    // Pixel cache limit in bytes. Requests for memory above this limit
+    // are automagically allocated on disk.
+    static void area(const MagickSizeType limit_);
+    static MagickSizeType area(void);
+
+    // Pixel cache limit in bytes. Requests for memory above this limit
+    // will fail.
+    static void disk(const MagickSizeType limit_);
+    static MagickSizeType disk(void);
+
+    // Pixel cache limit in bytes.  Once this memory limit is exceeded,
+    // all subsequent pixels cache operations are to/from disk.
+    static void map(const MagickSizeType limit_);
+    static MagickSizeType map(void);
+
+    // Pixel cache limit in bytes. Once this memory limit is exceeded,
+    // all subsequent pixels cache operations are to/from disk or to/from
+    // memory mapped files.
+    static void memory(const MagickSizeType limit_);
+    static MagickSizeType memory(void);
+
+    // Limits the number of threads used in multithreaded operations.
+    static void thread(const MagickSizeType limit_);
+    static MagickSizeType thread(void);
+
+  private:
+    ResourceLimits(void);
+
+  }; // class ResourceLimits
+
+} // Magick namespace
+
+#endif // Magick_ResourceLimits_header

diff --git a/Magick++/lib/ResourceLimits.cpp b/Magick++/lib/ResourceLimits.cpp
new file mode 100644 (file)
index 0000000..9c78116
--- /dev/null
+++ b/Magick++/lib/ResourceLimits.cpp
@@ -0,0 +1,65 @@
+// This may look like C code, but it is really -*- C++ -*-
+//
+// Copyright Dirk Lemstra, 2014
+//
+// Implementation of ResourceLimits
+//
+
+#define MAGICKCORE_IMPLEMENTATION  1
+#define MAGICK_PLUSPLUS_IMPLEMENTATION 1
+
+#include "Magick++/ResourceLimits.h"
+
+void Magick::ResourceLimits::area(const MagickSizeType limit_)
+{
+  (void) SetMagickResourceLimit(AreaResource,limit_);
+}
+
+MagickCore::MagickSizeType Magick::ResourceLimits::area(void)
+{
+  return GetMagickResourceLimit(AreaResource);
+}
+
+void Magick::ResourceLimits::disk(const MagickSizeType limit_)
+{
+  (void) SetMagickResourceLimit(DiskResource,limit_);
+}
+
+MagickCore::MagickSizeType Magick::ResourceLimits::disk(void)
+{
+  return GetMagickResourceLimit(DiskResource);
+}
+
+void Magick::ResourceLimits::map(const MagickSizeType limit_)
+{
+  (void) SetMagickResourceLimit(MapResource,limit_);
+}
+
+MagickCore::MagickSizeType Magick::ResourceLimits::map(void)
+{
+  return GetMagickResourceLimit(MapResource);
+}
+
+void Magick::ResourceLimits::memory(const MagickSizeType limit_)
+{
+  (void) SetMagickResourceLimit(MemoryResource,limit_);
+}
+
+MagickCore::MagickSizeType Magick::ResourceLimits::memory(void)
+{
+  return GetMagickResourceLimit(MemoryResource);
+}
+
+void Magick::ResourceLimits::thread(const MagickSizeType limit_)
+{
+  (void) SetMagickResourceLimit(ThreadResource,limit_);
+}
+
+MagickCore::MagickSizeType Magick::ResourceLimits::thread(void)
+{
+  return GetMagickResourceLimit(ThreadResource);
+}
+
+Magick::ResourceLimits::ResourceLimits()
+{
+}