PCL
MetaParameter.h
Go to the documentation of this file.
1 // ____ ______ __
2 // / __ \ / ____// /
3 // / /_/ // / / /
4 // / ____// /___ / /___ PixInsight Class Library
5 // /_/ \____//_____/ PCL 2.1.19
6 // ----------------------------------------------------------------------------
7 // pcl/MetaParameter.h - Released 2019-11-07T10:59:34Z
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-2019 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 (http://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  {
423  }
424 
432  {
433  }
434 
438  virtual ~MetaNumeric() noexcept( false )
439  {
440  }
441 
444  bool IsNumeric() const override
445  {
446  return true;
447  }
448 
451  virtual IsoString Id() const override = 0;
452 
458  virtual bool IsReal() const
459  {
460  return false;
461  }
462 
468  virtual bool IsInteger() const
469  {
470  return false;
471  }
472 
479  virtual double DefaultValue() const
480  {
481  return 0;
482  }
483 
491  virtual double MinimumValue() const
492  {
493  return -DBL_MAX;
494  }
495 
503  virtual double MaximumValue() const
504  {
505  return +DBL_MAX;
506  }
507 
508 protected:
509 
510  void PerformTypeAPIDefinitions() const override;
511  virtual uint32 APIParType() const override = 0;
512 };
513 
514 // ----------------------------------------------------------------------------
515 
530 class PCL_CLASS MetaInteger : public MetaNumeric
531 {
532 public:
533 
539  {
540  }
541 
549  {
550  }
551 
555  virtual ~MetaInteger() noexcept( false )
556  {
557  }
558 
561  bool IsInteger() const override
562  {
563  return true;
564  }
565 
568  virtual IsoString Id() const override = 0;
569 
574  virtual bool IsSigned() const = 0;
575 
576 private:
577 
578  virtual uint32 APIParType() const override = 0;
579 };
580 
581 // ----------------------------------------------------------------------------
582 
591 class PCL_CLASS MetaUnsignedInteger : public MetaInteger
592 {
593 public:
594 
600  {
601  }
602 
610  {
611  }
612 
616  virtual ~MetaUnsignedInteger() noexcept( false )
617  {
618  }
619 
622  bool IsSigned() const override
623  {
624  return false;
625  }
626 
629  virtual IsoString Id() const override = 0;
630 
631 private:
632 
633  virtual uint32 APIParType() const override = 0;
634 };
635 
636 // ----------------------------------------------------------------------------
637 
646 class PCL_CLASS MetaSignedInteger : public MetaInteger
647 {
648 public:
649 
655  {
656  }
657 
665  {
666  }
667 
671  virtual ~MetaSignedInteger() noexcept( false )
672  {
673  }
674 
677  bool IsSigned() const override
678  {
679  return true;
680  }
681 
684  virtual IsoString Id() const override = 0;
685 
686 private:
687 
688  virtual uint32 APIParType() const override = 0;
689 };
690 
691 // ----------------------------------------------------------------------------
692 
701 class PCL_CLASS MetaUInt8 : public MetaUnsignedInteger
702 {
703 public:
704 
710  {
711  }
712 
720  {
721  }
722 
726  virtual ~MetaUInt8() noexcept( false )
727  {
728  }
729 
732  virtual IsoString Id() const override = 0;
733 
734 private:
735 
736  uint32 APIParType() const override;
737 };
738 
739 // ----------------------------------------------------------------------------
740 
749 class PCL_CLASS MetaUInt16 : public MetaUnsignedInteger
750 {
751 public:
752 
758  {
759  }
760 
768  {
769  }
770 
774  virtual ~MetaUInt16() noexcept( false )
775  {
776  }
777 
780  virtual IsoString Id() const override = 0;
781 
782 private:
783 
784  uint32 APIParType() const override;
785 };
786 
787 // ----------------------------------------------------------------------------
788 
797 class PCL_CLASS MetaUInt32 : public MetaUnsignedInteger
798 {
799 public:
800 
806  {
807  }
808 
816  {
817  }
818 
822  virtual ~MetaUInt32() noexcept( false )
823  {
824  }
825 
828  virtual IsoString Id() const override = 0;
829 
830 private:
831 
832  uint32 APIParType() const override;
833 };
834 
835 // ----------------------------------------------------------------------------
836 
845 class PCL_CLASS MetaUInt64 : public MetaUnsignedInteger
846 {
847 public:
848 
854  {
855  }
856 
864  {
865  }
866 
870  virtual ~MetaUInt64() noexcept( false )
871  {
872  }
873 
874  virtual IsoString Id() const override = 0;
875 
876 private:
877 
878  uint32 APIParType() const override;
879 };
880 
881 // ----------------------------------------------------------------------------
882 
891 class PCL_CLASS MetaInt8 : public MetaSignedInteger
892 {
893 public:
894 
900  {
901  }
902 
910  {
911  }
912 
916  virtual ~MetaInt8() noexcept( false )
917  {
918  }
919 
922  virtual IsoString Id() const override = 0;
923 
924 private:
925 
926  uint32 APIParType() const override;
927 };
928 
929 // ----------------------------------------------------------------------------
930 
940 {
941 public:
942 
948  {
949  }
950 
958  {
959  }
960 
964  virtual ~MetaInt16() noexcept( false )
965  {
966  }
967 
970  virtual IsoString Id() const override = 0;
971 
972 private:
973 
974  uint32 APIParType() const override;
975 };
976 
977 // ----------------------------------------------------------------------------
978 
987 class PCL_CLASS MetaInt32 : public MetaSignedInteger
988 {
989 public:
990 
996  {
997  }
998 
1006  {
1007  }
1008 
1012  virtual ~MetaInt32() noexcept( false )
1013  {
1014  }
1015 
1018  virtual IsoString Id() const override = 0;
1019 
1020 private:
1021 
1022  uint32 APIParType() const override;
1023 };
1024 
1025 // ----------------------------------------------------------------------------
1026 
1035 class PCL_CLASS MetaInt64 : public MetaSignedInteger
1036 {
1037 public:
1038 
1044  {
1045  }
1046 
1054  {
1055  }
1056 
1060  virtual ~MetaInt64() noexcept( false )
1061  {
1062  }
1063 
1066  virtual IsoString Id() const override = 0;
1067 
1068 private:
1069 
1070  uint32 APIParType() const override;
1071 };
1072 
1073 // ----------------------------------------------------------------------------
1074 
1083 class PCL_CLASS MetaReal : public MetaNumeric
1084 {
1085 public:
1086 
1092  {
1093  }
1094 
1102  {
1103  }
1104 
1108  virtual ~MetaReal() noexcept( false )
1109  {
1110  }
1111 
1114  bool IsReal() const override
1115  {
1116  return true;
1117  }
1118 
1149  virtual int Precision() const
1150  {
1151  return -1; // printf's g format
1152  }
1153 
1167  virtual bool ScientificNotation() const
1168  {
1169  return false;
1170  }
1171 
1174  virtual IsoString Id() const override = 0;
1175 
1176 private:
1177 
1178  void PerformTypeAPIDefinitions() const override;
1179  virtual uint32 APIParType() const override = 0;
1180 };
1181 
1182 // ----------------------------------------------------------------------------
1183 
1193 class PCL_CLASS MetaFloat : public MetaReal
1194 {
1195 public:
1196 
1202  {
1203  }
1204 
1212  {
1213  }
1214 
1218  virtual ~MetaFloat() noexcept( false )
1219  {
1220  }
1221 
1224  virtual IsoString Id() const override = 0;
1225 
1226 private:
1227 
1228  uint32 APIParType() const override;
1229 };
1230 
1231 // ----------------------------------------------------------------------------
1232 
1242 class PCL_CLASS MetaDouble : public MetaReal
1243 {
1244 public:
1245 
1251  {
1252  }
1253 
1261  {
1262  }
1263 
1267  virtual ~MetaDouble() noexcept( false )
1268  {
1269  }
1270 
1273  virtual IsoString Id() const override = 0;
1274 
1275 private:
1276 
1277  uint32 APIParType() const override;
1278 };
1279 
1280 // ----------------------------------------------------------------------------
1281 
1298 class PCL_CLASS MetaBoolean : public MetaParameter
1299 {
1300 public:
1301 
1307  {
1308  }
1309 
1317  {
1318  }
1319 
1323  virtual ~MetaBoolean() noexcept( false )
1324  {
1325  }
1326 
1329  bool IsBoolean() const override
1330  {
1331  return true;
1332  }
1333 
1340  virtual bool DefaultValue() const
1341  {
1342  return false;
1343  }
1344 
1347  virtual IsoString Id() const override = 0;
1348 
1349 private:
1350 
1351  void PerformTypeAPIDefinitions() const override;
1352  uint32 APIParType() const override;
1353 };
1354 
1373 class PCL_CLASS pcl_bool
1374 {
1375 public:
1376 
1381  pcl_bool() = default;
1382 
1389  template <typename T> pcl_bool( const T& value ) :
1390  m_value( value ? 1 : 0 )
1391  {
1392  }
1393 
1400  template <typename T> pcl_bool& operator =( const T& value )
1401  {
1402  m_value = value ? 1 : 0;
1403  return *this;
1404  }
1405 
1410  constexpr operator bool() const
1411  {
1412  return m_value != 0;
1413  }
1414 
1415 #ifndef _MSC_VER
1416 
1421  constexpr operator int() const
1422  {
1423  return int( m_value );
1424  }
1425 
1426 #endif // !_MSC_VER
1427 
1428  constexpr bool operator ==( const pcl_bool& b ) const
1429  {
1430  return m_value == b.m_value;
1431  }
1432 
1433  constexpr bool operator <( const pcl_bool& b ) const
1434  {
1435  return m_value < b.m_value;
1436  }
1437 
1438 private:
1439 
1440  int32 m_value = 0; // MetaBoolean equivalent type
1441 };
1442 
1443 // ----------------------------------------------------------------------------
1444 
1462 class PCL_CLASS MetaEnumeration : public MetaParameter
1463 {
1464 public:
1465 
1471  {
1472  }
1473 
1481  {
1482  }
1483 
1487  virtual ~MetaEnumeration() noexcept( false )
1488  {
1489  }
1490 
1493  bool IsEnumeration() const override
1494  {
1495  return true;
1496  }
1497 
1500  virtual IsoString Id() const override = 0;
1501 
1510  virtual size_type NumberOfElements() const = 0;
1511 
1525  virtual IsoString ElementId( size_type idx ) const = 0;
1526 
1537  virtual int ElementValue( size_type idx ) const = 0;
1538 
1550  {
1551  return 0;
1552  }
1553 
1580  virtual IsoString ElementAliases() const
1581  {
1582  return IsoString();
1583  }
1584 
1585 private:
1586 
1587  void PerformTypeAPIDefinitions() const override;
1588  uint32 APIParType() const override;
1589 };
1590 
1604 typedef int32 pcl_enum;
1605 
1606 // ----------------------------------------------------------------------------
1607 
1616 {
1617 public:
1618 
1624  {
1625  }
1626 
1634  {
1635  }
1636 
1640  virtual ~MetaVariableLengthParameter() noexcept( false )
1641  {
1642  }
1643 
1646  bool IsVariableLength() const override
1647  {
1648  return true;
1649  }
1650 
1653  virtual IsoString Id() const override = 0;
1654 
1662  virtual size_type MinLength() const
1663  {
1664  return 0; // can be empty
1665  }
1666 
1677  virtual size_type MaxLength() const
1678  {
1679  return 0; // unlimited length
1680  }
1681 
1682 private:
1683 
1684  virtual void PerformTypeAPIDefinitions() const override = 0;
1685  virtual uint32 APIParType() const override = 0;
1686 };
1687 
1688 // ----------------------------------------------------------------------------
1689 
1697 class PCL_CLASS MetaString : public MetaVariableLengthParameter
1698 {
1699 public:
1700 
1706  {
1707  }
1708 
1716  {
1717  }
1718 
1722  virtual ~MetaString() noexcept( false )
1723  {
1724  }
1725 
1728  bool IsString() const override
1729  {
1730  return true;
1731  }
1732 
1735  virtual IsoString Id() const override = 0;
1736 
1747  virtual String DefaultValue() const
1748  {
1749  return String();
1750  }
1751 
1762  virtual String AllowedCharacters() const
1763  {
1764  return String(); // any character is valid
1765  }
1766 
1767 private:
1768 
1769  void PerformTypeAPIDefinitions() const override;
1770  uint32 APIParType() const override;
1771 };
1772 
1773 // ----------------------------------------------------------------------------
1774 
1787 class PCL_CLASS MetaTable : public MetaVariableLengthParameter
1788 {
1789 public:
1790 
1796  {
1797  }
1798 
1802  virtual ~MetaTable() noexcept( false )
1803  {
1804  }
1805 
1808  bool IsTable() const override
1809  {
1810  return true;
1811  }
1812 
1815  virtual IsoString Id() const override = 0;
1816 
1824  const MetaParameter* operator[]( size_type i ) const;
1825 
1826 private:
1827 
1828  // Nested tables are not allowed.
1829  MetaTable( MetaTable* );
1830 
1831  void PerformTypeAPIDefinitions() const override;
1832  uint32 APIParType() const override;
1833 };
1834 
1835 // ----------------------------------------------------------------------------
1836 
1849 class PCL_CLASS MetaBlock : public MetaVariableLengthParameter
1850 {
1851 public:
1852 
1858  {
1859  }
1860 
1868  {
1869  }
1870 
1874  virtual ~MetaBlock() noexcept( false )
1875  {
1876  }
1877 
1880  bool IsBlock() const override
1881  {
1882  return true;
1883  }
1884 
1887  virtual IsoString Id() const override = 0;
1888 
1912  {
1913  DataAsUInt8, // 8-bit unsigned integers
1914  DataAsInt8, // 8-bit signed integers
1915  DataAsUInt16, // 16-bit unsigned integers
1916  DataAsInt16, // 16-bit signed integers
1917  DataAsUInt32, // 32-bit unsigned integers
1918  DataAsInt32, // 32-bit signed integers
1919  DataAsUInt64, // 64-bit unsigned integers
1920  DataAsInt64, // 64-bit signed integers
1921  DataAsFloat, // float (32-bit IEEE 754 floating point)
1922  DataAsDouble // double (64-bit IEEE 754 floating point)
1923  };
1924 
1939  {
1940  return DataAsUInt8;
1941  }
1942 
1943 private:
1944 
1945  void PerformTypeAPIDefinitions() const override;
1946  uint32 APIParType() const override;
1947 };
1948 
1949 // ----------------------------------------------------------------------------
1950 
1951 } // pcl
1952 
1953 #endif // __PCL_BUILDING_PIXINSIGHT_APPLICATION
1954 
1955 #endif // __PCL_MetaParameter_h
1956 
1957 // ----------------------------------------------------------------------------
1958 // EOF pcl/MetaParameter.h - Released 2019-11-07T10:59:34Z
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:7911
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:2086
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:2075
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:5387