PCL
MetaParameter.h
Go to the documentation of this file.
1 // ____ ______ __
2 // / __ \ / ____// /
3 // / /_/ // / / /
4 // / ____// /___ / /___ PixInsight Class Library
5 // /_/ \____//_____/ PCL 2.4.0
6 // ----------------------------------------------------------------------------
7 // pcl/MetaParameter.h - Released 2020-08-25T19:17:02Z
8 // ----------------------------------------------------------------------------
9 // This file is part of the PixInsight Class Library (PCL).
10 // PCL is a multiplatform C++ framework for development of PixInsight modules.
11 //
12 // Copyright (c) 2003-2020 Pleiades Astrophoto S.L. All Rights Reserved.
13 //
14 // Redistribution and use in both source and binary forms, with or without
15 // modification, is permitted provided that the following conditions are met:
16 //
17 // 1. All redistributions of source code must retain the above copyright
18 // notice, this list of conditions and the following disclaimer.
19 //
20 // 2. All redistributions in binary form must reproduce the above copyright
21 // notice, this list of conditions and the following disclaimer in the
22 // documentation and/or other materials provided with the distribution.
23 //
24 // 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
25 // of their contributors, may be used to endorse or promote products derived
26 // from this software without specific prior written permission. For written
27 // permission, please contact info@pixinsight.com.
28 //
29 // 4. All products derived from this software, in any form whatsoever, must
30 // reproduce the following acknowledgment in the end-user documentation
31 // and/or other materials provided with the product:
32 //
33 // "This product is based on software from the PixInsight project, developed
34 // by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
35 //
36 // Alternatively, if that is where third-party acknowledgments normally
37 // appear, this acknowledgment must be reproduced in the product itself.
38 //
39 // THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
40 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
41 // TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
43 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
44 // EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
45 // INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
46 // DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
47 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
49 // POSSIBILITY OF SUCH DAMAGE.
50 // ----------------------------------------------------------------------------
51 
52 #ifndef __PCL_MetaParameter_h
53 #define __PCL_MetaParameter_h
54 
56 
57 #ifndef __PCL_BUILDING_PIXINSIGHT_APPLICATION
58 
59 #include <pcl/Defs.h>
60 
61 #include <pcl/MetaObject.h>
62 #include <pcl/String.h>
63 
64 #include <float.h> // DBL_MAX
65 
66 namespace pcl
67 {
68 
69 // ----------------------------------------------------------------------------
70 
71 class PCL_CLASS MetaProcess;
72 class PCL_CLASS MetaTable;
73 
74 // ----------------------------------------------------------------------------
75 
99 class PCL_CLASS MetaParameter : public MetaObject
100 {
101 public:
102 
108 
114  MetaParameter( MetaTable* T );
115 
119  virtual ~MetaParameter() noexcept( false )
120  {
121  }
122 
132  virtual IsoString Id() const = 0;
133 
159  virtual IsoString Aliases() const
160  {
161  return IsoString();
162  }
163 
175  virtual bool NeedsUnlocking() const
176  {
177  return false;
178  }
179 
203  virtual bool NeedsValidation() const
204  {
205  return false;
206  }
207 
208  // ### Undocumented
209  virtual uint32 FirstProcessVersion() const
210  {
211  return 0;
212  }
213 
214  // ### Undocumented
215  virtual uint32 LastProcessVersion() const
216  {
217  return 0;
218  }
219 
242  virtual bool IsRequired() const
243  {
244  return false;
245  }
246 
268  virtual bool IsReadOnly() const
269  {
270  return false;
271  }
272 
284  virtual String Description() const
285  {
286  return String();
287  }
288 
303  virtual String Comment() const
304  {
305  return String();
306  }
307 
313  virtual bool IsNumeric() const
314  {
315  return false;
316  }
317 
323  virtual bool IsBoolean() const
324  {
325  return false;
326  }
327 
333  virtual bool IsEnumeration() const
334  {
335  return false;
336  }
337 
343  virtual bool IsVariableLength() const
344  {
345  return false;
346  }
347 
352  virtual bool IsString() const
353  {
354  return false;
355  }
356 
361  virtual bool IsTable() const
362  {
363  return false;
364  }
365 
370  virtual bool IsBlock() const
371  {
372  return false;
373  }
374 
375 protected:
376 
377  void PerformAPIDefinitions() const override;
378 
379  virtual void PerformTypeAPIDefinitions() const
380  {
381  }
382 
383  virtual uint32 APIParType() const = 0;
384 
385  static bool inTableDefinition;
386 
387  friend class MetaTable;
388  friend class MetaProcess;
389 };
390 
391 // ----------------------------------------------------------------------------
392 
413 class PCL_CLASS MetaNumeric : public MetaParameter
414 {
415 public:
416 
422  : MetaParameter( P )
423  {
424  }
425 
433  : MetaParameter( T )
434  {
435  }
436 
440  virtual ~MetaNumeric() noexcept( false )
441  {
442  }
443 
446  bool IsNumeric() const override
447  {
448  return true;
449  }
450 
453  virtual IsoString Id() const override = 0;
454 
460  virtual bool IsReal() const
461  {
462  return false;
463  }
464 
470  virtual bool IsInteger() const
471  {
472  return false;
473  }
474 
481  virtual double DefaultValue() const
482  {
483  return 0;
484  }
485 
493  virtual double MinimumValue() const
494  {
495  return -DBL_MAX;
496  }
497 
505  virtual double MaximumValue() const
506  {
507  return +DBL_MAX;
508  }
509 
510 protected:
511 
512  void PerformTypeAPIDefinitions() const override;
513  virtual uint32 APIParType() const override = 0;
514 };
515 
516 // ----------------------------------------------------------------------------
517 
532 class PCL_CLASS MetaInteger : public MetaNumeric
533 {
534 public:
535 
541  : MetaNumeric( P )
542  {
543  }
544 
552  : MetaNumeric( T )
553  {
554  }
555 
559  virtual ~MetaInteger() noexcept( false )
560  {
561  }
562 
565  bool IsInteger() const override
566  {
567  return true;
568  }
569 
572  virtual IsoString Id() const override = 0;
573 
578  virtual bool IsSigned() const = 0;
579 
580 private:
581 
582  virtual uint32 APIParType() const override = 0;
583 };
584 
585 // ----------------------------------------------------------------------------
586 
595 class PCL_CLASS MetaUnsignedInteger : public MetaInteger
596 {
597 public:
598 
604  : MetaInteger( P )
605  {
606  }
607 
615  : MetaInteger( T )
616  {
617  }
618 
622  virtual ~MetaUnsignedInteger() noexcept( false )
623  {
624  }
625 
628  bool IsSigned() const override
629  {
630  return false;
631  }
632 
635  virtual IsoString Id() const override = 0;
636 
637 private:
638 
639  virtual uint32 APIParType() const override = 0;
640 };
641 
642 // ----------------------------------------------------------------------------
643 
652 class PCL_CLASS MetaSignedInteger : public MetaInteger
653 {
654 public:
655 
661  : MetaInteger( P )
662  {
663  }
664 
672  : MetaInteger( T )
673  {
674  }
675 
679  virtual ~MetaSignedInteger() noexcept( false )
680  {
681  }
682 
685  bool IsSigned() const override
686  {
687  return true;
688  }
689 
692  virtual IsoString Id() const override = 0;
693 
694 private:
695 
696  virtual uint32 APIParType() const override = 0;
697 };
698 
699 // ----------------------------------------------------------------------------
700 
709 class PCL_CLASS MetaUInt8 : public MetaUnsignedInteger
710 {
711 public:
712 
718  : MetaUnsignedInteger( P )
719  {
720  }
721 
729  : MetaUnsignedInteger( T )
730  {
731  }
732 
736  virtual ~MetaUInt8() noexcept( false )
737  {
738  }
739 
742  virtual IsoString Id() const override = 0;
743 
744 private:
745 
746  uint32 APIParType() const override;
747 };
748 
749 // ----------------------------------------------------------------------------
750 
759 class PCL_CLASS MetaUInt16 : public MetaUnsignedInteger
760 {
761 public:
762 
768  : MetaUnsignedInteger( P )
769  {
770  }
771 
779  : MetaUnsignedInteger( T )
780  {
781  }
782 
786  virtual ~MetaUInt16() noexcept( false )
787  {
788  }
789 
792  virtual IsoString Id() const override = 0;
793 
794 private:
795 
796  uint32 APIParType() const override;
797 };
798 
799 // ----------------------------------------------------------------------------
800 
809 class PCL_CLASS MetaUInt32 : public MetaUnsignedInteger
810 {
811 public:
812 
818  : MetaUnsignedInteger( P )
819  {
820  }
821 
829  : MetaUnsignedInteger( T )
830  {
831  }
832 
836  virtual ~MetaUInt32() noexcept( false )
837  {
838  }
839 
842  virtual IsoString Id() const override = 0;
843 
844 private:
845 
846  uint32 APIParType() const override;
847 };
848 
849 // ----------------------------------------------------------------------------
850 
859 class PCL_CLASS MetaUInt64 : public MetaUnsignedInteger
860 {
861 public:
862 
868  : MetaUnsignedInteger( P )
869  {
870  }
871 
879  : MetaUnsignedInteger( T )
880  {
881  }
882 
886  virtual ~MetaUInt64() noexcept( false )
887  {
888  }
889 
890  virtual IsoString Id() const override = 0;
891 
892 private:
893 
894  uint32 APIParType() const override;
895 };
896 
897 // ----------------------------------------------------------------------------
898 
907 class PCL_CLASS MetaInt8 : public MetaSignedInteger
908 {
909 public:
910 
916  : MetaSignedInteger( P )
917  {
918  }
919 
927  : MetaSignedInteger( T )
928  {
929  }
930 
934  virtual ~MetaInt8() noexcept( false )
935  {
936  }
937 
940  virtual IsoString Id() const override = 0;
941 
942 private:
943 
944  uint32 APIParType() const override;
945 };
946 
947 // ----------------------------------------------------------------------------
948 
958 {
959 public:
960 
966  : MetaSignedInteger( P )
967  {
968  }
969 
977  : MetaSignedInteger( T )
978  {
979  }
980 
984  virtual ~MetaInt16() noexcept( false )
985  {
986  }
987 
990  virtual IsoString Id() const override = 0;
991 
992 private:
993 
994  uint32 APIParType() const override;
995 };
996 
997 // ----------------------------------------------------------------------------
998 
1007 class PCL_CLASS MetaInt32 : public MetaSignedInteger
1008 {
1009 public:
1010 
1016  : MetaSignedInteger( P )
1017  {
1018  }
1019 
1027  : MetaSignedInteger( T )
1028  {
1029  }
1030 
1034  virtual ~MetaInt32() noexcept( false )
1035  {
1036  }
1037 
1040  virtual IsoString Id() const override = 0;
1041 
1042 private:
1043 
1044  uint32 APIParType() const override;
1045 };
1046 
1047 // ----------------------------------------------------------------------------
1048 
1057 class PCL_CLASS MetaInt64 : public MetaSignedInteger
1058 {
1059 public:
1060 
1066  : MetaSignedInteger( p )
1067  {
1068  }
1069 
1077  : MetaSignedInteger( t )
1078  {
1079  }
1080 
1084  virtual ~MetaInt64() noexcept( false )
1085  {
1086  }
1087 
1090  virtual IsoString Id() const override = 0;
1091 
1092 private:
1093 
1094  uint32 APIParType() const override;
1095 };
1096 
1097 // ----------------------------------------------------------------------------
1098 
1107 class PCL_CLASS MetaReal : public MetaNumeric
1108 {
1109 public:
1110 
1116  : MetaNumeric( P )
1117  {
1118  }
1119 
1127  : MetaNumeric( T )
1128  {
1129  }
1130 
1134  virtual ~MetaReal() noexcept( false )
1135  {
1136  }
1137 
1140  bool IsReal() const override
1141  {
1142  return true;
1143  }
1144 
1175  virtual int Precision() const
1176  {
1177  return -1; // printf's g format
1178  }
1179 
1193  virtual bool ScientificNotation() const
1194  {
1195  return false;
1196  }
1197 
1200  virtual IsoString Id() const override = 0;
1201 
1202 private:
1203 
1204  void PerformTypeAPIDefinitions() const override;
1205  virtual uint32 APIParType() const override = 0;
1206 };
1207 
1208 // ----------------------------------------------------------------------------
1209 
1219 class PCL_CLASS MetaFloat : public MetaReal
1220 {
1221 public:
1222 
1228  : MetaReal( P )
1229  {
1230  }
1231 
1239  : MetaReal( T )
1240  {
1241  }
1242 
1246  virtual ~MetaFloat() noexcept( false )
1247  {
1248  }
1249 
1252  virtual IsoString Id() const override = 0;
1253 
1254 private:
1255 
1256  uint32 APIParType() const override;
1257 };
1258 
1259 // ----------------------------------------------------------------------------
1260 
1270 class PCL_CLASS MetaDouble : public MetaReal
1271 {
1272 public:
1273 
1279  : MetaReal( P )
1280  {
1281  }
1282 
1290  : MetaReal( T )
1291  {
1292  }
1293 
1297  virtual ~MetaDouble() noexcept( false )
1298  {
1299  }
1300 
1303  virtual IsoString Id() const override = 0;
1304 
1305 private:
1306 
1307  uint32 APIParType() const override;
1308 };
1309 
1310 // ----------------------------------------------------------------------------
1311 
1328 class PCL_CLASS MetaBoolean : public MetaParameter
1329 {
1330 public:
1331 
1337  : MetaParameter( P )
1338  {
1339  }
1340 
1348  : MetaParameter( T )
1349  {
1350  }
1351 
1355  virtual ~MetaBoolean() noexcept( false )
1356  {
1357  }
1358 
1361  bool IsBoolean() const override
1362  {
1363  return true;
1364  }
1365 
1372  virtual bool DefaultValue() const
1373  {
1374  return false;
1375  }
1376 
1379  virtual IsoString Id() const override = 0;
1380 
1381 private:
1382 
1383  void PerformTypeAPIDefinitions() const override;
1384  uint32 APIParType() const override;
1385 };
1386 
1405 class PCL_CLASS pcl_bool
1406 {
1407 public:
1408 
1413  pcl_bool() = default;
1414 
1421  template <typename T> pcl_bool( const T& value )
1422  : m_value( value ? 1 : 0 )
1423  {
1424  }
1425 
1432  template <typename T> pcl_bool& operator =( const T& value )
1433  {
1434  m_value = value ? 1 : 0;
1435  return *this;
1436  }
1437 
1442  constexpr operator bool() const
1443  {
1444  return m_value != 0;
1445  }
1446 
1447 #ifndef _MSC_VER
1448 
1453  constexpr operator int() const
1454  {
1455  return int( m_value );
1456  }
1457 
1458 #endif // !_MSC_VER
1459 
1460  constexpr bool operator ==( const pcl_bool& b ) const
1461  {
1462  return m_value == b.m_value;
1463  }
1464 
1465  constexpr bool operator <( const pcl_bool& b ) const
1466  {
1467  return m_value < b.m_value;
1468  }
1469 
1470 private:
1471 
1472  int32 m_value = 0; // MetaBoolean equivalent type
1473 };
1474 
1475 // ----------------------------------------------------------------------------
1476 
1494 class PCL_CLASS MetaEnumeration : public MetaParameter
1495 {
1496 public:
1497 
1503  : MetaParameter( P )
1504  {
1505  }
1506 
1514  : MetaParameter( T )
1515  {
1516  }
1517 
1521  virtual ~MetaEnumeration() noexcept( false )
1522  {
1523  }
1524 
1527  bool IsEnumeration() const override
1528  {
1529  return true;
1530  }
1531 
1534  virtual IsoString Id() const override = 0;
1535 
1544  virtual size_type NumberOfElements() const = 0;
1545 
1559  virtual IsoString ElementId( size_type idx ) const = 0;
1560 
1571  virtual int ElementValue( size_type idx ) const = 0;
1572 
1584  {
1585  return 0;
1586  }
1587 
1614  virtual IsoString ElementAliases() const
1615  {
1616  return IsoString();
1617  }
1618 
1619 private:
1620 
1621  void PerformTypeAPIDefinitions() const override;
1622  uint32 APIParType() const override;
1623 };
1624 
1638 typedef int32 pcl_enum;
1639 
1640 // ----------------------------------------------------------------------------
1641 
1650 {
1651 public:
1652 
1658  : MetaParameter( P )
1659  {
1660  }
1661 
1669  : MetaParameter( T )
1670  {
1671  }
1672 
1676  virtual ~MetaVariableLengthParameter() noexcept( false )
1677  {
1678  }
1679 
1682  bool IsVariableLength() const override
1683  {
1684  return true;
1685  }
1686 
1689  virtual IsoString Id() const override = 0;
1690 
1698  virtual size_type MinLength() const
1699  {
1700  return 0; // can be empty
1701  }
1702 
1713  virtual size_type MaxLength() const
1714  {
1715  return 0; // unlimited length
1716  }
1717 
1718 private:
1719 
1720  virtual void PerformTypeAPIDefinitions() const override = 0;
1721  virtual uint32 APIParType() const override = 0;
1722 };
1723 
1724 // ----------------------------------------------------------------------------
1725 
1733 class PCL_CLASS MetaString : public MetaVariableLengthParameter
1734 {
1735 public:
1736 
1743  {
1744  }
1745 
1754  {
1755  }
1756 
1760  virtual ~MetaString() noexcept( false )
1761  {
1762  }
1763 
1766  bool IsString() const override
1767  {
1768  return true;
1769  }
1770 
1773  virtual IsoString Id() const override = 0;
1774 
1785  virtual String DefaultValue() const
1786  {
1787  return String();
1788  }
1789 
1800  virtual String AllowedCharacters() const
1801  {
1802  return String(); // any character is valid
1803  }
1804 
1805 private:
1806 
1807  void PerformTypeAPIDefinitions() const override;
1808  uint32 APIParType() const override;
1809 };
1810 
1811 // ----------------------------------------------------------------------------
1812 
1825 class PCL_CLASS MetaTable : public MetaVariableLengthParameter
1826 {
1827 public:
1828 
1835  {
1836  }
1837 
1841  virtual ~MetaTable() noexcept( false )
1842  {
1843  }
1844 
1847  bool IsTable() const override
1848  {
1849  return true;
1850  }
1851 
1854  virtual IsoString Id() const override = 0;
1855 
1863  const MetaParameter* operator[]( size_type i ) const;
1864 
1865 private:
1866 
1867  // Nested tables are not allowed.
1868  MetaTable( MetaTable* );
1869 
1870  void PerformTypeAPIDefinitions() const override;
1871  uint32 APIParType() const override;
1872 };
1873 
1874 // ----------------------------------------------------------------------------
1875 
1888 class PCL_CLASS MetaBlock : public MetaVariableLengthParameter
1889 {
1890 public:
1891 
1898  {
1899  }
1900 
1909  {
1910  }
1911 
1915  virtual ~MetaBlock() noexcept( false )
1916  {
1917  }
1918 
1921  bool IsBlock() const override
1922  {
1923  return true;
1924  }
1925 
1928  virtual IsoString Id() const override = 0;
1929 
1953  {
1954  DataAsUInt8, // 8-bit unsigned integers
1955  DataAsInt8, // 8-bit signed integers
1956  DataAsUInt16, // 16-bit unsigned integers
1957  DataAsInt16, // 16-bit signed integers
1958  DataAsUInt32, // 32-bit unsigned integers
1959  DataAsInt32, // 32-bit signed integers
1960  DataAsUInt64, // 64-bit unsigned integers
1961  DataAsInt64, // 64-bit signed integers
1962  DataAsFloat, // float (32-bit IEEE 754 floating point)
1963  DataAsDouble // double (64-bit IEEE 754 floating point)
1964  };
1965 
1980  {
1981  return DataAsUInt8;
1982  }
1983 
1984 private:
1985 
1986  void PerformTypeAPIDefinitions() const override;
1987  uint32 APIParType() const override;
1988 };
1989 
1990 // ----------------------------------------------------------------------------
1991 
1992 } // pcl
1993 
1994 #endif // __PCL_BUILDING_PIXINSIGHT_APPLICATION
1995 
1996 #endif // __PCL_MetaParameter_h
1997 
1998 // ----------------------------------------------------------------------------
1999 // EOF pcl/MetaParameter.h - Released 2020-08-25T19:17:02Z
Root base class for all PixInsight module components.
Definition: MetaObject.h:85
virtual bool DefaultValue() const
virtual ~MetaTable() noexcept(false)
MetaBlock(MetaTable *t)
MetaFloat(MetaTable *T)
virtual bool NeedsValidation() const
A formal description of a 64-bit IEEE 754 floating point process parameter.
bool IsBlock() const override
A formal description of a real process parameter.
virtual String DefaultValue() const
virtual bool IsTable() const
A formal description of an enumerated process parameter.
MetaInt16(MetaProcess *P)
pcl_bool(const T &value)
MetaSignedInteger(MetaTable *T)
virtual bool ScientificNotation() const
virtual double MinimumValue() const
MetaUInt8(MetaTable *T)
A formal description of an integer process parameter.
virtual bool IsInteger() const
MetaTable(MetaProcess *P)
virtual bool IsNumeric() const
A formal description of a block process parameter.
PCL root namespace.
Definition: AbstractImage.h:76
MetaUInt32(MetaTable *T)
virtual ~MetaUnsignedInteger() noexcept(false)
MetaInt8(MetaProcess *P)
bool IsVariableLength() const override
A formal description of a 32-bit signed integer process parameter.
MetaEnumeration(MetaProcess *P)
MetaUInt32(MetaProcess *P)
A formal description of a 16-bit signed integer process parameter.
virtual ~MetaBlock() noexcept(false)
A formal description of a variable length process parameter.
A formal description of an unsigned integer process parameter.
virtual String AllowedCharacters() const
String Id(value_type operation)
virtual bool IsBlock() const
virtual ~MetaUInt64() noexcept(false)
A formal description of a string process parameter.
virtual bool NeedsUnlocking() const
MetaReal(MetaTable *T)
bool IsBoolean() const override
A formal description of a signed integer process parameter.
MetaUInt16(MetaTable *T)
MetaEnumeration(MetaTable *T)
MetaBoolean(MetaTable *T)
virtual ~MetaSignedInteger() noexcept(false)
virtual size_type MaxLength() const
A formal description of a table process parameter.
virtual int Precision() const
bool IsNumeric() const override
MetaDouble(MetaTable *T)
MetaUInt64(MetaTable *T)
MetaSignedInteger(MetaProcess *P)
virtual bool IsReal() const
A formal description of an 8-bit signed integer process parameter.
MetaInt64(MetaProcess *p)
size_t size_type
Definition: Defs.h:543
bool IsInteger() const override
MetaUnsignedInteger(MetaTable *T)
virtual ~MetaInt32() noexcept(false)
virtual ~MetaInt16() noexcept(false)
virtual IsoString ElementAliases() const
bool IsSigned() const override
bool IsReal() const override
A formal description of a 16-bit unsigned integer process parameter.
Unicode (UTF-16) string.
Definition: String.h:7916
A formal description of a 32-bit IEEE 754 floating point process parameter.
MetaBlock(MetaProcess *p)
MetaNumeric(MetaTable *T)
virtual ~MetaBoolean() noexcept(false)
MetaUInt64(MetaProcess *P)
bool IsString() const override
MetaString(MetaTable *T)
virtual ~MetaFloat() noexcept(false)
virtual String Description() const
virtual size_type DefaultValueIndex() const
virtual size_type MinLength() const
virtual bool IsReadOnly() const
MetaInt8(MetaTable *T)
signed int int32
Definition: Defs.h:594
virtual ~MetaInt64() noexcept(false)
MetaString(MetaProcess *P)
virtual bool IsString() const
MetaDouble(MetaProcess *P)
bool operator<(const Array< T, A > &x1, const Array< T, A > &x2)
Definition: Array.h:2103
bool IsEnumeration() const override
MetaInt32(MetaProcess *P)
A formal description of an 8-bit unsigned integer process parameter.
virtual data_interpretation DataInterpretation() const
virtual ~MetaNumeric() noexcept(false)
A formal description of a 64-bit signed integer process parameter.
virtual ~MetaEnumeration() noexcept(false)
MetaUInt8(MetaProcess *P)
MetaNumeric(MetaProcess *P)
MetaUInt16(MetaProcess *P)
virtual bool IsBoolean() const
MetaInt64(MetaTable *t)
virtual ~MetaInteger() noexcept(false)
virtual bool IsEnumeration() const
virtual ~MetaUInt8() noexcept(false)
MetaInteger(MetaTable *T)
MetaFloat(MetaProcess *P)
virtual ~MetaUInt16() noexcept(false)
virtual ~MetaVariableLengthParameter() noexcept(false)
virtual ~MetaString() noexcept(false)
MetaBoolean(MetaProcess *P)
A formal description of a 64-bit unsigned integer process parameter.
virtual bool IsRequired() const
virtual ~MetaParameter() noexcept(false)
virtual ~MetaInt8() noexcept(false)
virtual double DefaultValue() const
MetaInteger(MetaProcess *P)
MetaUnsignedInteger(MetaProcess *P)
virtual bool IsVariableLength() const
bool operator==(const Array< T, A > &x1, const Array< T, A > &x2)
Definition: Array.h:2092
MetaInt32(MetaTable *T)
virtual String Comment() const
virtual ~MetaUInt32() noexcept(false)
A formal description of a Boolean process parameter.
virtual IsoString Aliases() const
MetaVariableLengthParameter(MetaProcess *P)
MetaInt16(MetaTable *T)
bool IsSigned() const override
int32 pcl_enum
An integer type that can be safely used to implement enumerated process parameters on all supported p...
virtual ~MetaReal() noexcept(false)
A first-class data type that can be safely used to implement Boolean process parameters on all suppor...
A formal description of a numeric process parameter.
unsigned int uint32
Definition: Defs.h:600
bool IsTable() const override
Root base class for PCL classes providing formal descriptions of process parameters.
Definition: MetaParameter.h:99
virtual double MaximumValue() const
virtual ~MetaDouble() noexcept(false)
A formal description of a PixInsight process.
Definition: MetaProcess.h:106
A formal description of a 32-bit unsigned integer process parameter.
MetaReal(MetaProcess *P)
Eight-bit string (ISO/IEC-8859-1 or UTF-8 string)
Definition: String.h:5390