From d90964110cf8c9455e34b7596e26b3c2b8cfe698 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 4 Sep 2024 22:37:11 +0000 Subject: [PATCH] Publish MMDevice/latest --- _device_base_8h_source.html | 6 +- _image_metadata_8h_source.html | 917 ++++++++++++++++----------------- _img_buffer_8h_source.html | 2 +- _m_m_device_8h_source.html | 2 +- class_c_camera_base.html | 2 +- class_metadata-members.html | 4 +- class_metadata.html | 12 +- 7 files changed, 466 insertions(+), 479 deletions(-) diff --git a/_device_base_8h_source.html b/_device_base_8h_source.html index e1be85b..a1347ae 100644 --- a/_device_base_8h_source.html +++ b/_device_base_8h_source.html @@ -1228,7 +1228,7 @@
1562  virtual long GetNumberOfImages() {return thd_->GetNumberOfImages();}
1563 
1564  // called from the thread function before exit
-
1565  virtual void OnThreadExiting() throw()
+
1565  virtual void OnThreadExiting()
1566  {
1567  try
1568  {
@@ -1331,7 +1331,7 @@
1668  void UpdateActualDuration() {actualDuration_ = camera_->GetCurrentMMTime() - startTime_;}
1669 
1670  private:
-
1671  virtual int svc(void) throw()
+
1671  virtual int svc()
1672  {
1673  int ret=DEVICE_ERR;
1674  try
@@ -2198,7 +2198,7 @@
MMDeviceThreadBase
Definition: DeviceThreads.h:34
MMThreadGuard
Definition: DeviceThreads.h:158
MMThreadLock
Definition: DeviceThreads.h:95
-
Metadata
Definition: ImageMetadata.h:287
+
Metadata
Definition: ImageMetadata.h:282
diff --git a/_image_metadata_8h_source.html b/_image_metadata_8h_source.html index 780fa0d..a2e222b 100644 --- a/_image_metadata_8h_source.html +++ b/_image_metadata_8h_source.html @@ -70,485 +70,472 @@
22 
23 #pragma once
24 
-
25 #ifdef _MSC_VER
-
26 #pragma warning(push)
-
27 #pragma warning(disable: 4290) // 'C++ exception specification ignored'
-
28 #endif
-
29 
-
30 #if defined(__GNUC__) && !defined(__clang__)
-
31 #pragma GCC diagnostic push
-
32 // 'dynamic exception specifications are deprecated in C++11 [-Wdeprecated]'
-
33 #pragma GCC diagnostic ignored "-Wdeprecated"
-
34 #endif
-
35 
-
36 #include "MMDeviceConstants.h"
-
37 
-
38 #include <string>
-
39 #include <vector>
-
40 #include <map>
-
41 #include <sstream>
-
42 #include <stdio.h>
-
43 #include <stdlib.h>
-
44 
-
46 // MetadataError
-
47 // -------------
-
48 // Micro-Manager metadata error class, used to create exception objects
-
49 //
-
50 class MetadataError
-
51 {
-
52 public:
-
53  MetadataError(const char* msg) :
-
54  message_(msg) {}
-
55 
-
56  virtual ~MetadataError() {}
+
25 #include "MMDeviceConstants.h"
+
26 
+
27 #include <string>
+
28 #include <vector>
+
29 #include <map>
+
30 #include <sstream>
+
31 #include <stdio.h>
+
32 #include <stdlib.h>
+
33 
+
34 #ifdef SWIG
+
35 #define MMDEVICE_LEGACY_THROW(ex) throw (ex)
+
36 #else
+
37 #define MMDEVICE_LEGACY_THROW(ex)
+
38 #endif
+
39 
+
41 // MetadataError
+
42 // -------------
+
43 // Micro-Manager metadata error class, used to create exception objects
+
44 //
+
45 class MetadataError
+
46 {
+
47 public:
+
48  MetadataError(const char* msg) :
+
49  message_(msg) {}
+
50 
+
51  virtual ~MetadataError() {}
+
52 
+
53  virtual std::string getMsg()
+
54  {
+
55  return message_;
+
56  }
57 
-
58  virtual std::string getMsg()
-
59  {
-
60  return message_;
-
61  }
-
62 
-
63 private:
-
64  std::string message_;
-
65 };
-
66 
-
67 class MetadataKeyError : public MetadataError
-
68 {
-
69 public:
-
70  MetadataKeyError() :
-
71  MetadataError("Undefined metadata key") {}
-
72  ~MetadataKeyError() {}
-
73 };
-
74 
-
75 class MetadataIndexError : public MetadataError
-
76 {
-
77 public:
-
78  MetadataIndexError() :
-
79  MetadataError("Metadata array index out of bounds") {}
-
80  ~MetadataIndexError() {}
-
81 };
-
82 
-
83 
-
84 class MetadataSingleTag;
-
85 class MetadataArrayTag;
-
86 
-
90 class MetadataTag
-
91 {
-
92 public:
-
93  MetadataTag() : name_("undefined"), deviceLabel_("undefined"), readOnly_(false) {}
-
94  MetadataTag(const char* name, const char* device, bool readOnly) :
-
95  name_(name), deviceLabel_(device), readOnly_(readOnly) {}
-
96  virtual ~MetadataTag() {}
-
97 
-
98  const std::string& GetDevice() const {return deviceLabel_;}
-
99  const std::string& GetName() const {return name_;}
-
100  const std::string GetQualifiedName() const
-
101  {
-
102  std::string str;
-
103  if (deviceLabel_.compare("_") != 0)
-
104  {
-
105  str.append(deviceLabel_).append("-");
-
106  }
-
107  str.append(name_);
-
108  return str;
-
109  }
-
110  bool IsReadOnly() const {return readOnly_;}
-
111 
-
112  void SetDevice(const char* device) {deviceLabel_ = device;}
-
113  void SetName(const char* name) {name_ = name;}
-
114  void SetReadOnly(bool ro) {readOnly_ = ro;}
-
115 
-
122  virtual const MetadataSingleTag* ToSingleTag() const { return 0; }
-
127  virtual const MetadataArrayTag* ToArrayTag() const { return 0; }
-
128 
-
129  //inline MetadataSingleTag* ToSingleTag() {
-
130  // const MetadataTag *p = this;
-
131  // return const_cast<MetadataSingleTag*>(p->ToSingleTag());
-
132  // }
-
133  //inline MetadataArrayTag* ToArrayTag() {
-
134  // const MetadataTag *p = this;
-
135  // return const_cast<MetadataArrayTag*>(p->ToArrayTag());
-
136  //}
+
58 private:
+
59  std::string message_;
+
60 };
+
61 
+
62 class MetadataKeyError : public MetadataError
+
63 {
+
64 public:
+
65  MetadataKeyError() :
+
66  MetadataError("Undefined metadata key") {}
+
67  ~MetadataKeyError() {}
+
68 };
+
69 
+
70 class MetadataIndexError : public MetadataError
+
71 {
+
72 public:
+
73  MetadataIndexError() :
+
74  MetadataError("Metadata array index out of bounds") {}
+
75  ~MetadataIndexError() {}
+
76 };
+
77 
+
78 
+
79 class MetadataSingleTag;
+
80 class MetadataArrayTag;
+
81 
+
85 class MetadataTag
+
86 {
+
87 public:
+
88  MetadataTag() : name_("undefined"), deviceLabel_("undefined"), readOnly_(false) {}
+
89  MetadataTag(const char* name, const char* device, bool readOnly) :
+
90  name_(name), deviceLabel_(device), readOnly_(readOnly) {}
+
91  virtual ~MetadataTag() {}
+
92 
+
93  const std::string& GetDevice() const {return deviceLabel_;}
+
94  const std::string& GetName() const {return name_;}
+
95  const std::string GetQualifiedName() const
+
96  {
+
97  std::string str;
+
98  if (deviceLabel_.compare("_") != 0)
+
99  {
+
100  str.append(deviceLabel_).append("-");
+
101  }
+
102  str.append(name_);
+
103  return str;
+
104  }
+
105  bool IsReadOnly() const {return readOnly_;}
+
106 
+
107  void SetDevice(const char* device) {deviceLabel_ = device;}
+
108  void SetName(const char* name) {name_ = name;}
+
109  void SetReadOnly(bool ro) {readOnly_ = ro;}
+
110 
+
117  virtual const MetadataSingleTag* ToSingleTag() const { return 0; }
+
122  virtual const MetadataArrayTag* ToArrayTag() const { return 0; }
+
123 
+
124  //inline MetadataSingleTag* ToSingleTag() {
+
125  // const MetadataTag *p = this;
+
126  // return const_cast<MetadataSingleTag*>(p->ToSingleTag());
+
127  // }
+
128  //inline MetadataArrayTag* ToArrayTag() {
+
129  // const MetadataTag *p = this;
+
130  // return const_cast<MetadataArrayTag*>(p->ToArrayTag());
+
131  //}
+
132 
+
133  virtual MetadataTag* Clone() = 0;
+
134  virtual std::string Serialize() = 0;
+
135  virtual bool Restore(const char* stream) = 0;
+
136  virtual bool Restore(std::istringstream& is) = 0;
137 
-
138  virtual MetadataTag* Clone() = 0;
-
139  virtual std::string Serialize() = 0;
-
140  virtual bool Restore(const char* stream) = 0;
-
141  virtual bool Restore(std::istringstream& is) = 0;
-
142 
-
143  static std::string ReadLine(std::istringstream& is)
-
144  {
-
145  std::string ret;
-
146  std::getline(is, ret);
-
147  return ret;
-
148  }
-
149 
-
150 private:
-
151  std::string name_;
-
152  std::string deviceLabel_;
-
153  bool readOnly_;
-
154 };
-
155 
-
156 class MetadataSingleTag : public MetadataTag
-
157 {
-
158 public:
-
159  MetadataSingleTag() {}
-
160  MetadataSingleTag(const char* name, const char* device, bool readOnly) :
-
161  MetadataTag(name, device, readOnly) {}
-
162  ~MetadataSingleTag() {}
+
138  static std::string ReadLine(std::istringstream& is)
+
139  {
+
140  std::string ret;
+
141  std::getline(is, ret);
+
142  return ret;
+
143  }
+
144 
+
145 private:
+
146  std::string name_;
+
147  std::string deviceLabel_;
+
148  bool readOnly_;
+
149 };
+
150 
+
151 class MetadataSingleTag : public MetadataTag
+
152 {
+
153 public:
+
154  MetadataSingleTag() {}
+
155  MetadataSingleTag(const char* name, const char* device, bool readOnly) :
+
156  MetadataTag(name, device, readOnly) {}
+
157  ~MetadataSingleTag() {}
+
158 
+
159  const std::string& GetValue() const {return value_;}
+
160  void SetValue(const char* val) {value_ = val;}
+
161 
+
162  virtual const MetadataSingleTag* ToSingleTag() const { return this; }
163 
-
164  const std::string& GetValue() const {return value_;}
-
165  void SetValue(const char* val) {value_ = val;}
-
166 
-
167  virtual const MetadataSingleTag* ToSingleTag() const { return this; }
+
164  MetadataTag* Clone()
+
165  {
+
166  return new MetadataSingleTag(*this);
+
167  }
168 
-
169  MetadataTag* Clone()
+
169  std::string Serialize()
170  {
-
171  return new MetadataSingleTag(*this);
-
172  }
-
173 
-
174  std::string Serialize()
-
175  {
-
176  std::string str;
-
177 
-
178  str.append(GetName()).append("\n");
-
179  str.append(GetDevice()).append("\n");
-
180  str.append(IsReadOnly() ? "1" : "0").append("\n");
+
171  std::string str;
+
172 
+
173  str.append(GetName()).append("\n");
+
174  str.append(GetDevice()).append("\n");
+
175  str.append(IsReadOnly() ? "1" : "0").append("\n");
+
176 
+
177  str.append(value_).append("\n");
+
178 
+
179  return str;
+
180  }
181 
-
182  str.append(value_).append("\n");
-
183 
-
184  return str;
-
185  }
-
186 
-
187  bool Restore(const char* stream)
-
188  {
-
189  std::istringstream is(stream);
-
190  return Restore(is);
-
191  }
-
192 
-
193  bool Restore(std::istringstream& is)
-
194  {
-
195  SetName(ReadLine(is).c_str());
-
196  SetDevice(ReadLine(is).c_str());
-
197  SetReadOnly(atoi(ReadLine(is).c_str()) != 0);
+
182  bool Restore(const char* stream)
+
183  {
+
184  std::istringstream is(stream);
+
185  return Restore(is);
+
186  }
+
187 
+
188  bool Restore(std::istringstream& is)
+
189  {
+
190  SetName(ReadLine(is).c_str());
+
191  SetDevice(ReadLine(is).c_str());
+
192  SetReadOnly(atoi(ReadLine(is).c_str()) != 0);
+
193 
+
194  value_ = ReadLine(is);
+
195 
+
196  return true;
+
197  }
198 
-
199  value_ = ReadLine(is);
-
200 
-
201  return true;
-
202  }
-
203 
-
204 private:
-
205  std::string value_;
-
206 };
-
207 
-
208 class MetadataArrayTag : public MetadataTag
-
209 {
-
210 public:
-
211  MetadataArrayTag() {}
-
212  MetadataArrayTag(const char* name, const char* device, bool readOnly) :
-
213  MetadataTag(name, device, readOnly) {}
-
214  ~MetadataArrayTag() {}
-
215 
-
216  virtual const MetadataArrayTag* ToArrayTag() const { return this; }
-
217 
-
218  void AddValue(const char* val) {values_.push_back(val);}
-
219  void SetValue(const char* val, size_t idx)
-
220  {
-
221  if (values_.size() < idx+1)
-
222  values_.resize(idx+1);
-
223  values_[idx] = val;
-
224  }
-
225 
-
226  const std::string& GetValue(size_t idx) const {
-
227  if (idx >= values_.size())
-
228  throw MetadataIndexError();
-
229  return values_[idx];
-
230  }
-
231 
-
232  size_t GetSize() const {return values_.size();}
+
199 private:
+
200  std::string value_;
+
201 };
+
202 
+
203 class MetadataArrayTag : public MetadataTag
+
204 {
+
205 public:
+
206  MetadataArrayTag() {}
+
207  MetadataArrayTag(const char* name, const char* device, bool readOnly) :
+
208  MetadataTag(name, device, readOnly) {}
+
209  ~MetadataArrayTag() {}
+
210 
+
211  virtual const MetadataArrayTag* ToArrayTag() const { return this; }
+
212 
+
213  void AddValue(const char* val) {values_.push_back(val);}
+
214  void SetValue(const char* val, size_t idx)
+
215  {
+
216  if (values_.size() < idx+1)
+
217  values_.resize(idx+1);
+
218  values_[idx] = val;
+
219  }
+
220 
+
221  const std::string& GetValue(size_t idx) const {
+
222  if (idx >= values_.size())
+
223  throw MetadataIndexError();
+
224  return values_[idx];
+
225  }
+
226 
+
227  size_t GetSize() const {return values_.size();}
+
228 
+
229  MetadataTag* Clone()
+
230  {
+
231  return new MetadataArrayTag(*this);
+
232  }
233 
-
234  MetadataTag* Clone()
+
234  std::string Serialize()
235  {
-
236  return new MetadataArrayTag(*this);
-
237  }
-
238 
-
239  std::string Serialize()
-
240  {
-
241  std::string str;
-
242 
-
243  str.append(GetName()).append("\n");
-
244  str.append(GetDevice()).append("\n");
-
245  str.append(IsReadOnly() ? "1" : "0").append("\n");
-
246 
-
247  std::stringstream os;
-
248  os << values_.size();
-
249  str.append(os.str()).append("\n");
-
250 
-
251  for (size_t i = 0; i < values_.size(); i++)
-
252  str.append(values_[i]).append("\n");
-
253 
-
254  return str;
-
255  }
-
256 
-
257  bool Restore(const char* stream)
-
258  {
-
259  std::istringstream is(stream);
-
260  return Restore(is);
-
261  }
-
262 
-
263  bool Restore(std::istringstream& is)
-
264  {
-
265  SetName(ReadLine(is).c_str());
-
266  SetDevice(ReadLine(is).c_str());
-
267  SetReadOnly(atoi(ReadLine(is).c_str()) != 0);
-
268 
-
269  size_t size = atol(ReadLine(is).c_str());
+
236  std::string str;
+
237 
+
238  str.append(GetName()).append("\n");
+
239  str.append(GetDevice()).append("\n");
+
240  str.append(IsReadOnly() ? "1" : "0").append("\n");
+
241 
+
242  std::stringstream os;
+
243  os << values_.size();
+
244  str.append(os.str()).append("\n");
+
245 
+
246  for (size_t i = 0; i < values_.size(); i++)
+
247  str.append(values_[i]).append("\n");
+
248 
+
249  return str;
+
250  }
+
251 
+
252  bool Restore(const char* stream)
+
253  {
+
254  std::istringstream is(stream);
+
255  return Restore(is);
+
256  }
+
257 
+
258  bool Restore(std::istringstream& is)
+
259  {
+
260  SetName(ReadLine(is).c_str());
+
261  SetDevice(ReadLine(is).c_str());
+
262  SetReadOnly(atoi(ReadLine(is).c_str()) != 0);
+
263 
+
264  size_t size = atol(ReadLine(is).c_str());
+
265 
+
266  values_.resize(size);
+
267 
+
268  for (size_t i = 0; i < size; i++)
+
269  values_[i] = ReadLine(is);
270 
-
271  values_.resize(size);
-
272 
-
273  for (size_t i = 0; i < size; i++)
-
274  values_[i] = ReadLine(is);
-
275 
-
276  return true;
-
277  }
-
278 
-
279 private:
-
280  std::vector<std::string> values_;
-
281 };
-
282 
-
286 class Metadata
-
287 {
-
288 public:
-
289 
-
290  Metadata() {} // empty constructor
+
271  return true;
+
272  }
+
273 
+
274 private:
+
275  std::vector<std::string> values_;
+
276 };
+
277 
+
281 class Metadata
+
282 {
+
283 public:
+
284 
+
285  Metadata() {} // empty constructor
+
286 
+
287  ~Metadata() // destructor
+
288  {
+
289  Clear();
+
290  }
291 
-
292  ~Metadata() // destructor
+
292  Metadata(const Metadata& original) // copy constructor
293  {
-
294  Clear();
-
295  }
-
296 
-
297  Metadata(const Metadata& original) // copy constructor
-
298  {
-
299  for (TagConstIter it = original.tags_.begin(); it != original.tags_.end(); it++)
-
300  {
-
301  SetTag(*it->second);
-
302  }
-
303  }
-
304 
-
305  void Clear()
-
306  {
-
307  for (TagConstIter it=tags_.begin(); it != tags_.end(); it++)
-
308  delete it->second;
-
309  tags_.clear();
-
310  }
-
311 
-
312  std::vector<std::string> GetKeys() const
-
313  {
-
314  std::vector<std::string> keyList;
-
315  for (TagConstIter it = tags_.begin(), end = tags_.end(); it != end; ++it)
-
316  keyList.push_back(it->first);
-
317  return keyList;
-
318  }
-
319 
-
320  bool HasTag(const char* key)
-
321  {
-
322  TagConstIter it = tags_.find(key);
-
323  if (it != tags_.end())
-
324  return true;
-
325  else
-
326  return false;
-
327  }
-
328 
-
329  MetadataSingleTag GetSingleTag(const char* key) const throw (MetadataKeyError)
-
330  {
-
331  MetadataTag* tag = FindTag(key);
-
332  const MetadataSingleTag* stag = tag->ToSingleTag();
-
333  return *stag;
-
334  }
-
335 
-
336  MetadataArrayTag GetArrayTag(const char* key) const throw (MetadataKeyError)
-
337  {
-
338  MetadataTag* tag = FindTag(key);
-
339  const MetadataArrayTag* atag = tag->ToArrayTag();
-
340  return *atag;
-
341  }
-
342 
-
343  void SetTag(MetadataTag& tag)
-
344  {
-
345  MetadataTag* newTag = tag.Clone();
-
346  const std::string key(tag.GetQualifiedName());
-
347  RemoveTag(key.c_str());
-
348  tags_[key] = newTag;
-
349  }
-
350 
-
351  void RemoveTag(const char* key)
-
352  {
-
353  TagIter it = tags_.find(key);
-
354  if (it != tags_.end())
-
355  {
-
356  delete it->second;
-
357  tags_.erase(it); // Non-const iterator needed in pre-C++11 code
-
358  }
-
359  }
-
360 
-
361  /*
-
362  * Convenience method to add a MetadataSingleTag
-
363  */
-
364  template <class anytype>
-
365  void PutTag(std::string key, std::string deviceLabel, anytype value)
-
366  {
-
367  std::stringstream os;
-
368  os << value;
-
369  MetadataSingleTag* newTag = new MetadataSingleTag(key.c_str(), deviceLabel.c_str(), true);
-
370  newTag->SetValue(os.str().c_str());
-
371  tags_[newTag->GetQualifiedName()] = newTag;
-
372  }
-
373 
-
374  /*
-
375  * Add a tag not associated with any device.
-
376  */
-
377  template <class anytype>
-
378  void PutImageTag(std::string key, anytype value)
-
379  {
-
380  PutTag(key, "_", value);
-
381  }
-
382 
-
383  /*
-
384  * Deprecated name. Equivalent to PutImageTag.
-
385  */
-
386  template <class anytype>
-
387  void put(std::string key, anytype value)
-
388  {
-
389  PutImageTag(key, value);
-
390  }
-
391 
-
392 #ifndef SWIG
-
393  Metadata& operator=(const Metadata& rhs)
-
394  {
-
395  Clear();
-
396 
-
397  for (TagConstIter it=rhs.tags_.begin(); it != rhs.tags_.end(); it++)
-
398  {
-
399  SetTag(*it->second);
-
400  }
-
401 
-
402  return *this;
-
403  }
-
404 #endif
-
405 
-
406  void Merge(const Metadata& newTags)
-
407  {
-
408  for (TagConstIter it=newTags.tags_.begin(); it != newTags.tags_.end(); it++)
-
409  {
-
410  SetTag(*it->second);
-
411  }
-
412  }
-
413 
-
414  std::string Serialize() const
-
415  {
-
416  std::string str;
-
417 
-
418  std::ostringstream os;
-
419  os << tags_.size();
-
420  str.append(os.str()).append("\n");
+
294  for (TagConstIter it = original.tags_.begin(); it != original.tags_.end(); it++)
+
295  {
+
296  SetTag(*it->second);
+
297  }
+
298  }
+
299 
+
300  void Clear()
+
301  {
+
302  for (TagConstIter it=tags_.begin(); it != tags_.end(); it++)
+
303  delete it->second;
+
304  tags_.clear();
+
305  }
+
306 
+
307  std::vector<std::string> GetKeys() const
+
308  {
+
309  std::vector<std::string> keyList;
+
310  for (TagConstIter it = tags_.begin(), end = tags_.end(); it != end; ++it)
+
311  keyList.push_back(it->first);
+
312  return keyList;
+
313  }
+
314 
+
315  bool HasTag(const char* key)
+
316  {
+
317  TagConstIter it = tags_.find(key);
+
318  if (it != tags_.end())
+
319  return true;
+
320  else
+
321  return false;
+
322  }
+
323 
+
324  MetadataSingleTag GetSingleTag(const char* key) const MMDEVICE_LEGACY_THROW(MetadataKeyError)
+
325  {
+
326  MetadataTag* tag = FindTag(key);
+
327  const MetadataSingleTag* stag = tag->ToSingleTag();
+
328  return *stag;
+
329  }
+
330 
+
331  MetadataArrayTag GetArrayTag(const char* key) const MMDEVICE_LEGACY_THROW(MetadataKeyError)
+
332  {
+
333  MetadataTag* tag = FindTag(key);
+
334  const MetadataArrayTag* atag = tag->ToArrayTag();
+
335  return *atag;
+
336  }
+
337 
+
338  void SetTag(MetadataTag& tag)
+
339  {
+
340  MetadataTag* newTag = tag.Clone();
+
341  const std::string key(tag.GetQualifiedName());
+
342  RemoveTag(key.c_str());
+
343  tags_[key] = newTag;
+
344  }
+
345 
+
346  void RemoveTag(const char* key)
+
347  {
+
348  TagIter it = tags_.find(key);
+
349  if (it != tags_.end())
+
350  {
+
351  delete it->second;
+
352  tags_.erase(it); // Non-const iterator needed in pre-C++11 code
+
353  }
+
354  }
+
355 
+
356  /*
+
357  * Convenience method to add a MetadataSingleTag
+
358  */
+
359  template <class anytype>
+
360  void PutTag(std::string key, std::string deviceLabel, anytype value)
+
361  {
+
362  std::stringstream os;
+
363  os << value;
+
364  MetadataSingleTag* newTag = new MetadataSingleTag(key.c_str(), deviceLabel.c_str(), true);
+
365  newTag->SetValue(os.str().c_str());
+
366  tags_[newTag->GetQualifiedName()] = newTag;
+
367  }
+
368 
+
369  /*
+
370  * Add a tag not associated with any device.
+
371  */
+
372  template <class anytype>
+
373  void PutImageTag(std::string key, anytype value)
+
374  {
+
375  PutTag(key, "_", value);
+
376  }
+
377 
+
378  /*
+
379  * Deprecated name. Equivalent to PutImageTag.
+
380  */
+
381  template <class anytype>
+
382  void put(std::string key, anytype value)
+
383  {
+
384  PutImageTag(key, value);
+
385  }
+
386 
+
387 #ifndef SWIG
+
388  Metadata& operator=(const Metadata& rhs)
+
389  {
+
390  Clear();
+
391 
+
392  for (TagConstIter it=rhs.tags_.begin(); it != rhs.tags_.end(); it++)
+
393  {
+
394  SetTag(*it->second);
+
395  }
+
396 
+
397  return *this;
+
398  }
+
399 #endif
+
400 
+
401  void Merge(const Metadata& newTags)
+
402  {
+
403  for (TagConstIter it=newTags.tags_.begin(); it != newTags.tags_.end(); it++)
+
404  {
+
405  SetTag(*it->second);
+
406  }
+
407  }
+
408 
+
409  std::string Serialize() const
+
410  {
+
411  std::string str;
+
412 
+
413  std::ostringstream os;
+
414  os << tags_.size();
+
415  str.append(os.str()).append("\n");
+
416 
+
417  for (TagConstIter it = tags_.begin(); it != tags_.end(); it++)
+
418  {
+
419  const std::string id((it->second->ToArrayTag()) ? "a" : "s");
+
420  str.append(id).append("\n");
421 
-
422  for (TagConstIter it = tags_.begin(); it != tags_.end(); it++)
-
423  {
-
424  const std::string id((it->second->ToArrayTag()) ? "a" : "s");
-
425  str.append(id).append("\n");
-
426 
-
427  str.append(it->second->Serialize());
-
428  }
-
429 
-
430  return str;
-
431  }
-
432 
-
433  // TODO: Can this be removed?
-
434  std::string readLine(std::istringstream &iss)
+
422  str.append(it->second->Serialize());
+
423  }
+
424 
+
425  return str;
+
426  }
+
427 
+
428  // TODO: Can this be removed?
+
429  std::string readLine(std::istringstream &iss)
+
430  {
+
431  return MetadataTag::ReadLine(iss);
+
432  }
+
433 
+
434  bool Restore(const char* stream)
435  {
-
436  return MetadataTag::ReadLine(iss);
-
437  }
-
438 
-
439  bool Restore(const char* stream)
-
440  {
-
441  Clear();
-
442 
-
443  std::istringstream is(stream);
-
444 
-
445  const size_t sz = atol(readLine(is).c_str());
-
446 
-
447  for (size_t i=0; i<sz; i++)
-
448  {
-
449  const std::string id(readLine(is));
-
450 
-
451  MetadataTag* newTag;
-
452  if (id.compare("s") == 0)
-
453  {
-
454  newTag = new MetadataSingleTag();
-
455  }
-
456  else if (id.compare("a") == 0)
-
457  {
-
458  newTag = new MetadataArrayTag();
-
459  }
-
460  else
-
461  {
-
462  return false;
-
463  }
-
464 
-
465  newTag->Restore(is);
-
466  tags_[newTag->GetQualifiedName()] = newTag;
-
467  }
-
468  return true;
-
469  }
-
470 
-
471  std::string Dump()
-
472  {
-
473  std::ostringstream os;
-
474 
-
475  os << tags_.size();
-
476  for (TagConstIter it = tags_.begin(); it != tags_.end(); it++)
-
477  {
-
478  std::string id("s");
-
479  if (it->second->ToArrayTag())
-
480  id = "a";
-
481  std::string ser = it->second->Serialize();
-
482  os << id << " : " << ser << '\n';
-
483  }
-
484 
-
485  return os.str();
-
486  }
-
487 
-
488 private:
-
489  MetadataTag* FindTag(const char* key) const
-
490  {
-
491  TagConstIter it = tags_.find(key);
-
492  if (it != tags_.end())
-
493  return it->second;
-
494  else
-
495  throw MetadataKeyError();
-
496  }
-
497 
-
498  std::map<std::string, MetadataTag*> tags_;
-
499  typedef std::map<std::string, MetadataTag*>::iterator TagIter;
-
500  typedef std::map<std::string, MetadataTag*>::const_iterator TagConstIter;
-
501 };
-
502 
-
503 #if defined(__GNUC__) && !defined(__clang__)
-
504 #pragma GCC diagnostic pop
-
505 #endif
-
506 
-
507 #ifdef _MSC_VER
-
508 #pragma warning(pop)
-
509 #endif
-
MetadataArrayTag
Definition: ImageMetadata.h:209
-
MetadataArrayTag::ToArrayTag
virtual const MetadataArrayTag * ToArrayTag() const
Definition: ImageMetadata.h:216
-
MetadataError
Definition: ImageMetadata.h:51
-
Metadata
Definition: ImageMetadata.h:287
-
MetadataIndexError
Definition: ImageMetadata.h:76
-
MetadataKeyError
Definition: ImageMetadata.h:68
-
MetadataSingleTag
Definition: ImageMetadata.h:157
-
MetadataSingleTag::ToSingleTag
virtual const MetadataSingleTag * ToSingleTag() const
Definition: ImageMetadata.h:167
-
MetadataTag
Definition: ImageMetadata.h:91
-
MetadataTag::ToSingleTag
virtual const MetadataSingleTag * ToSingleTag() const
Definition: ImageMetadata.h:122
-
MetadataTag::ToArrayTag
virtual const MetadataArrayTag * ToArrayTag() const
Definition: ImageMetadata.h:127
+
436  Clear();
+
437 
+
438  std::istringstream is(stream);
+
439 
+
440  const size_t sz = atol(readLine(is).c_str());
+
441 
+
442  for (size_t i=0; i<sz; i++)
+
443  {
+
444  const std::string id(readLine(is));
+
445 
+
446  MetadataTag* newTag;
+
447  if (id.compare("s") == 0)
+
448  {
+
449  newTag = new MetadataSingleTag();
+
450  }
+
451  else if (id.compare("a") == 0)
+
452  {
+
453  newTag = new MetadataArrayTag();
+
454  }
+
455  else
+
456  {
+
457  return false;
+
458  }
+
459 
+
460  newTag->Restore(is);
+
461  tags_[newTag->GetQualifiedName()] = newTag;
+
462  }
+
463  return true;
+
464  }
+
465 
+
466  std::string Dump()
+
467  {
+
468  std::ostringstream os;
+
469 
+
470  os << tags_.size();
+
471  for (TagConstIter it = tags_.begin(); it != tags_.end(); it++)
+
472  {
+
473  std::string id("s");
+
474  if (it->second->ToArrayTag())
+
475  id = "a";
+
476  std::string ser = it->second->Serialize();
+
477  os << id << " : " << ser << '\n';
+
478  }
+
479 
+
480  return os.str();
+
481  }
+
482 
+
483 private:
+
484  MetadataTag* FindTag(const char* key) const
+
485  {
+
486  TagConstIter it = tags_.find(key);
+
487  if (it != tags_.end())
+
488  return it->second;
+
489  else
+
490  throw MetadataKeyError();
+
491  }
+
492 
+
493  std::map<std::string, MetadataTag*> tags_;
+
494  typedef std::map<std::string, MetadataTag*>::iterator TagIter;
+
495  typedef std::map<std::string, MetadataTag*>::const_iterator TagConstIter;
+
496 };
+
MetadataArrayTag
Definition: ImageMetadata.h:204
+
MetadataArrayTag::ToArrayTag
virtual const MetadataArrayTag * ToArrayTag() const
Definition: ImageMetadata.h:211
+
MetadataError
Definition: ImageMetadata.h:46
+
Metadata
Definition: ImageMetadata.h:282
+
MetadataIndexError
Definition: ImageMetadata.h:71
+
MetadataKeyError
Definition: ImageMetadata.h:63
+
MetadataSingleTag
Definition: ImageMetadata.h:152
+
MetadataSingleTag::ToSingleTag
virtual const MetadataSingleTag * ToSingleTag() const
Definition: ImageMetadata.h:162
+
MetadataTag
Definition: ImageMetadata.h:86
+
MetadataTag::ToSingleTag
virtual const MetadataSingleTag * ToSingleTag() const
Definition: ImageMetadata.h:117
+
MetadataTag::ToArrayTag
virtual const MetadataArrayTag * ToArrayTag() const
Definition: ImageMetadata.h:122
diff --git a/_img_buffer_8h_source.html b/_img_buffer_8h_source.html index d42cc4a..b0407a9 100644 --- a/_img_buffer_8h_source.html +++ b/_img_buffer_8h_source.html @@ -117,7 +117,7 @@
70  Metadata metadata_;
71 };
ImgBuffer
Definition: ImgBuffer.h:36
-
Metadata
Definition: ImageMetadata.h:287
+
Metadata
Definition: ImageMetadata.h:282
diff --git a/_m_m_device_8h_source.html b/_m_m_device_8h_source.html index d593873..b818465 100644 --- a/_m_m_device_8h_source.html +++ b/_m_m_device_8h_source.html @@ -979,7 +979,7 @@
MM::XYStage::SetOrigin
virtual int SetOrigin()=0
MM::XYStage::SendXYStageSequence
virtual int SendXYStageSequence()=0
MM::XYStage::AddToXYStageSequence
virtual int AddToXYStageSequence(double positionX, double positionY)=0
-
Metadata
Definition: ImageMetadata.h:287
+
Metadata
Definition: ImageMetadata.h:282
diff --git a/class_c_camera_base.html b/class_c_camera_base.html index dda1785..51b6200 100644 --- a/class_c_camera_base.html +++ b/class_c_camera_base.html @@ -328,7 +328,7 @@ virtual long GetNumberOfImages ()   -virtual void OnThreadExiting () throw () +virtual void OnThreadExiting ()   virtual bool isStopOnOverflow () diff --git a/class_metadata-members.html b/class_metadata-members.html index 3ad9ecc..10fa0c8 100644 --- a/class_metadata-members.html +++ b/class_metadata-members.html @@ -48,9 +48,9 @@ - + - + diff --git a/class_metadata.html b/class_metadata.html index 21a8cab..e18dfa7 100644 --- a/class_metadata.html +++ b/class_metadata.html @@ -63,12 +63,12 @@ - - - - + + + +
Clear() (defined in Metadata)Metadatainline
Dump() (defined in Metadata)Metadatainline
GetArrayTag(const char *key) const (defined in Metadata)Metadatainline
GetArrayTag(const char *key) const MMDEVICE_LEGACY_THROW(MetadataKeyError) (defined in Metadata)Metadatainline
GetKeys() const (defined in Metadata)Metadatainline
GetSingleTag(const char *key) const (defined in Metadata)Metadatainline
GetSingleTag(const char *key) const MMDEVICE_LEGACY_THROW(MetadataKeyError) (defined in Metadata)Metadatainline
HasTag(const char *key) (defined in Metadata)Metadatainline
Merge(const Metadata &newTags) (defined in Metadata)Metadatainline
Metadata() (defined in Metadata)Metadatainline
bool HasTag (const char *key)
 
-MetadataSingleTag GetSingleTag (const char *key) const throw (MetadataKeyError)
 
-MetadataArrayTag GetArrayTag (const char *key) const throw (MetadataKeyError)
 
+MetadataSingleTag GetSingleTag (const char *key) const MMDEVICE_LEGACY_THROW(MetadataKeyError)
 
+MetadataArrayTag GetArrayTag (const char *key) const MMDEVICE_LEGACY_THROW(MetadataKeyError)
 
void SetTag (MetadataTag &tag)