PCL
MetaParameter.h
Go to the documentation of this file.
1 // ____ ______ __
2 // / __ \ / ____// /
3 // / /_/ // / / /
4 // / ____// /___ / /___ PixInsight Class Library
5 // /_/ \____//_____/ PCL 2.7.0
6 // ----------------------------------------------------------------------------
7 // pcl/MetaParameter.h - Released 2024-06-18T15:48:54Z
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-2024 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 
115 
119  ~MetaParameter() noexcept( false ) override
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  ~MetaNumeric() noexcept( false ) override
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  ~MetaInteger() noexcept( false ) override
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  ~MetaUnsignedInteger() noexcept( false ) override
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  ~MetaSignedInteger() noexcept( false ) override
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  ~MetaUInt8() noexcept( false ) override
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  ~MetaUInt16() noexcept( false ) override
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  ~MetaUInt32() noexcept( false ) override
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  ~MetaUInt64() noexcept( false ) override
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  ~MetaInt8() noexcept( false ) override
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  ~MetaInt16() noexcept( false ) override
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  ~MetaInt32() noexcept( false ) override
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  ~MetaInt64() noexcept( false ) override
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  ~MetaReal() noexcept( false ) override
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  ~MetaFloat() noexcept( false ) override
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  ~MetaDouble() noexcept( false ) override
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  ~MetaBoolean() noexcept( false ) override
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  ~MetaEnumeration() noexcept( false ) override
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 using pcl_enum = int32;
1639 
1640 // ----------------------------------------------------------------------------
1641 
1650 {
1651 public:
1652 
1658  : MetaParameter( P )
1659  {
1660  }
1661 
1669  : MetaParameter( T )
1670  {
1671  }
1672 
1676  ~MetaVariableLengthParameter() noexcept( false ) override
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  ~MetaString() noexcept( false ) override
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  ~MetaTable() noexcept( false ) override
1842  {
1843  }
1844 
1847  bool IsTable() const override
1848  {
1849  return true;
1850  }
1851 
1854  virtual IsoString Id() const override = 0;
1855 
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  ~MetaBlock() noexcept( false ) override
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 2024-06-18T15:48:54Z
Eight-bit string (ISO/IEC-8859-1 or UTF-8 string)
Definition: String.h:5425
A formal description of a block process parameter.
virtual data_interpretation DataInterpretation() const
virtual IsoString Id() const override=0
MetaBlock(MetaProcess *p)
~MetaBlock() noexcept(false) override
bool IsBlock() const override
MetaBlock(MetaTable *t)
A formal description of a Boolean process parameter.
virtual IsoString Id() const override=0
bool IsBoolean() const override
MetaBoolean(MetaTable *T)
~MetaBoolean() noexcept(false) override
MetaBoolean(MetaProcess *P)
virtual bool DefaultValue() const
A formal description of a 64-bit IEEE 754 floating point process parameter.
~MetaDouble() noexcept(false) override
MetaDouble(MetaProcess *P)
virtual IsoString Id() const override=0
MetaDouble(MetaTable *T)
A formal description of an enumerated process parameter.
virtual IsoString ElementId(size_type idx) const =0
virtual IsoString Id() const override=0
virtual size_type DefaultValueIndex() const
MetaEnumeration(MetaTable *T)
virtual IsoString ElementAliases() const
virtual size_type NumberOfElements() const =0
bool IsEnumeration() const override
virtual int ElementValue(size_type idx) const =0
MetaEnumeration(MetaProcess *P)
~MetaEnumeration() noexcept(false) override
A formal description of a 32-bit IEEE 754 floating point process parameter.
~MetaFloat() noexcept(false) override
MetaFloat(MetaProcess *P)
virtual IsoString Id() const override=0
MetaFloat(MetaTable *T)
A formal description of a 16-bit signed integer process parameter.
MetaInt16(MetaTable *T)
virtual IsoString Id() const override=0
~MetaInt16() noexcept(false) override
MetaInt16(MetaProcess *P)
A formal description of a 32-bit signed integer process parameter.
MetaInt32(MetaTable *T)
MetaInt32(MetaProcess *P)
virtual IsoString Id() const override=0
~MetaInt32() noexcept(false) override
A formal description of a 64-bit signed integer process parameter.
MetaInt64(MetaProcess *p)
virtual IsoString Id() const override=0
~MetaInt64() noexcept(false) override
MetaInt64(MetaTable *t)
A formal description of an 8-bit signed integer process parameter.
virtual IsoString Id() const override=0
MetaInt8(MetaTable *T)
~MetaInt8() noexcept(false) override
MetaInt8(MetaProcess *P)
A formal description of an integer process parameter.
~MetaInteger() noexcept(false) override
MetaInteger(MetaProcess *P)
MetaInteger(MetaTable *T)
virtual bool IsSigned() const =0
virtual IsoString Id() const override=0
bool IsInteger() const override
A formal description of a numeric process parameter.
virtual bool IsReal() const
~MetaNumeric() noexcept(false) override
MetaNumeric(MetaProcess *P)
virtual double DefaultValue() const
MetaNumeric(MetaTable *T)
virtual IsoString Id() const override=0
virtual double MaximumValue() const
bool IsNumeric() const override
virtual double MinimumValue() const
virtual bool IsInteger() const
Root base class for all PixInsight module components.
Definition: MetaObject.h:86
Root base class for PCL classes providing formal descriptions of process parameters.
virtual bool IsRequired() const
~MetaParameter() noexcept(false) override
virtual bool NeedsUnlocking() const
virtual bool IsBoolean() const
virtual bool IsTable() const
virtual bool IsString() const
virtual bool IsNumeric() const
MetaParameter(MetaTable *T)
MetaParameter(MetaProcess *P)
virtual String Comment() const
virtual bool IsEnumeration() const
virtual bool IsBlock() const
virtual String Description() const
virtual bool NeedsValidation() const
virtual bool IsReadOnly() const
virtual bool IsVariableLength() const
virtual IsoString Id() const =0
virtual IsoString Aliases() const
A formal description of a PixInsight process.
Definition: MetaProcess.h:107
A formal description of a real process parameter.
virtual int Precision() const
MetaReal(MetaTable *T)
virtual bool ScientificNotation() const
MetaReal(MetaProcess *P)
bool IsReal() const override
~MetaReal() noexcept(false) override
virtual IsoString Id() const override=0
A formal description of a signed integer process parameter.
MetaSignedInteger(MetaProcess *P)
virtual IsoString Id() const override=0
bool IsSigned() const override
~MetaSignedInteger() noexcept(false) override
MetaSignedInteger(MetaTable *T)
A formal description of a string process parameter.
~MetaString() noexcept(false) override
virtual String DefaultValue() const
bool IsString() const override
MetaString(MetaProcess *P)
MetaString(MetaTable *T)
virtual String AllowedCharacters() const
virtual IsoString Id() const override=0
A formal description of a table process parameter.
bool IsTable() const override
const MetaParameter * operator[](size_type i) const
MetaTable(MetaProcess *P)
virtual IsoString Id() const override=0
~MetaTable() noexcept(false) override
A formal description of a 16-bit unsigned integer process parameter.
MetaUInt16(MetaTable *T)
virtual IsoString Id() const override=0
MetaUInt16(MetaProcess *P)
~MetaUInt16() noexcept(false) override
A formal description of a 32-bit unsigned integer process parameter.
MetaUInt32(MetaProcess *P)
~MetaUInt32() noexcept(false) override
virtual IsoString Id() const override=0
MetaUInt32(MetaTable *T)
A formal description of a 64-bit unsigned integer process parameter.
virtual IsoString Id() const override=0
MetaUInt64(MetaTable *T)
MetaUInt64(MetaProcess *P)
~MetaUInt64() noexcept(false) override
A formal description of an 8-bit unsigned integer process parameter.
MetaUInt8(MetaProcess *P)
virtual IsoString Id() const override=0
~MetaUInt8() noexcept(false) override
MetaUInt8(MetaTable *T)
A formal description of an unsigned integer process parameter.
MetaUnsignedInteger(MetaProcess *P)
MetaUnsignedInteger(MetaTable *T)
~MetaUnsignedInteger() noexcept(false) override
virtual IsoString Id() const override=0
bool IsSigned() const override
A formal description of a variable length process parameter.
virtual size_type MaxLength() const
MetaVariableLengthParameter(MetaProcess *P)
bool IsVariableLength() const override
virtual IsoString Id() const override=0
virtual size_type MinLength() const
~MetaVariableLengthParameter() noexcept(false) override
Unicode (UTF-16) string.
Definition: String.h:8113
A first-class data type that can be safely used to implement Boolean process parameters on all suppor...
pcl_bool(const T &value)
pcl_bool()=default
bool operator==(const Array< T, A > &x1, const Array< T, A > &x2) noexcept
Definition: Array.h:2267
bool operator<(const Array< T, A > &x1, const Array< T, A > &x2) noexcept
Definition: Array.h:2278
signed int int32
Definition: Defs.h:660
unsigned int uint32
Definition: Defs.h:666
int32 pcl_enum
An integer type that can be safely used to implement enumerated process parameters on all supported p...
size_t size_type
Definition: Defs.h:609
PCL root namespace.
Definition: AbstractImage.h:77