class CV_EXPORTS_W_SIMPLE Device
{
public:
- CV_WRAP Device();
+ CV_WRAP Device() CV_NOEXCEPT;
explicit Device(void* d);
Device(const Device& d);
Device& operator = (const Device& d);
class CV_EXPORTS Context
{
public:
- Context();
+ Context() CV_NOEXCEPT;
explicit Context(int dtype);
~Context();
Context(const Context& c);
class CV_EXPORTS Platform
{
public:
- Platform();
+ Platform() CV_NOEXCEPT;
~Platform();
Platform(const Platform& p);
Platform& operator = (const Platform& p);
class CV_EXPORTS Queue
{
public:
- Queue();
+ Queue() CV_NOEXCEPT;
explicit Queue(const Context& c, const Device& d=Device());
~Queue();
Queue(const Queue& q);
public:
enum { LOCAL=1, READ_ONLY=2, WRITE_ONLY=4, READ_WRITE=6, CONSTANT=8, PTR_ONLY = 16, NO_SIZE=256 };
KernelArg(int _flags, UMat* _m, int wscale=1, int iwscale=1, const void* _obj=0, size_t _sz=0);
- KernelArg();
+ KernelArg() CV_NOEXCEPT;
static KernelArg Local(size_t localMemSize)
{ return KernelArg(LOCAL, 0, 1, 1, 0, localMemSize); }
class CV_EXPORTS Kernel
{
public:
- Kernel();
+ Kernel() CV_NOEXCEPT;
Kernel(const char* kname, const Program& prog);
Kernel(const char* kname, const ProgramSource& prog,
const String& buildopts = String(), String* errmsg=0);
class CV_EXPORTS Program
{
public:
- Program();
+ Program() CV_NOEXCEPT;
Program(const ProgramSource& src,
const String& buildflags, String& errmsg);
Program(const Program& prog);
public:
typedef uint64 hash_t; // deprecated
- ProgramSource();
+ ProgramSource() CV_NOEXCEPT;
explicit ProgramSource(const String& module, const String& name, const String& codeStr, const String& codeHash);
explicit ProgramSource(const String& prog); // deprecated
explicit ProgramSource(const char* prog); // deprecated
class CV_EXPORTS PlatformInfo
{
public:
- PlatformInfo();
+ PlatformInfo() CV_NOEXCEPT;
explicit PlatformInfo(void* id);
~PlatformInfo();
class CV_EXPORTS Image2D
{
public:
- Image2D();
+ Image2D() CV_NOEXCEPT;
/**
@param src UMat object from which to get image properties and data
bool initialized;
};
-Platform::Platform()
+Platform::Platform() CV_NOEXCEPT
{
p = 0;
}
};
-Device::Device()
+Device::Device() CV_NOEXCEPT
{
p = 0;
}
};
-Context::Context()
+Context::Context() CV_NOEXCEPT
{
p = 0;
}
cv::ocl::Queue profiling_queue_;
};
-Queue::Queue()
+Queue::Queue() CV_NOEXCEPT
{
p = 0;
}
/////////////////////////////////////////// KernelArg /////////////////////////////////////////////
-KernelArg::KernelArg()
+KernelArg::KernelArg() CV_NOEXCEPT
: flags(0), m(0), obj(0), sz(0), wscale(1), iwscale(1)
{
}
namespace cv { namespace ocl {
-Kernel::Kernel()
+Kernel::Kernel() CV_NOEXCEPT
{
p = 0;
}
};
-ProgramSource::ProgramSource()
+ProgramSource::ProgramSource() CV_NOEXCEPT
{
p = 0;
}
};
-Program::Program() { p = 0; }
+Program::Program() CV_NOEXCEPT
+{
+ p = 0;
+}
Program::Program(const ProgramSource& src,
const String& buildflags, String& errmsg)
int versionMinor_;
};
-PlatformInfo::PlatformInfo()
+PlatformInfo::PlatformInfo() CV_NOEXCEPT
{
p = 0;
}
cl_mem handle;
};
-Image2D::Image2D()
+Image2D::Image2D() CV_NOEXCEPT
{
p = NULL;
}
CV_EXPORTS bool haveSVM() { return false; }
-Device::Device() : p(NULL) { }
+Device::Device() CV_NOEXCEPT : p(NULL) { }
Device::Device(void* d) : p(NULL) { OCL_NOT_AVAILABLE(); }
Device::Device(const Device& d) : p(NULL) { }
Device& Device::operator=(const Device& d) { return *this; }
}
-Context::Context() : p(NULL) { }
+Context::Context() CV_NOEXCEPT : p(NULL) { }
Context::Context(int dtype) : p(NULL) { }
Context::~Context() { }
Context::Context(const Context& c) : p(NULL) { }
bool Context::useSVM() const { return false; }
void Context::setUseSVM(bool enabled) { }
-Platform::Platform() : p(NULL) { }
+Platform::Platform() CV_NOEXCEPT : p(NULL) { }
Platform::~Platform() { }
Platform::Platform(const Platform&) : p(NULL) { }
Platform& Platform::operator=(const Platform&) { return *this; }
void initializeContextFromHandle(Context& ctx, void* platform, void* context, void* device) { OCL_NOT_AVAILABLE(); }
-Queue::Queue() : p(NULL) { }
+Queue::Queue() CV_NOEXCEPT : p(NULL) { }
Queue::Queue(const Context& c, const Device& d) : p(NULL) { OCL_NOT_AVAILABLE(); }
Queue::~Queue() { }
Queue::Queue(const Queue& q) {}
const Queue& Queue::getProfilingQueue() const { OCL_NOT_AVAILABLE(); }
-KernelArg::KernelArg()
+KernelArg::KernelArg() CV_NOEXCEPT
: flags(0), m(0), obj(0), sz(0), wscale(1), iwscale(1)
{
}
}
-Kernel::Kernel() : p(NULL) { }
+Kernel::Kernel() CV_NOEXCEPT : p(NULL) { }
Kernel::Kernel(const char* kname, const Program& prog) : p(NULL) { OCL_NOT_AVAILABLE(); }
Kernel::Kernel(const char* kname, const ProgramSource& prog, const String& buildopts, String* errmsg) : p(NULL) { OCL_NOT_AVAILABLE(); }
Kernel::~Kernel() { }
void* Kernel::ptr() const { return NULL; }
-Program::Program() : p(NULL) { }
+Program::Program() CV_NOEXCEPT : p(NULL) { }
Program::Program(const ProgramSource& src, const String& buildflags, String& errmsg) : p(NULL) { OCL_NOT_AVAILABLE(); }
Program::Program(const Program& prog) : p(NULL) { }
Program& Program::operator=(const Program& prog) { return *this; }
/* static */ String Program::getPrefix(const String& buildflags) { OCL_NOT_AVAILABLE(); }
-ProgramSource::ProgramSource() : p(NULL) { }
+ProgramSource::ProgramSource() CV_NOEXCEPT : p(NULL) { }
ProgramSource::ProgramSource(const String& module, const String& name, const String& codeStr, const String& codeHash) : p(NULL) { }
ProgramSource::ProgramSource(const String& prog) : p(NULL) { }
ProgramSource::ProgramSource(const char* prog) : p(NULL) { }
/* static */ ProgramSource ProgramSource::fromSPIR(const String& module, const String& name, const unsigned char* binary, const size_t size, const cv::String& buildOptions) { OCL_NOT_AVAILABLE(); }
-PlatformInfo::PlatformInfo() : p(NULL) { }
+PlatformInfo::PlatformInfo() CV_NOEXCEPT : p(NULL) { }
PlatformInfo::PlatformInfo(void* id) : p(NULL) { OCL_NOT_AVAILABLE(); }
PlatformInfo::~PlatformInfo() { }
void buildOptionsAddMatrixDescription(String& buildOptions, const String& name, InputArray _m) { OCL_NOT_AVAILABLE(); }
-Image2D::Image2D() : p(NULL) { }
+Image2D::Image2D() CV_NOEXCEPT : p(NULL) { }
Image2D::Image2D(const UMat &src, bool norm, bool alias) { OCL_NOT_AVAILABLE(); }
Image2D::Image2D(const Image2D & i) : p(NULL) { OCL_NOT_AVAILABLE(); }
Image2D::~Image2D() { }