feat(Data): Support for std::vector

Author: macmade

CF++/include/CF++/CFPP-Data.hpp

@@ -31,6 +31,8 @@
 #ifndef CFPP_DATA_HPP
 #define CFPP_DATA_HPP
 
+#include <vector>
+
 namespace CF
 {
     class CFPP_EXPORT Data: public PropertyListType< Data >
@@ -60,6 +62,7 @@ namespace CF
             Data( const std::string & value );
             Data( const Byte * value, CFIndex length );
             Data( std::initializer_list< Byte > value );
+            Data( const std::vector< Byte > & value );
             Data( Data && value ) noexcept;
 
             ~Data() override;
@@ -71,6 +74,7 @@ namespace CF
             Data & operator =( CFStringRef value );
             Data & operator =( std::nullptr_t );
             Data & operator =( const std::string & value );
+            Data & operator =( const std::vector< Byte > & value );
 
             operator const Byte * () const;
             operator std::string  () const;
@@ -82,6 +86,7 @@ namespace CF
             Data & operator += ( CFDataRef value );
             Data & operator += ( const Data & value );
             Data & operator += ( const std::string & value );
+            Data & operator += ( const std::vector< Byte > & value );
 
             CFTypeID  GetTypeID()   const override;
             CFTypeRef GetCFObject() const override;

CF++/source/CFPP-Data.cpp

@@ -118,7 +118,15 @@ namespace CF
         }
     }
 
-    Data::Data( std::initializer_list< Byte > value ): Data( static_cast< CFIndex >( value.size() ) )
+    Data::Data( std::initializer_list< Byte > value ): Data()
+    {
+        for( Byte b: value )
+        {
+            CFDataAppendBytes( this->_cfObject, &b, 1 );
+        }
+    }
+    
+    Data::Data( const std::vector< Byte > & value ): Data()
     {
         for( Byte b: value )
         {
@@ -179,6 +187,11 @@ namespace CF
         return operator =( Data( value ) );
     }
 
+    Data & Data::operator =( const std::vector< Byte > & value )
+    {
+        return operator =( Data( value ) );
+    }
+    
     Data::operator const Byte * () const
     {
         if( this->_cfObject == nullptr )
@@ -262,6 +275,16 @@ namespace CF
         return *( this );
     }
 
+    Data & Data::operator += ( const std::vector< Byte > & value )
+    {
+        if( this->_cfObject != nullptr )
+        {
+            CFDataAppendBytes( this->_cfObject, value.data(), static_cast< CFIndex >( value.size() ) );
+        }
+        
+        return *( this );
+    }
+    
     CFTypeID Data::GetTypeID() const
     {
         return CFDataGetTypeID();

Unit-Tests/Test-CFPP-Data.cpp

@@ -133,6 +133,19 @@ TEST( CFPP_Data, CTOR_STDInitializerList )
     ASSERT_TRUE( d[ 3 ] == 0xEF );
 }
 
+TEST( CFPP_Data, CTOR_STDVector )
+{
+    CF::Data d( std::vector< CF::Data::Byte > { 0xDE, 0xAD, 0xBE, 0xEF } );
+    
+    ASSERT_TRUE( d.IsValid() );
+    ASSERT_TRUE( d.GetLength() == 4 );
+    
+    ASSERT_TRUE( d[ 0 ] == 0xDE );
+    ASSERT_TRUE( d[ 1 ] == 0xAD );
+    ASSERT_TRUE( d[ 2 ] == 0xBE );
+    ASSERT_TRUE( d[ 3 ] == 0xEF );
+}
+
 TEST( CFPP_Data, CCTOR )
 {
     CF::Data d1;
@@ -293,6 +306,32 @@ TEST( CFPP_Data, OperatorAssignSTDString )
     ASSERT_TRUE( d2.GetLength() == 0 );
 }
 
+TEST( CFPP_Data, OperatorAssignSTDVector )
+{
+    CF::Data d1( { 0xFF } );
+    CF::Data d2( { 0xFF } );
+    
+    ASSERT_TRUE( d1.IsValid() );
+    ASSERT_TRUE( d2.IsValid() );
+    
+    ASSERT_EQ( d1.GetLength(), 1 );
+    ASSERT_EQ( d2.GetLength(), 1 );
+    
+    d1 = std::vector< CF::Data::Byte >( { 0xDE, 0xAD, 0xBE, 0xEF } );
+    d2 = std::vector< CF::Data::Byte >( {} );
+    
+    ASSERT_TRUE( d1.IsValid() );
+    ASSERT_TRUE( d2.IsValid() );
+    
+    ASSERT_EQ( d1.GetLength(), 4 );
+    ASSERT_EQ( d2.GetLength(), 0 );
+    
+    ASSERT_TRUE( d1[ 0 ] == 0xDE );
+    ASSERT_TRUE( d1[ 1 ] == 0xAD );
+    ASSERT_TRUE( d1[ 2 ] == 0xBE );
+    ASSERT_TRUE( d1[ 3 ] == 0xEF );
+}
+
 TEST( CFPP_Data, Referencing )
 {
     CF::Data d1;
@@ -478,6 +517,35 @@ TEST( CFPP_Data, OperatorPlusEqualSTDString )
     ASSERT_TRUE( d2[ 4 ] == 'h' );
 }
 
+TEST( CFPP_Data, OperatorPlusEqualSTDVector )
+{
+    CF::Data d1( { 0xFF } );
+    CF::Data d2( { 0xFF } );
+    
+    ASSERT_TRUE( d1.IsValid() );
+    ASSERT_TRUE( d2.IsValid() );
+    
+    ASSERT_EQ( d1.GetLength(), 1 );
+    ASSERT_EQ( d2.GetLength(), 1 );
+    
+    d1 += std::vector< CF::Data::Byte >( { 0xDE, 0xAD, 0xBE, 0xEF } );
+    d2 += std::vector< CF::Data::Byte >( {} );
+    
+    ASSERT_TRUE( d1.IsValid() );
+    ASSERT_TRUE( d2.IsValid() );
+    
+    ASSERT_EQ( d1.GetLength(), 5 );
+    ASSERT_EQ( d2.GetLength(), 1 );
+    
+    ASSERT_TRUE( d1[ 0 ] == 0xFF );
+    ASSERT_TRUE( d1[ 1 ] == 0xDE );
+    ASSERT_TRUE( d1[ 2 ] == 0xAD );
+    ASSERT_TRUE( d1[ 3 ] == 0xBE );
+    ASSERT_TRUE( d1[ 4 ] == 0xEF );
+    
+    ASSERT_TRUE( d2[ 0 ] == 0xFF );
+}
+
 TEST( CFPP_Data, GetTypeID )
 {
     CF::Data d;