UniSet  2.8.0
MTR.h
1 /*
2  * Copyright (c) 2015 Pavel Vainerman.
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License as
6  * published by the Free Software Foundation, version 2.1.
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * Lesser General Lesser Public License for more details.
12  *
13  * You should have received a copy of the GNU Lesser General Public License
14  * along with this program. If not, see <http://www.gnu.org/licenses/>.
15  */
16 // --------------------------------------------------------------------------
17 #ifndef _MTR_H_
18 #define _MTR_H_
19 // -----------------------------------------------------------------------------
20 #include <string>
21 #include <map>
22 #include <cstdint>
23 #include <unordered_map>
24 #include <list>
25 #include <ostream>
26 #include <cstring>
27 #include <cmath>
28 #include "modbus/ModbusTypes.h"
29 #include "ComPort.h"
30 // -------------------------------------------------------------------------
31 namespace uniset
32 {
33  // -----------------------------------------------------------------------------
34  class ModbusClient;
35  // -----------------------------------------------------------------------------
36  namespace MTR
37  {
38  // реализованные в данном интерфейсе типы данных
39  enum MTRType
40  {
41  mtUnknown,
42  mtT1,
43  mtT2,
44  mtT3,
45  mtT4,
46  mtT5,
47  mtT6,
48  mtT7,
49  mtT8,
50  mtT9,
51  mtT10,
52  mtT16,
53  mtT17,
54  mtF1,
55  mtT_Str16,
56  mtT_Str8
57  };
58  // -------------------------------------------------------------------------
59  std::string type2str( MTRType t );
60  MTRType str2type( const std::string& s );
61  size_t wsize( MTRType t );
62  // -------------------------------------------------------------------------
63  // Информация
64  const ModbusRTU::ModbusData regModelNumber = 0x01;
65  const ModbusRTU::ModbusData regSerialNumber = 0x09;
66 
67  std::string getModelNumber( uniset::ModbusClient* mb, ModbusRTU::ModbusAddr addr );
68  std::string getSerialNumber(uniset::ModbusClient* mb, ModbusRTU::ModbusAddr addr );
69  // -------------------------------------------------------------------------
70  // Настройки связи (чтение - read03, запись - write06)
71  const ModbusRTU::ModbusData regUpdateConfiguration = 53;
72  const ModbusRTU::ModbusData regAddress = 55;
73  const ModbusRTU::ModbusData regBaudRate = 56;
74  const ModbusRTU::ModbusData regStopBit = 57; /* 0 - Stop bit, 1 - Stop bits */
75  const ModbusRTU::ModbusData regParity = 58;
76  const ModbusRTU::ModbusData regDataBits = 59;
77 
78  enum mtrBaudRate
79  {
80  br1200 = 0,
81  br2400 = 1,
82  br4800 = 2,
83  br9600 = 3,
84  br19200 = 4,
85  br38400 = 5,
86  br57600 = 6,
87  br115200 = 7
88  };
89 
90  enum mtrParity
91  {
92  mpNoParity = 0,
93  mpOddParity = 1,
94  mpEvenParity = 2
95  };
96 
97  enum mtrDataBits
98  {
99  db8Bits = 0,
100  db7Bits = 1
101  };
102 
103  bool setAddress( uniset::ModbusClient* mb, ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusAddr newAddr );
104  bool setBaudRate(uniset::ModbusClient* mb, ModbusRTU::ModbusAddr addr, mtrBaudRate br );
105  bool setStopBit(uniset::ModbusClient* mb, ModbusRTU::ModbusAddr addr, bool state );
106  bool setParity(uniset::ModbusClient* mb, ModbusRTU::ModbusAddr addr, mtrParity p );
107  bool setDataBits( uniset::ModbusClient* mb, ModbusRTU::ModbusAddr addr, mtrDataBits d );
108  ComPort::Parity get_parity( ModbusRTU::ModbusData data );
109  ComPort::Speed get_speed( ModbusRTU::ModbusData data );
110  // -------------------------------------------------------------------------
111  enum MTRError
112  {
113  mtrNoError,
114  mtrBadDeviceType,
115  mtrDontReadConfile,
116  mtrSendParamFailed,
117  mtrUnknownError
118  };
119  std::ostream& operator<<(std::ostream& os, MTRError& e );
120  // Настройка из конф. файла
121  MTRError update_configuration( uniset::ModbusClient* mb, ModbusRTU::ModbusAddr addr,
122  const std::string& mtrconfile, int verbose = 0 );
123  // ---------------------------
124  // вспомогательные функции и типы данных
125  typedef std::list<ModbusRTU::ModbusData> DataList;
126  typedef std::unordered_map<ModbusRTU::ModbusData, DataList> DataMap;
127  const int attempts = 3; //
128  static const ModbusRTU::ModbusData skip[] = {48, 49, 59}; // registers which should not write
129 
130  bool send_param( uniset::ModbusClient* mb, DataMap& dmap, ModbusRTU::ModbusAddr addr, int verb );
131  bool read_param( const std::string& str, std::string& str1, std::string& str2 );
132  DataMap read_confile( const std::string& f );
133  void update_communication_params( ModbusRTU::ModbusAddr reg, ModbusRTU::ModbusData data,
134  uniset::ModbusClient* mb, ModbusRTU::ModbusAddr& addr, int verb );
135  // -------------------------------------------------------------------------
136  static const size_t u2size = 2;
137  // -------------------------------------------------------------------------
138  class T1
139  {
140  public:
141  T1(): val(0) {}
142  T1( uint16_t v ): val(v) {}
143  T1( const ModbusRTU::ModbusData* data ): val(data[0]) {}
144  ~T1() {}
145  // ------------------------------------------
147  static size_t wsize()
148  {
149  return 1;
150  }
152  static MTRType type()
153  {
154  return mtT1;
155  }
156  // ------------------------------------------
157  uint16_t val;
158  };
159  std::ostream& operator<<(std::ostream& os, T1& t );
160  // -------------------------------------------------------------------------
161  class T2
162  {
163  public:
164  T2(): val(0) {}
165  T2( int16_t v ): val(v) {}
166  T2( const ModbusRTU::ModbusData* data ): val(data[0]) {}
167  ~T2() {}
168  // ------------------------------------------
170  static size_t wsize()
171  {
172  return 1;
173  }
175  static MTRType type()
176  {
177  return mtT2;
178  }
179  // ------------------------------------------
180  int16_t val;
181  };
182  std::ostream& operator<<(std::ostream& os, T2& t );
183  // -------------------------------------------------------------------------
184  class T3
185  {
186  public:
187  // ------------------------------------------
189  typedef union
190  {
191  uint16_t v[u2size];
192  int32_t val; // :32
193  } T3mem;
194  // ------------------------------------------
195  // конструкторы на разные случаи...
196  T3()
197  {
198  memset(raw.v, 0, sizeof(raw.v));
199  }
200 
201  T3( int32_t i )
202  {
203  raw.val = i;
204  }
205 
206  T3( uint16_t v1, uint16_t v2 )
207  {
208  raw.v[0] = v1;
209  raw.v[1] = v2;
210  }
211 
212  T3( const ModbusRTU::ModbusData* data, size_t size )
213  {
214  if( size >= u2size )
215  {
216  // У MTR обратный порядок слов в ответе
217  raw.v[0] = data[1];
218  raw.v[1] = data[0];
219  }
220  }
221 
222  ~T3() {}
223  // ------------------------------------------
225  static size_t wsize()
226  {
227  return u2size;
228  }
230  static MTRType type()
231  {
232  return mtT3;
233  }
234  // ------------------------------------------
235  // функции преобразования к разным типам
236  operator long()
237  {
238  return raw.val;
239  }
240 
241  T3mem raw;
242  };
243  std::ostream& operator<<(std::ostream& os, T3& t );
244  // --------------------------------------------------------------------------
245  class T4
246  {
247  public:
248  // ------------------------------------------
249  // конструкторы на разные случаи...
250  T4(): sval(""), raw(0) {}
251  T4( uint16_t v1 ): raw(v1)
252  {
253  char c[3];
254  memcpy(c, &v1, 2);
255  c[2] = '\0';
256  sval = std::string(c);
257  }
258 
259  T4( const ModbusRTU::ModbusData* data ):
260  raw(data[0])
261  {
262  char c[3];
263  memcpy(c, &(data[0]), 2);
264  c[2] = '\0';
265  sval = std::string(c);
266  }
267 
268  ~T4() {}
269  // ------------------------------------------
271  static size_t wsize()
272  {
273  return 1;
274  }
276  static MTRType type()
277  {
278  return mtT4;
279  }
280  // ------------------------------------------
281  std::string sval;
282  uint16_t raw;
283  };
284  std::ostream& operator<<(std::ostream& os, T4& t );
285  // --------------------------------------------------------------------------
286  class T5
287  {
288  public:
289  // ------------------------------------------
291  typedef union
292  {
293  uint16_t v[u2size];
294  struct u_T5
295  {
296  uint32_t val: 24;
297  int8_t exp; // :8
298  } __attribute__( ( packed ) ) u2;
299  long lval;
300  } T5mem;
301  // ------------------------------------------
302  // конструкторы на разные случаи...
303  T5(): val(0)
304  {
305  memset(raw.v, 0, sizeof(raw.v));
306  }
307  T5( uint16_t v1, uint16_t v2 )
308  {
309  raw.v[0] = v1;
310  raw.v[1] = v2;
311  val = raw.u2.val * pow( (long)10, (long)raw.u2.exp );
312  }
313 
314  T5( long v )
315  {
316  raw.lval = v;
317  val = raw.u2.val * pow( (long)10, (long)raw.u2.exp );
318  }
319 
320  T5( const ModbusRTU::ModbusData* data, size_t size ): val(0)
321  {
322  if( size >= u2size )
323  {
324  // При получении данных от MTR слова необходимо перевернуть
325  raw.v[0] = data[1];
326  raw.v[1] = data[0];
327  val = raw.u2.val * pow( (long)10, (long)raw.u2.exp );
328  }
329  }
330 
331  ~T5() {}
332  // ------------------------------------------
334  static size_t wsize()
335  {
336  return u2size;
337  }
339  static MTRType type()
340  {
341  return mtT5;
342  }
343  // ------------------------------------------
344  double val;
345  T5mem raw;
346  };
347  std::ostream& operator<<(std::ostream& os, T5& t );
348  // --------------------------------------------------------------------------
349  class T6
350  {
351  public:
352  // ------------------------------------------
354  typedef union
355  {
356  uint16_t v[u2size];
357  struct u_T6
358  {
359  int32_t val: 24;
360  int8_t exp; // :8
361  } u2;
362  long lval;
363  } T6mem;
364  // ------------------------------------------
365  // конструкторы на разные случаи...
366  T6(): val(0)
367  {
368  memset(raw.v, 0, sizeof(raw.v));
369  }
370  T6( uint16_t v1, uint16_t v2 )
371  {
372  raw.v[0] = v1;
373  raw.v[1] = v2;
374  val = raw.u2.val * pow( (long)10, (long)raw.u2.exp );
375  }
376 
377  T6( long v )
378  {
379  raw.lval = v;
380  val = raw.u2.val * pow( (long)10, (long)raw.u2.exp );
381  }
382 
383  T6( const ModbusRTU::ModbusData* data, size_t size )
384  {
385  if( size >= u2size )
386  {
387  // При получении данных от MTR слова необходимо перевернуть
388  raw.v[0] = data[1];
389  raw.v[1] = data[0];
390  val = raw.u2.val * pow( (long)10, (long)raw.u2.exp );
391  }
392  }
393 
394  ~T6() {}
395  // ------------------------------------------
397  static size_t wsize()
398  {
399  return u2size;
400  }
402  static MTRType type()
403  {
404  return mtT6;
405  }
406  // ------------------------------------------
407  double val = { 0.0 };
408  T6mem raw;
409  };
410  std::ostream& operator<<(std::ostream& os, T6& t );
411  // --------------------------------------------------------------------------
412  class T7
413  {
414  public:
415  // ------------------------------------------
417  typedef union
418  {
419  uint16_t v[u2size];
420  struct u_T7
421  {
422  uint32_t val: 16;
423  uint8_t ic; // :8 - Inductive/capacitive
424  uint8_t ie; // :8 - Import/export
425  } __attribute__( ( packed ) ) u2;
426  long lval;
427  } T7mem;
428  // ------------------------------------------
429  // конструкторы на разные случаи...
430  T7(): val(0)
431  {
432  memset(raw.v, 0, sizeof(raw.v));
433  }
434  T7( uint16_t v1, uint16_t v2 )
435  {
436  raw.v[0] = v1;
437  raw.v[1] = v2;
438  val = raw.u2.val * pow( (long)10, (long) - 4 );
439  }
440  T7( const long v )
441  {
442  raw.lval = v;
443  val = raw.u2.val * pow( (long)10, (long) - 4 );
444  }
445 
446  T7( const ModbusRTU::ModbusData* data, size_t size )
447  {
448  if( size >= u2size )
449  {
450  // При получении данных от MTR слова необходимо перевернуть
451  raw.v[0] = data[1];
452  raw.v[1] = data[0];
453  val = raw.u2.val * pow( (long)10, (long) - 4 );
454  }
455  }
456 
457  ~T7() {}
458  // ------------------------------------------
460  static size_t wsize()
461  {
462  return u2size;
463  }
465  static MTRType type()
466  {
467  return mtT7;
468  }
469  // ------------------------------------------
470  double val = { 0.0 };
471  T7mem raw;
472  };
473  std::ostream& operator<<(std::ostream& os, T7& t );
474  // --------------------------------------------------------------------------
475  class T8
476  {
477  public:
478  // ------------------------------------------
480  typedef union
481  {
482  uint16_t v[u2size];
483  struct u_T8
484  {
485  uint16_t mon: 8;
486  uint16_t day: 8;
487  uint16_t hour: 8;
488  uint16_t min: 8;
489  } __attribute__( ( packed ) ) u2;
490  } T8mem;
491  // ------------------------------------------
492  // конструкторы на разные случаи...
493  T8()
494  {
495  memset(raw.v, 0, sizeof(raw.v));
496  }
497  T8( uint16_t v1, uint16_t v2 )
498  {
499  raw.v[0] = v1;
500  raw.v[1] = v2;
501  }
502 
503  T8( const ModbusRTU::ModbusData* data, size_t size )
504  {
505  if( size >= u2size )
506  {
507  // При получении данных от MTR слова необходимо перевернуть
508  raw.v[1] = data[0];
509  raw.v[0] = data[1];
510  }
511  }
512 
513  inline uint16_t day()
514  {
515  return raw.u2.day;
516  }
517  inline uint16_t mon()
518  {
519  return raw.u2.mon;
520  }
521  inline uint16_t hour()
522  {
523  return raw.u2.hour;
524  }
525  inline uint16_t min()
526  {
527  return raw.u2.min;
528  }
529 
530  ~T8() {}
531  // ------------------------------------------
533  static size_t wsize()
534  {
535  return u2size;
536  }
538  static MTRType type()
539  {
540  return mtT8;
541  }
542  // ------------------------------------------
543  T8mem raw;
544  };
545  std::ostream& operator<<(std::ostream& os, T8& t );
546  // --------------------------------------------------------------------------
547  class T9
548  {
549  public:
550  // ------------------------------------------
552  typedef union
553  {
554  uint16_t v[u2size];
555  struct u_T9
556  {
557  uint16_t hour: 8;
558  uint16_t min: 8;
559  uint16_t sec: 8;
560  uint16_t ssec: 8;
561  } __attribute__( ( packed ) ) u2;
562  } T9mem;
563  // ------------------------------------------
564  // конструкторы на разные случаи...
565  T9()
566  {
567  memset(raw.v, 0, sizeof(raw.v));
568  }
569  T9( uint16_t v1, uint16_t v2 )
570  {
571  raw.v[0] = v1;
572  raw.v[1] = v2;
573  }
574 
575  T9( const ModbusRTU::ModbusData* data, size_t size )
576  {
577  if( size >= u2size )
578  {
579  // При получении данных от MTR слова необходимо перевернуть
580  raw.v[0] = data[1];
581  raw.v[1] = data[0];
582  }
583  }
584 
585  inline uint16_t hour()
586  {
587  return raw.u2.hour;
588  }
589  inline uint16_t min()
590  {
591  return raw.u2.min;
592  }
593  inline uint16_t sec()
594  {
595  return raw.u2.sec;
596  }
597  inline uint16_t ssec()
598  {
599  return raw.u2.ssec;
600  }
601 
602  ~T9() {}
603  // ------------------------------------------
605  static size_t wsize()
606  {
607  return u2size;
608  }
610  static MTRType type()
611  {
612  return mtT9;
613  }
614  // ------------------------------------------
615  T9mem raw;
616  };
617  std::ostream& operator<<(std::ostream& os, T9& t );
618  // -------------------------------------------------------------------------
619  class T10
620  {
621  public:
622  // ------------------------------------------
624  typedef union
625  {
626  uint16_t v[u2size];
627  struct u_T10
628  {
629  uint16_t year: 16;
630  uint16_t mon: 8;
631  uint16_t day: 8;
632  } __attribute__( ( packed ) ) u2;
633  } T10mem;
634  // ------------------------------------------
635  // конструкторы на разные случаи...
636  T10()
637  {
638  memset(raw.v, 0, sizeof(raw.v));
639  }
640  T10( uint16_t v1, uint16_t v2 )
641  {
642  raw.v[0] = v1;
643  raw.v[1] = v2;
644  }
645 
646  T10( const ModbusRTU::ModbusData* data, size_t size )
647  {
648  if( size >= u2size )
649  {
650  // При получении данных от MTR слова необходимо перевернуть
651  raw.v[0] = data[1];
652  raw.v[1] = data[0];
653  }
654  }
655 
656  inline uint16_t year()
657  {
658  return raw.u2.year;
659  }
660  inline uint16_t mon()
661  {
662  return raw.u2.mon;
663  }
664  inline uint16_t day()
665  {
666  return raw.u2.day;
667  }
668 
669  ~T10() {}
670  // ------------------------------------------
672  static size_t wsize()
673  {
674  return u2size;
675  }
677  static MTRType type()
678  {
679  return mtT10;
680  }
681  // ------------------------------------------
682  T10mem raw;
683  };
684  std::ostream& operator<<(std::ostream& os, T10& t );
685  // --------------------------------------------------------------------------
686 
687  class T16
688  {
689  public:
690  T16(): val(0) {}
691  T16( uint16_t v ): val(v)
692  {
693  fval = (float)(val) / 100.0;
694  }
695  T16( const ModbusRTU::ModbusData* data ): val(data[0])
696  {
697  fval = (float)(val) / 100.0;
698  }
699  T16( float f ): fval(f)
700  {
701  val = lroundf(fval * 100);
702  }
703 
704  ~T16() {}
705  // ------------------------------------------
707  static size_t wsize()
708  {
709  return 1;
710  }
712  static MTRType type()
713  {
714  return mtT16;
715  }
716  // ------------------------------------------
717  operator float()
718  {
719  return fval;
720  }
721  operator uint16_t()
722  {
723  return val;
724  }
725 
726  uint16_t val = { 0 };
727  float fval = { 0.0 };
728  };
729  std::ostream& operator<<(std::ostream& os, T16& t );
730  // --------------------------------------------------------------------------
731  class T17
732  {
733  public:
734  T17(): val(0) {}
735  T17( int16_t v ): val(v)
736  {
737  fval = (float)(v) / 100.0;
738  }
739  T17( uint16_t v ): val(v)
740  {
741  fval = (float)( (int16_t)(v) ) / 100.0;
742  }
743 
744  T17( const ModbusRTU::ModbusData* data ): val(data[0])
745  {
746  fval = (float)(val) / 100.0;
747  }
748  T17( float f ): fval(f)
749  {
750  val = lroundf(fval * 100);
751  }
752  ~T17() {}
753  // ------------------------------------------
755  static size_t wsize()
756  {
757  return 1;
758  }
760  static MTRType type()
761  {
762  return mtT17;
763  }
764  // ------------------------------------------
765  operator float()
766  {
767  return fval;
768  }
769  operator int16_t()
770  {
771  return val;
772  }
773 
774  int16_t val = { 0 };
775  float fval = { 0 };
776  };
777  std::ostream& operator<<(std::ostream& os, T17& t );
778  // --------------------------------------------------------------------------
779  class F1
780  {
781  public:
782  // ------------------------------------------
784  typedef union
785  {
786  uint16_t v[2];
787  float val; //
788  } F1mem;
789  // ------------------------------------------
790  // конструкторы на разные случаи...
791  F1()
792  {
793  memset(raw.v, 0, sizeof(raw.v));
794  }
795  F1( uint16_t v1, uint16_t v2 )
796  {
797  raw.v[0] = v1;
798  raw.v[1] = v2;
799  }
800 
801  F1( float f )
802  {
803  raw.val = f;
804  }
805 
806  F1( const ModbusRTU::ModbusData* data, size_t size )
807  {
808  if( size >= u2size )
809  {
810  // При получении данных от MTR слова необходимо перевернуть
811  raw.v[0] = data[1];
812  raw.v[1] = data[0];
813  }
814  }
815 
816  ~F1() {}
817  // ------------------------------------------
819  static size_t wsize()
820  {
821  return u2size;
822  }
824  static MTRType type()
825  {
826  return mtF1;
827  }
828  // ------------------------------------------
829  operator float()
830  {
831  return raw.val;
832  }
833  operator long()
834  {
835  return lroundf(raw.val);
836  }
837 
838  F1mem raw;
839  };
840  std::ostream& operator<<(std::ostream& os, F1& t );
841  // --------------------------------------------------------------------------
842  class T_Str16
843  {
844  public:
845  // ------------------------------------------
846  // конструкторы на разные случаи...
847  T_Str16(): sval("") {}
849  {
850  char c[17];
851  ModbusRTU::ModbusData data[8];
852 
853  for( int i = 0; i < 8; i++ )
854  data[i] = ModbusRTU::SWAPSHORT(ret.data[i]);
855 
856  memcpy(c, &data, 16);
857  c[16] = '\0';
858  sval = std::string(c);
859  }
860 
861  ~T_Str16() {}
862  // ------------------------------------------
864  static size_t wsize()
865  {
866  return 8;
867  }
869  static MTRType type()
870  {
871  return mtT_Str16;
872  }
873  // ------------------------------------------
874  std::string sval;
875  };
876  std::ostream& operator<<(std::ostream& os, T_Str16& t );
877  // --------------------------------------------------------------------------
878 
879  class T_Str8
880  {
881  public:
882  // ------------------------------------------
883  // конструкторы на разные случаи...
884  T_Str8(): sval("") {}
886  {
887  char c[9];
888  ModbusRTU::ModbusData data[4];
889 
890  for( int i = 0; i < 4; i++ )
891  data[i] = ModbusRTU::SWAPSHORT(ret.data[i]);
892 
893  memcpy(c, &data, 8);
894  c[8] = '\0';
895  sval = std::string(c);
896  }
897 
898  ~T_Str8() {}
899  // ------------------------------------------
901  static size_t wsize()
902  {
903  return 4;
904  }
906  static MTRType type()
907  {
908  return mtT_Str8;
909  }
910  // ------------------------------------------
911  std::string sval;
912  };
913  std::ostream& operator<<(std::ostream& os, T_Str8& t );
914  // --------------------------------------------------------------------------
915  } // end of namespace MTR
916  // --------------------------------------------------------------------------
917 } // end of namespace uniset
918 // --------------------------------------------------------------------------
919 #endif // _MTR_H_
920 // -----------------------------------------------------------------------------
Definition: MTR.h:420
static MTRType type()
Definition: MTR.h:339
Definition: CommonEventLoop.h:14
static MTRType type()
Definition: MTR.h:869
static size_t wsize()
Definition: MTR.h:170
Definition: MTR.h:291
Definition: ModbusClient.h:18
static size_t wsize()
Definition: MTR.h:707
Definition: MTR.h:627
Definition: MTR.h:475
Definition: MTR.h:731
static MTRType type()
Definition: MTR.h:402
Definition: MTR.h:624
Definition: MTR.h:687
static MTRType type()
Definition: MTR.h:465
Definition: MTR.h:245
Definition: ModbusTypes.h:664
Definition: MTR.h:161
static size_t wsize()
Definition: MTR.h:864
Definition: MTR.h:480
static MTRType type()
Definition: MTR.h:906
static MTRType type()
Definition: MTR.h:677
Definition: MTR.h:412
static MTRType type()
Definition: MTR.h:175
Definition: MTR.h:354
Definition: MTR.h:357
static MTRType type()
Definition: MTR.h:760
static size_t wsize()
Definition: MTR.h:397
static size_t wsize()
Definition: MTR.h:271
Definition: MTR.h:184
Definition: MTR.h:842
Definition: MTR.h:138
Definition: MTR.h:879
Definition: MTR.h:417
Definition: MTR.h:552
static size_t wsize()
Definition: MTR.h:147
Definition: MTR.h:189
Definition: MTR.h:779
Definition: MTR.h:294
static size_t wsize()
Definition: MTR.h:672
static MTRType type()
Definition: MTR.h:538
static size_t wsize()
Definition: MTR.h:225
Definition: MTR.h:619
static MTRType type()
Definition: MTR.h:610
static MTRType type()
Definition: MTR.h:152
static size_t wsize()
Definition: MTR.h:533
Definition: MTR.h:555
static size_t wsize()
Definition: MTR.h:755
Definition: MTR.h:349
static size_t wsize()
Definition: MTR.h:901
static size_t wsize()
Definition: MTR.h:460
static size_t wsize()
Definition: MTR.h:605
static MTRType type()
Definition: MTR.h:230
Definition: MTR.h:547
static MTRType type()
Definition: MTR.h:712
Definition: MTR.h:784
static MTRType type()
Definition: MTR.h:824
Definition: MTR.h:483
static MTRType type()
Definition: MTR.h:276
static size_t wsize()
Definition: MTR.h:334
static size_t wsize()
Definition: MTR.h:819
Definition: MTR.h:286