Variant.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/Variant.h - Released 2024-06-18T15:48:54Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_Variant_h
#define __PCL_Variant_h
 
 
#include <pcl/Defs.h>
#include <pcl/Diagnostics.h>
 
#include <pcl/ByteArray.h>
#include <pcl/Complex.h>
#include <pcl/Matrix.h>
#include <pcl/Point.h>
#include <pcl/Rectangle.h>
#include <pcl/StringList.h>
#include <pcl/TimePoint.h>
#include <pcl/Vector.h>
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
namespace VariantType
{
   enum value_type
   {
      Invalid = 0,
 
      Bool,
      Boolean = Bool,
 
      Int8,
      Char = Int8,
      Int16,
      Short = Int16,
      Int32,
      Integer = Int32,
      Int64,
 
      UInt8,
      Byte = UInt8,
      UInt16,
      UShort = UInt16,
      UInt32,
      UInt = UInt32,
      UInt64,
 
      Float32,
      Float = Float32,
      Float64,
      Double = Float64,
      Real = Double,
 
      Complex32,
      FComplex = Complex32,
      Complex64,
      DComplex = Complex64,
      Complex = DComplex,
 
      TimePoint,
 
      I32Point,
      Point = I32Point,
      F32Point,
      FPoint = F32Point,
      F64Point,
      DPoint = F64Point,
 
      I32Rect,
      Rect = I32Rect,
      F32Rect,
      FRect = F32Rect,
      F64Rect,
      DRect = F64Rect,
 
      I8Vector,
      CharVector = I8Vector,
      UI8Vector,
      ByteVector = UI8Vector,
      I16Vector,
      UI16Vector,
      I32Vector,
      IVector = I32Vector,
      UI32Vector,
      UIVector = UI32Vector,
      I64Vector,
      UI64Vector,
      F32Vector,
      FVector = F32Vector,
      F64Vector,
      DVector = F64Vector,
      C32Vector,
      C64Vector,
 
      I8Matrix,
      CharMatrix = I8Matrix,
      UI8Matrix,
      ByteMatrix = UI8Matrix,
      I16Matrix,
      UI16Matrix,
      I32Matrix,
      IMatrix = I32Matrix,
      UI32Matrix,
      UIMatrix = UI32Matrix,
      I64Matrix,
      UI64Matrix,
      F32Matrix,
      FMatrix = F32Matrix,
      F64Matrix,
      DMatrix = F64Matrix,
      C32Matrix,
      C64Matrix,
 
      ByteArray,
 
      String,
      IsoString,
 
      StringList,
      IsoStringList,
 
      StringKeyValue,
      IsoStringKeyValue,
 
      StringKeyValueList,
      IsoStringKeyValueList,
 
      NumberOfVariantTypes,
 
      FirstCustomType = 1024
   };
}
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS Variant
{
public:
 
   using data_type = VariantType::value_type;
 
   Variant()
      : m_type( VariantType::Invalid )
   {
      m_data.anyValue = 0;
   }
 
   Variant( bool b )
      : m_type( VariantType::Bool )
   {
      m_data.boolValue = b;
   }
 
   Variant( int8 i8 )
      : m_type( VariantType::Int8 )
   {
      m_data.int8Value = i8;
   }
 
   Variant( int16 i16 )
      : m_type( VariantType::Int16 )
   {
      m_data.int16Value = i16;
   }
 
   Variant( int32 i32 )
      : m_type( VariantType::Int32 )
   {
      m_data.int32Value = i32;
   }
 
   Variant( int64 i64 )
      : m_type( VariantType::Int64 )
   {
      m_data.int64Value = i64;
   }
 
   Variant( uint8 u8 )
      : m_type( VariantType::UInt8 )
   {
      m_data.uint8Value = u8;
   }
 
   Variant( uint16 u16 )
      : m_type( VariantType::UInt16 )
   {
      m_data.uint16Value = u16;
   }
 
   Variant( uint32 u32 ) : m_type( VariantType::UInt32 )
   {
      m_data.uint32Value = u32;
   }
 
   Variant( uint64 u64 )
      : m_type( VariantType::UInt64 )
   {
      m_data.uint64Value = u64;
   }
 
   Variant( float f )
      : m_type( VariantType::Float )
   {
      m_data.float32Value = f;
   }
 
   Variant( double d )
      : m_type( VariantType::Double )
   {
      m_data.float64Value = d;
   }
 
   Variant( fcomplex fc )
      : m_type( VariantType::FComplex )
   {
      m_data.anyValue = 0;
      m_data.complex32Value = new fcomplex( fc );
   }
 
   Variant( dcomplex dc )
      : m_type( VariantType::DComplex )
   {
      m_data.anyValue = 0;
      m_data.complex64Value = new dcomplex( dc );
   }
 
   Variant( const TimePoint& t )
      : m_type( VariantType::TimePoint )
   {
      m_data.anyValue = 0;
      m_data.timePointValue = new TimePoint( t );
   }
 
   Variant( const Point& p )
      : m_type( VariantType::Point )
   {
      m_data.anyValue = 0;
      m_data.i32PointValue = new Point( p );
   }
 
   Variant( const FPoint& fp )
      : m_type( VariantType::FPoint )
   {
      m_data.anyValue = 0;
      m_data.f32PointValue = new FPoint( fp );
   }
 
   Variant( const DPoint& dp )
      : m_type( VariantType::DPoint )
   {
      m_data.anyValue = 0;
      m_data.f64PointValue = new DPoint( dp );
   }
 
   Variant( const Rect& r )
      : m_type( VariantType::Rect )
   {
      m_data.anyValue = 0;
      m_data.i32RectValue = new Rect( r );
   }
 
   Variant( const FRect& fr )
      : m_type( VariantType::FRect )
   {
      m_data.anyValue = 0;
      m_data.f32RectValue = new FRect( fr );
   }
 
   Variant( const DRect& dr )
      : m_type( VariantType::DRect )
   {
      m_data.anyValue = 0;
      m_data.f64RectValue = new DRect( dr );
   }
 
   Variant( const CharVector& cv )
      : m_type( VariantType::CharVector )
   {
      m_data.anyValue = 0;
      m_data.i8VectorValue = new CharVector( cv );
   }
 
   Variant( const ByteVector& bv )
      : m_type( VariantType::ByteVector )
   {
      m_data.anyValue = 0;
      m_data.ui8VectorValue = new ByteVector( bv );
   }
 
   Variant( const I16Vector& i16v )
      : m_type( VariantType::I16Vector )
   {
      m_data.anyValue = 0;
      m_data.i16VectorValue = new I16Vector( i16v );
   }
 
   Variant( const UI16Vector& ui16v )
      : m_type( VariantType::UI16Vector )
   {
      m_data.anyValue = 0;
      m_data.ui16VectorValue = new UI16Vector( ui16v );
   }
 
   Variant( const IVector& iv )
      : m_type( VariantType::IVector )
   {
      m_data.anyValue = 0;
      m_data.i32VectorValue = new IVector( iv );
   }
 
   Variant( const UIVector& uiv )
      : m_type( VariantType::UIVector )
   {
      m_data.anyValue = 0;
      m_data.ui32VectorValue = new UIVector( uiv );
   }
 
   Variant( const I64Vector& i64v )
      : m_type( VariantType::I64Vector )
   {
      m_data.anyValue = 0;
      m_data.i64VectorValue = new I64Vector( i64v );
   }
 
   Variant( const UI64Vector& ui64v )
      : m_type( VariantType::UI64Vector )
   {
      m_data.anyValue = 0;
      m_data.ui64VectorValue = new UI64Vector( ui64v );
   }
 
   Variant( const FVector& fv )
      : m_type( VariantType::FVector )
   {
      m_data.anyValue = 0;
      m_data.f32VectorValue = new FVector( fv );
   }
 
   Variant( const DVector& dv )
      : m_type( VariantType::DVector )
   {
      m_data.anyValue = 0;
      m_data.f64VectorValue = new DVector( dv );
   }
 
   Variant( const C32Vector& c32v )
      : m_type( VariantType::C32Vector )
   {
      m_data.anyValue = 0;
      m_data.c32VectorValue = new C32Vector( c32v );
   }
 
   Variant( const C64Vector& c64v )
      : m_type( VariantType::C64Vector )
   {
      m_data.anyValue = 0;
      m_data.c64VectorValue = new C64Vector( c64v );
   }
 
   Variant( const CharMatrix& cm )
      : m_type( VariantType::CharMatrix )
   {
      m_data.anyValue = 0;
      m_data.i8MatrixValue = new CharMatrix( cm );
   }
 
   Variant( const ByteMatrix& bm )
      : m_type( VariantType::ByteMatrix )
   {
      m_data.anyValue = 0;
      m_data.ui8MatrixValue = new ByteMatrix( bm );
   }
 
   Variant( const I16Matrix& i16m )
      : m_type( VariantType::I16Matrix )
   {
      m_data.anyValue = 0;
      m_data.i16MatrixValue = new I16Matrix( i16m );
   }
 
   Variant( const UI16Matrix& ui16m )
      : m_type( VariantType::UI16Matrix )
   {
      m_data.anyValue = 0;
      m_data.ui16MatrixValue = new UI16Matrix( ui16m );
   }
 
   Variant( const IMatrix& im )
      : m_type( VariantType::IMatrix )
   {
      m_data.anyValue = 0;
      m_data.i32MatrixValue = new IMatrix( im );
   }
 
   Variant( const UIMatrix& uim )
      : m_type( VariantType::UIMatrix )
   {
      m_data.anyValue = 0;
      m_data.ui32MatrixValue = new UIMatrix( uim );
   }
 
   Variant( const I64Matrix& i64m )
      : m_type( VariantType::I64Matrix )
   {
      m_data.anyValue = 0;
      m_data.i64MatrixValue = new I64Matrix( i64m );
   }
 
   Variant( const UI64Matrix& ui64m )
      : m_type( VariantType::UI64Matrix )
   {
      m_data.anyValue = 0;
      m_data.ui64MatrixValue = new UI64Matrix( ui64m );
   }
 
   Variant( const FMatrix& fm )
      : m_type( VariantType::FMatrix )
   {
      m_data.anyValue = 0;
      m_data.f32MatrixValue = new FMatrix( fm );
   }
 
   Variant( const DMatrix& dm )
      : m_type( VariantType::DMatrix )
   {
      m_data.anyValue = 0;
      m_data.f64MatrixValue = new DMatrix( dm );
   }
 
   Variant( const C32Matrix& c32m )
      : m_type( VariantType::C32Matrix )
   {
      m_data.anyValue = 0;
      m_data.c32MatrixValue = new C32Matrix( c32m );
   }
 
   Variant( const C64Matrix& c64m )
      : m_type( VariantType::C64Matrix )
   {
      m_data.anyValue = 0;
      m_data.c64MatrixValue = new C64Matrix( c64m );
   }
 
   Variant( const ByteArray& ba )
      : m_type( VariantType::ByteArray )
   {
      m_data.anyValue = 0;
      m_data.byteArrayValue = new ByteArray( ba );
   }
 
   Variant( const String& s )
      : m_type( VariantType::String )
   {
      m_data.anyValue = 0;
      m_data.stringValue = new String( s );
   }
 
   Variant( const IsoString& s8 )
      : m_type( VariantType::IsoString )
   {
      m_data.anyValue = 0;
      m_data.isoStringValue = new IsoString( s8 );
   }
 
   Variant( const char* cp )
      : m_type( VariantType::IsoString )
   {
      m_data.anyValue = 0;
      m_data.isoStringValue = new IsoString( cp );
   }
 
   Variant( const StringList& sl )
      : m_type( VariantType::StringList )
   {
      m_data.anyValue = 0;
      m_data.stringListValue = new StringList( sl );
   }
 
   Variant( const IsoStringList& isl )
      : m_type( VariantType::IsoStringList )
   {
      m_data.anyValue = 0;
      m_data.isoStringListValue = new IsoStringList( isl );
   }
 
   Variant( const StringKeyValue& skv )
      : m_type( VariantType::StringKeyValue )
   {
      m_data.anyValue = 0;
      m_data.stringKeyValueValue = new StringKeyValue( skv );
   }
 
   Variant( const IsoStringKeyValue& iskv )
      : m_type( VariantType::IsoStringKeyValue )
   {
      m_data.anyValue = 0;
      m_data.isoStringKeyValueValue = new IsoStringKeyValue( iskv );
   }
 
   Variant( const StringKeyValueList& skvl )
      : m_type( VariantType::StringKeyValueList )
   {
      m_data.anyValue = 0;
      m_data.stringKeyValueListValue = new StringKeyValueList( skvl );
   }
 
   Variant( const IsoStringKeyValueList& iskvl )
      : m_type( VariantType::IsoStringKeyValueList )
   {
      m_data.anyValue = 0;
      m_data.isoStringKeyValueListValue = new IsoStringKeyValueList( iskvl );
   }
 
   Variant( const Variant& x )
      : m_type( VariantType::Invalid )
   {
      m_data.anyValue = 0;
      Copy( x );
   }
 
   Variant( Variant&& x )
   {
      m_type = x.m_type;
      m_data.anyValue = x.m_data.anyValue;
      x.m_type = VariantType::Invalid;
   }
 
   virtual ~Variant()
   {
      Clear();
   }
 
   Variant& operator =( const Variant& x )
   {
      Assign( x );
      return *this;
   }
 
   void Assign( const Variant& x )
   {
      if ( &x != this )
      {
         Clear();
         Copy( x );
      }
   }
 
   Variant& operator =( Variant&& x )
   {
      Transfer( x );
      return *this;
   }
 
   void Transfer( Variant& x )
   {
      if ( &x != this )
      {
         Clear();
         m_type = x.m_type;
         m_data.anyValue = x.m_data.anyValue;
         x.m_type = VariantType::Invalid;
      }
   }
 
   void Transfer( Variant&& x )
   {
      if ( &x != this )
      {
         Clear();
         m_type = x.m_type;
         m_data.anyValue = x.m_data.anyValue;
         x.m_type = VariantType::Invalid;
      }
   }
 
   bool IsValid() const
   {
      return m_type != VariantType::Invalid;
   }
 
   data_type Type() const
   {
      return data_type( m_type );
   }
 
   Variant ToType( data_type type ) const;
 
   void Clear();
 
   int Compare( const Variant& x ) const;
 
   bool operator ==( const Variant& x ) const
   {
      return Compare( x ) == 0;
   }
 
   bool operator <( const Variant& x ) const
   {
      return Compare( x ) < 0;
   }
 
   bool ToBool() const;
 
   bool CanConvertToBool() const noexcept;
 
   bool ToBoolean() const
   {
      return ToBool();
   }
 
   bool CanConvertToBoolean() const noexcept
   {
      return CanConvertToBool();
   }
 
   int ToInt() const;
 
   bool CanConvertToInt() const noexcept;
 
   int64 ToInt64() const;
 
   bool CanConvertToInt64() const noexcept;
 
   unsigned int ToUInt() const;
 
   bool CanConvertToUInt() const noexcept;
 
   uint64 ToUInt64() const;
 
   bool CanConvertToUInt64() const noexcept;
 
   float ToFloat() const;
 
   bool CanConvertToFloat() const noexcept;
 
   double ToDouble() const;
 
   bool CanConvertToDouble() const noexcept;
 
   fcomplex ToFComplex() const;
 
   bool CanConvertToFComplex() const noexcept;
 
   dcomplex ToDComplex() const;
 
   bool CanConvertToDComplex() const noexcept;
 
   complex ToComplex() const
   {
      return ToDComplex();
   }
 
   bool CanConvertToComplex() const noexcept
   {
      return CanConvertToDComplex();
   }
 
   TimePoint ToTimePoint() const;
 
   bool CanConvertToTimePoint() const noexcept;
 
   Point ToPoint() const;
 
   bool CanConvertToPoint() const noexcept;
 
   FPoint ToFPoint() const;
 
   bool CanConvertToFPoint() const noexcept;
 
   DPoint ToDPoint() const;
 
   bool CanConvertToDPoint() const noexcept;
 
   Rect ToRect() const;
 
   bool CanConvertToRect() const noexcept;
 
   FRect ToFRect() const;
 
   bool CanConvertToFRect() const noexcept;
 
   DRect ToDRect() const;
 
   bool CanConvertToDRect() const noexcept;
 
   CharVector ToCharVector() const;
 
   bool CanConvertToCharVector() const noexcept;
 
   ByteVector ToByteVector() const;
 
   bool CanConvertToByteVector() const noexcept;
 
   I16Vector ToI16Vector() const;
 
   bool CanConvertToI16Vector() const noexcept;
 
   UI16Vector ToUI16Vector() const;
 
   bool CanConvertToUI16Vector() const noexcept;
 
   IVector ToIVector() const;
 
   bool CanConvertToIVector() const noexcept;
 
   UIVector ToUIVector() const;
 
   bool CanConvertToUIVector() const noexcept;
 
   I64Vector ToI64Vector() const;
 
   bool CanConvertToI64Vector() const noexcept;
 
   UI64Vector ToUI64Vector() const;
 
   bool CanConvertToUI64Vector() const noexcept;
 
   FVector ToFVector() const;
 
   bool CanConvertToFVector() const noexcept;
 
   DVector ToDVector() const;
 
   bool CanConvertToDVector() const noexcept;
 
   Vector ToVector() const
   {
      return ToDVector();
   }
 
   bool CanConvertToVector() const noexcept
   {
      return CanConvertToDVector();
   }
 
   C32Vector ToC32Vector() const;
 
   bool CanConvertToC32Vector() const noexcept;
 
   C64Vector ToC64Vector() const;
 
   bool CanConvertToC64Vector() const noexcept;
 
   CharMatrix ToCharMatrix() const;
 
   bool CanConvertToCharMatrix() const noexcept;
 
   ByteMatrix ToByteMatrix() const;
 
   bool CanConvertToByteMatrix() const noexcept;
 
   I16Matrix ToI16Matrix() const;
 
   bool CanConvertToI16Matrix() const noexcept;
 
   UI16Matrix ToUI16Matrix() const;
 
   bool CanConvertToUI16Matrix() const noexcept;
 
   IMatrix ToIMatrix() const;
 
   bool CanConvertToIMatrix() const noexcept;
 
   UIMatrix ToUIMatrix() const;
 
   bool CanConvertToUIMatrix() const noexcept;
 
   I64Matrix ToI64Matrix() const;
 
   bool CanConvertToI64Matrix() const noexcept;
 
   UI64Matrix ToUI64Matrix() const;
 
   bool CanConvertToUI64Matrix() const noexcept;
 
   FMatrix ToFMatrix() const;
 
   bool CanConvertToFMatrix() const noexcept;
 
   DMatrix ToDMatrix() const;
 
   bool CanConvertToDMatrix() const noexcept;
 
   Matrix ToMatrix() const
   {
      return ToDMatrix();
   }
 
   bool CanConvertToMatrix() const noexcept
   {
      return CanConvertToDMatrix();
   }
 
   C32Matrix ToC32Matrix() const;
 
   bool CanConvertToC32Matrix() const noexcept;
 
   C64Matrix ToC64Matrix() const;
 
   bool CanConvertToC64Matrix() const noexcept;
 
   ByteArray ToByteArray() const;
 
   bool CanConvertToByteArray() const noexcept;
 
   String ToString() const;
 
   bool CanConvertToString() const noexcept;
 
   IsoString ToIsoString() const;
 
   bool CanConvertToIsoString() const noexcept;
 
   StringList ToStringList() const;
 
   bool CanConvertToStringList() const noexcept;
 
   IsoStringList ToIsoStringList() const;
 
   bool CanConvertToIsoStringList() const noexcept;
 
   StringKeyValue ToStringKeyValue() const;
 
   IsoStringKeyValue ToIsoStringKeyValue() const;
 
   StringKeyValueList ToStringKeyValueList() const;
 
   IsoStringKeyValueList ToIsoStringKeyValueList() const;
 
   const void* InternalBlockAddress() const;
 
   size_type VectorLength() const;
 
   Rect MatrixDimensions() const;
 
   size_type BlockSize() const;
 
   static int BytesPerBlockElementForType( int type );
 
   int BytesPerBlockElement() const
   {
      return BytesPerBlockElementForType( m_type );
   }
 
   static bool IsScalarType( int type );
 
   bool IsScalar() const
   {
      return IsScalarType( m_type );
   }
 
   static bool IsComplexType( int type )
   {
      return type == VariantType::Complex32 || type == VariantType::Complex64;
   }
 
   bool IsComplex() const
   {
      return IsComplexType( m_type );
   }
 
   static bool IsTimePointType( int type )
   {
      return type == VariantType::TimePoint;
   }
 
   bool IsTimePoint() const
   {
      return IsTimePointType( m_type );
   }
 
   static bool IsVectorType( int type );
 
   bool IsVector() const
   {
      return IsVectorType( m_type );
   }
 
   static bool IsMatrixType( int type );
 
   bool IsMatrix() const
   {
      return IsMatrixType( m_type );
   }
 
   static bool IsStringType( int type )
   {
      return type == VariantType::String || type == VariantType::IsoString;
   }
 
   bool IsString() const
   {
      return IsStringType( m_type );
   }
 
   static bool IsStructuredType( int type );
 
   bool IsStructured() const
   {
      return IsStructuredType( m_type );
   }
 
   static const char* TypeAsString( int type );
 
private:
 
   union Data
   {
      bool        boolValue;
 
      int8        int8Value;
      int16       int16Value;
      int32       int32Value;
      int64       int64Value;
 
      uint8       uint8Value;
      uint16      uint16Value;
      uint32      uint32Value;
      uint64      uint64Value;
 
      float       float32Value;
      double      float64Value;
 
      fcomplex*   complex32Value;
      dcomplex*   complex64Value;
 
      TimePoint*  timePointValue;
 
      I32Point*   i32PointValue;
      F32Point*   f32PointValue;
      F64Point*   f64PointValue;
 
      I32Rect*    i32RectValue;
      F32Rect*    f32RectValue;
      F64Rect*    f64RectValue;
 
      I8Vector*   i8VectorValue;
      UI8Vector*  ui8VectorValue;
      I16Vector*  i16VectorValue;
      UI16Vector* ui16VectorValue;
      I32Vector*  i32VectorValue;
      UI32Vector* ui32VectorValue;
      I64Vector*  i64VectorValue;
      UI64Vector* ui64VectorValue;
      F32Vector*  f32VectorValue;
      F64Vector*  f64VectorValue;
      C32Vector*  c32VectorValue;
      C64Vector*  c64VectorValue;
 
      I8Matrix*   i8MatrixValue;
      UI8Matrix*  ui8MatrixValue;
      I16Matrix*  i16MatrixValue;
      UI16Matrix* ui16MatrixValue;
      I32Matrix*  i32MatrixValue;
      UI32Matrix* ui32MatrixValue;
      I64Matrix*  i64MatrixValue;
      UI64Matrix* ui64MatrixValue;
      F32Matrix*  f32MatrixValue;
      F64Matrix*  f64MatrixValue;
      C32Matrix*  c32MatrixValue;
      C64Matrix*  c64MatrixValue;
 
      ByteArray*  byteArrayValue;
 
      String*     stringValue;
      IsoString*  isoStringValue;
 
      StringList*    stringListValue;
      IsoStringList* isoStringListValue;
 
      StringKeyValue*    stringKeyValueValue;
      IsoStringKeyValue* isoStringKeyValueValue;
 
      StringKeyValueList*    stringKeyValueListValue;
      IsoStringKeyValueList* isoStringKeyValueListValue;
 
      uint64 anyValue;
   };
 
   Data m_data;
   int  m_type;
 
   // Internal
   void Copy( const Variant& );
 
   friend class PCL_AssertVariantSize;
};
 
class PCL_AssertVariantSize
{
#ifndef _MSC_VER
# ifdef __clang__
   _Pragma("clang diagnostic push")
   _Pragma("clang diagnostic ignored \"-Wunused-private-field\"")
# endif
   Variant* v;
   static_assert( sizeof( v->m_data ) == sizeof( uint64 ), "Invalid sizeof( Variant::m_data )" );
   static_assert( sizeof( v->m_data.anyValue ) == sizeof( v->m_data ), "Invalid sizeof( Variant::m_data.anyValue )" );
# ifdef __clang__
   _Pragma("clang diagnostic pop")
# endif
#else
   static_assert( sizeof( Variant::Data ) == sizeof( uint64 ), "Invalid sizeof( Variant::m_data )" );
#endif
};
 
// ----------------------------------------------------------------------------
 
} // pcl
 
struct api_property_value;
namespace pcl
{
   Variant VariantFromAPIPropertyValue( const api_property_value& );
   void APIPropertyValueFromVariant( api_property_value&, const Variant& );
   Variant::data_type VariantTypeFromAPIPropertyType( uint64 );
   uint64 APIPropertyTypeFromVariantType( Variant::data_type );
} // pcl
 
#endif   // __PCL_Variant_h
 
// ----------------------------------------------------------------------------
// EOF pcl/Variant.h - Released 2024-06-18T15:48:54Z