- Fixed serialization of stringw-arrays again and learned another lesson of...

- Fixed serialization of stringw-arrays again and learned another lesson of "be very careful when changing const's".
- Added test for serialization
- Added operator != for quaternion.


git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@3026 dfc29bdd-3216-0410-991c-e03cc46cb475

include/IAttributes.h

@@ -234,12 +234,12 @@ public:
 	*/
 
 	//! Adds an attribute as wide string array
-	virtual void addArray(const c8* attributeName, core::array<core::stringw> value) = 0;
+	virtual void addArray(const c8* attributeName, const core::array<core::stringw>& value) = 0;
 
 	//! Sets an attribute value as a wide string array.
 	//! \param attributeName: Name for the attribute
 	//! \param value: Value for the attribute. Set this to 0 to delete the attribute
-	virtual void setAttribute(const c8* attributeName, const core::array<core::stringw> value) = 0;
+	virtual void setAttribute(const c8* attributeName, const core::array<core::stringw>& value) = 0;
 
 	//! Gets an attribute as an array of wide strings.
 	//! \param attributeName: Name of the attribute to get.
@@ -252,7 +252,7 @@ public:
 	virtual core::array<core::stringw> getAttributeAsArray(s32 index) = 0;
 
 	//! Sets an attribute as an array of wide strings
-	virtual void setAttribute(s32 index, core::array<core::stringw> value) = 0;
+	virtual void setAttribute(s32 index, const core::array<core::stringw>& value) = 0;
 
 
 	/*

include/quaternion.h

@@ -40,6 +40,9 @@ class quaternion
 		//! Equalilty operator
 		bool operator==(const quaternion& other) const;
 
+		//! inequality operator
+		bool operator!=(const quaternion& other) const;
+
 		//! Assignment operator
 		inline quaternion& operator=(const quaternion& other);
 
@@ -171,6 +174,11 @@ inline bool quaternion::operator==(const quaternion& other) const
 		(W == other.W));
 }
 
+// inequality operator
+inline bool quaternion::operator!=(const quaternion& other) const
+{
+	return !(*this == other);
+}
 
 // assignment operator
 inline quaternion& quaternion::operator=(const quaternion& other)
@@ -339,7 +347,7 @@ inline void quaternion::getMatrix( matrix4 &dest, const core::vector3df &center
 	m2.setInverseTranslation ( center );
 	lookat *= m2;
 */
-inline void quaternion::getMatrixCenter(matrix4 &dest, 
+inline void quaternion::getMatrixCenter(matrix4 &dest,
 					const core::vector3df &center,
 					const core::vector3df &translation) const
 {

source/Irrlicht/CAttributes.cpp

@@ -181,13 +181,13 @@ core::stringw CAttributes::getAttributeAsStringW(s32 index)
 
 
 //! Adds an attribute as an array of wide strings
-void CAttributes::addArray(const c8* attributeName, core::array<core::stringw> value)
+void CAttributes::addArray(const c8* attributeName, const core::array<core::stringw>& value)
 {
 	Attributes.push_back(new CStringWArrayAttribute(attributeName, value));
 }
 
 //! Sets an attribute value as an array of wide strings.
-void CAttributes::setAttribute(const c8* attributeName, const core::array<core::stringw> value)
+void CAttributes::setAttribute(const c8* attributeName, const core::array<core::stringw>& value)
 {
 	IAttribute* att = getAttributeP(attributeName);
 	if (att)
@@ -220,7 +220,7 @@ core::array<core::stringw> CAttributes::getAttributeAsArray(s32 index)
 }
 
 //! Sets an attribute as an array of wide strings
-void CAttributes::setAttribute(s32 index, core::array<core::stringw> value)
+void CAttributes::setAttribute(s32 index, const core::array<core::stringw>& value)
 {
 	if (index >= 0 && index < (s32)Attributes.size() )
 		Attributes[index]->setArray(value);

source/Irrlicht/CAttributes.h

@@ -210,12 +210,12 @@ public:
 	*/
 
 	//! Adds an attribute as wide string array
-	virtual void addArray(const c8* attributeName, core::array<core::stringw> value);
+	virtual void addArray(const c8* attributeName, const core::array<core::stringw>& value);
 
 	//! Sets an attribute value as a wide string array.
 	//! \param attributeName: Name for the attribute
 	//! \param value: Value for the attribute. Set this to 0 to delete the attribute
-	virtual void setAttribute(const c8* attributeName, const core::array<core::stringw> value);
+	virtual void setAttribute(const c8* attributeName, const core::array<core::stringw>& value);
 
 	//! Gets an attribute as an array of wide strings.
 	//! \param attributeName: Name of the attribute to get.
@@ -228,7 +228,7 @@ public:
 	virtual core::array<core::stringw> getAttributeAsArray(s32 index);
 
 	//! Sets an attribute as an array of wide strings
-	virtual void setAttribute(s32 index, core::array<core::stringw> value);
+	virtual void setAttribute(s32 index, const core::array<core::stringw>& value);
 
 	/*
 

source/Irrlicht/IAttribute.h

-// Copyright (C) 2002-2009 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine".
-// For conditions of distribution and use, see copyright notice in irrlicht.h
-
-#ifndef __I_ATTRIBUTE_H_INCLUDED__
-#define __I_ATTRIBUTE_H_INCLUDED__
-
-#include "IReferenceCounted.h"
-#include "SColor.h"
-#include "vector3d.h"
-#include "vector2d.h"
-#include "line2d.h"
-#include "line3d.h"
-#include "triangle3d.h"
-#include "position2d.h"
-#include "rect.h"
-#include "matrix4.h"
-#include "quaternion.h"
-#include "plane3d.h"
-#include "triangle3d.h"
-#include "line2d.h"
-#include "line3d.h"
-#include "irrString.h"
-#include "irrArray.h"
-#include "EAttributes.h"
-
-
-namespace irr
-{
-namespace io
-{
-
-class IAttribute : public virtual IReferenceCounted
-{
-public:
-
-	virtual ~IAttribute() {};
-
-	virtual s32 getInt()				{ return 0; }
-	virtual f32 getFloat()				{ return 0; }
-	virtual video::SColorf getColorf()		{ return video::SColorf(1.0f,1.0f,1.0f,1.0f); }
-	virtual video::SColor getColor()		{ return video::SColor(255,255,255,255); }
-	virtual core::stringc getString()		{ return core::stringc(getStringW().c_str()); }
-	virtual core::stringw getStringW()		{ return core::stringw(); }
-	virtual core::array<core::stringw> getArray()	{ return core::array<core::stringw>(); };
-	virtual bool getBool()				{ return false; }
-	virtual void getBinary(void* outdata, s32 maxLength) {};
-	virtual core::vector3df getVector()		{ return core::vector3df(); }
-	virtual core::position2di getPosition()	{ return core::position2di(); }
-	virtual core::rect<s32> getRect()		{ return core::rect<s32>(); }
-	virtual core::quaternion getQuaternion(){ return core::quaternion(); }
-	virtual core::matrix4 getMatrix()		{ return core::matrix4(); }
-	virtual core::triangle3df getTriangle()		{ return core::triangle3df(); }
-	virtual core::vector2df getVector2d()		{ return core::vector2df(); }
-	virtual core::vector2di getVector2di()		{ return core::vector2di(); }
-	virtual core::line2df getLine2d()		{ return core::line2df(); }
-	virtual core::line2di getLine2di()		{ return core::line2di(); }
-	virtual core::line3df getLine3d()		{ return core::line3df(); }
-	virtual core::line3di getLine3di()		{ return core::line3di(); }
-	virtual core::dimension2du getDimension2d()	{ return core::dimension2du(); }
-	virtual core::aabbox3d<f32> getBBox()		{ return core::aabbox3d<f32>(); }
-	virtual core::plane3df getPlane()		{ return core::plane3df(); }
-
-	virtual video::ITexture* getTexture()		{ return 0; }
-	virtual const char* getEnum()			{ return 0; }
-	virtual void* getUserPointer()			{ return 0; }
-
-	virtual void setInt(s32 intValue)		{};
-	virtual void setFloat(f32 floatValue)		{};
-	virtual void setString(const char* text)	{};
-	virtual void setString(const wchar_t* text){ setString(core::stringc(text).c_str()); };
-	virtual void setArray( core::array<core::stringw> arr )	{};
-	virtual void setColor(video::SColorf color)	{};
-	virtual void setColor(video::SColor color)	{};
-	virtual void setBool(bool boolValue)		{};
-	virtual void setBinary(void* data, s32 maxLenght) {};
-	virtual void setVector(core::vector3df v)	{};
-	virtual void setPosition(core::position2di v)	{};
-	virtual void setRect(core::rect<s32> v)		{};
-	virtual void setQuaternion(core::quaternion v) {};
-	virtual void setMatrix(core::matrix4 v) {};
-	virtual void setTriangle(core::triangle3df v) {};
-	virtual void setVector2d(core::vector2df v) {};
-	virtual void setVector2d(core::vector2di v) {};
-	virtual void setLine2d(core::line2df v) {};
-	virtual void setLine2d(core::line2di v) {};
-	virtual void setLine3d(core::line3df v) {};
-	virtual void setLine3d(core::line3di v) {};
-	virtual void setDimension2d(core::dimension2du v) {};
-	virtual void setBBox(core::aabbox3d<f32> v) {};
-	virtual void setPlane(core::plane3df v) {};
-	virtual void setUserPointer(void* v)	{};
-
-	virtual void setEnum(const char* enumValue, const char* const* enumerationLiterals) {};
-	virtual void setTexture(video::ITexture*)	{};
-
-	core::stringc Name;
-
-	virtual E_ATTRIBUTE_TYPE getType() const = 0;
-	virtual const wchar_t* getTypeString() const = 0;
-};
-
-} // end namespace io
-} // end namespace irr
-
-#endif
+// Copyright (C) 2002-2009 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __I_ATTRIBUTE_H_INCLUDED__
+#define __I_ATTRIBUTE_H_INCLUDED__
+
+#include "IReferenceCounted.h"
+#include "SColor.h"
+#include "vector3d.h"
+#include "vector2d.h"
+#include "line2d.h"
+#include "line3d.h"
+#include "triangle3d.h"
+#include "position2d.h"
+#include "rect.h"
+#include "matrix4.h"
+#include "quaternion.h"
+#include "plane3d.h"
+#include "triangle3d.h"
+#include "line2d.h"
+#include "line3d.h"
+#include "irrString.h"
+#include "irrArray.h"
+#include "EAttributes.h"
+
+
+namespace irr
+{
+namespace io
+{
+
+class IAttribute : public virtual IReferenceCounted
+{
+public:
+
+	virtual ~IAttribute() {};
+
+	virtual s32 getInt()				{ return 0; }
+	virtual f32 getFloat()				{ return 0; }
+	virtual video::SColorf getColorf()		{ return video::SColorf(1.0f,1.0f,1.0f,1.0f); }
+	virtual video::SColor getColor()		{ return video::SColor(255,255,255,255); }
+	virtual core::stringc getString()		{ return core::stringc(getStringW().c_str()); }
+	virtual core::stringw getStringW()		{ return core::stringw(); }
+	virtual core::array<core::stringw> getArray()	{ return core::array<core::stringw>(); };
+	virtual bool getBool()				{ return false; }
+	virtual void getBinary(void* outdata, s32 maxLength) {};
+	virtual core::vector3df getVector()		{ return core::vector3df(); }
+	virtual core::position2di getPosition()	{ return core::position2di(); }
+	virtual core::rect<s32> getRect()		{ return core::rect<s32>(); }
+	virtual core::quaternion getQuaternion(){ return core::quaternion(); }
+	virtual core::matrix4 getMatrix()		{ return core::matrix4(); }
+	virtual core::triangle3df getTriangle()		{ return core::triangle3df(); }
+	virtual core::vector2df getVector2d()		{ return core::vector2df(); }
+	virtual core::vector2di getVector2di()		{ return core::vector2di(); }
+	virtual core::line2df getLine2d()		{ return core::line2df(); }
+	virtual core::line2di getLine2di()		{ return core::line2di(); }
+	virtual core::line3df getLine3d()		{ return core::line3df(); }
+	virtual core::line3di getLine3di()		{ return core::line3di(); }
+	virtual core::dimension2du getDimension2d()	{ return core::dimension2du(); }
+	virtual core::aabbox3d<f32> getBBox()		{ return core::aabbox3d<f32>(); }
+	virtual core::plane3df getPlane()		{ return core::plane3df(); }
+
+	virtual video::ITexture* getTexture()		{ return 0; }
+	virtual const char* getEnum()			{ return 0; }
+	virtual void* getUserPointer()			{ return 0; }
+
+	virtual void setInt(s32 intValue)		{};
+	virtual void setFloat(f32 floatValue)		{};
+	virtual void setString(const char* text)	{};
+	virtual void setString(const wchar_t* text){ setString(core::stringc(text).c_str()); };
+	virtual void setArray(const core::array<core::stringw>& arr )	{};
+	virtual void setColor(video::SColorf color)	{};
+	virtual void setColor(video::SColor color)	{};
+	virtual void setBool(bool boolValue)		{};
+	virtual void setBinary(void* data, s32 maxLenght) {};
+	virtual void setVector(core::vector3df v)	{};
+	virtual void setPosition(core::position2di v)	{};
+	virtual void setRect(core::rect<s32> v)		{};
+	virtual void setQuaternion(core::quaternion v) {};
+	virtual void setMatrix(core::matrix4 v) {};
+	virtual void setTriangle(core::triangle3df v) {};
+	virtual void setVector2d(core::vector2df v) {};
+	virtual void setVector2d(core::vector2di v) {};
+	virtual void setLine2d(core::line2df v) {};
+	virtual void setLine2d(core::line2di v) {};
+	virtual void setLine3d(core::line3df v) {};
+	virtual void setLine3d(core::line3di v) {};
+	virtual void setDimension2d(core::dimension2du v) {};
+	virtual void setBBox(core::aabbox3d<f32> v) {};
+	virtual void setPlane(core::plane3df v) {};
+	virtual void setUserPointer(void* v)	{};
+
+	virtual void setEnum(const char* enumValue, const char* const* enumerationLiterals) {};
+	virtual void setTexture(video::ITexture*)	{};
+
+	core::stringc Name;
+
+	virtual E_ATTRIBUTE_TYPE getType() const = 0;
+	virtual const wchar_t* getTypeString() const = 0;
+};
+
+} // end namespace io
+} // end namespace irr
+
+#endif

tests/main.cpp

@@ -68,6 +68,7 @@ int main(int argumentCount, char * arguments[])
 	TEST(filesystem);
 	TEST(archiveReader);
 	TEST(testXML);
+	TEST(serializeAttributes);
 	// null driver
 	TEST(fast_atof);
 	TEST(collisionResponseAnimator);

tests/serializeAttributes.cpp

+#include "testUtils.h"
+
+using namespace irr;
+using namespace core;
+using namespace io;
+
+#define COMPARE(a, b) if ( (a) != (b) ) { logTestString("Not identical %s in %s:%d", #a, __FILE__, __LINE__ ); return false; }
+
+const u32 BINARY_BLOCK_SIZE = 10;
+
+enum EMockEnum
+{
+	EME_NONE,
+	EME_ONE,
+	EME_COUNT
+};
+
+const c8* const MockEnumNames[EME_COUNT+1] =
+{
+	"none",
+	"one",
+	0,
+};
+
+class SerializableMock : public virtual io::IAttributeExchangingObject
+{
+public:
+
+	virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const
+	{
+		out->addInt("valInt", valInt);
+		out->addFloat("valFloat", valFloat);
+		out->addString("valString", valString.c_str());
+		out->addString("valStringW", valStringW.c_str());
+		out->addBinary("valBinary", (void*)valBinary, BINARY_BLOCK_SIZE);
+		out->addArray("valStringWArray", valStringWArray);
+		out->addBool("valBool", valBool);
+		out->addEnum("valEnum", valEnum, MockEnumNames);
+		out->addColor("valColor", valColor);
+		out->addColorf("valColorf", valColorf);
+		out->addVector3d("valVector3df", valVector3df);
+		out->addPosition2d("valPosition2di", valPosition2di);
+		out->addRect("valRect", valRect);
+		out->addMatrix("valMatrix", valMatrix);
+		out->addQuaternion("valQuaternion", valQuaternion);
+		out->addBox3d("valAabbox3df", valAabbox3df);
+		out->addPlane3d("valPlane3df", valPlane3df);
+		out->addTriangle3d("valTriangle3df", valTriangle3df);
+		out->addLine2d("valLine2df", valLine2df);
+		out->addLine3d("valLine3df", valLine3df);
+		out->addTexture("valTexture", valTexture );
+		out->addUserPointer("valPointer", valPointer);
+	}
+
+	virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options)
+	{
+		valInt = in->getAttributeAsInt("valInt");
+		valFloat = in->getAttributeAsFloat("valFloat");
+		valString = in->getAttributeAsString("valString");
+		valStringW = in->getAttributeAsStringW("valStringW");
+		in->getAttributeAsBinaryData("valBinary", valBinary, BINARY_BLOCK_SIZE);
+		valStringWArray = in->getAttributeAsArray("valStringWArray");
+		valBool = in->getAttributeAsBool("valBool");
+		valEnum = (EMockEnum)in->getAttributeAsEnumeration("valEnum", MockEnumNames);
+		valColor = in->getAttributeAsColor("valColor");
+		valColorf = in->getAttributeAsColorf("valColorf");
+		valVector3df = in->getAttributeAsVector3d("valVector3df");
+		valPosition2di = in->getAttributeAsPosition2d("valPosition2di");
+		valRect = in->getAttributeAsRect("valRect");
+		valMatrix = in->getAttributeAsMatrix("valMatrix");
+		valQuaternion = in->getAttributeAsQuaternion("valQuaternion");
+		valAabbox3df = in->getAttributeAsBox3d("valAabbox3df");
+		valPlane3df = in->getAttributeAsPlane3d("valPlane3df");
+		valTriangle3df = in->getAttributeAsTriangle3d("valTriangle3df");
+		valLine2df = in->getAttributeAsLine2d("valLine2df");
+		valLine3df = in->getAttributeAsLine3d("valLine3df");
+		valTexture = in->getAttributeAsTexture("valTexture");
+		valPointer = in->getAttributeAsUserPointer("valPointer");
+	}
+
+	bool operator==(const SerializableMock& other)
+	{
+		COMPARE(valInt, other.valInt);
+		COMPARE(valFloat, other.valFloat);
+		COMPARE(valString, other.valString);
+		COMPARE(valStringW, other.valStringW);
+		if ( memcmp( valBinary, other.valBinary, BINARY_BLOCK_SIZE) != 0 )
+		{
+			logTestString("Not identical %s in %s:%d", "valBinary",  __FILE__, __LINE__ );
+			return false;
+		}
+		COMPARE(valStringWArray, other.valStringWArray);
+		COMPARE(valBool, other.valBool);
+		COMPARE(valEnum, other.valEnum);
+		COMPARE(valColor, other.valColor);
+		if ( valColorf.r != other.valColorf.r || valColorf.g != other.valColorf.g || valColorf.b != other.valColorf.b || valColorf.a != other.valColorf.a )
+		{
+			logTestString("Not identical %s in %s:%d", "valColorf",  __FILE__, __LINE__ );
+			return false;
+		}
+		COMPARE(valVector3df, other.valVector3df);
+		COMPARE(valPosition2di, other.valPosition2di);
+		COMPARE(valRect, other.valRect);
+		COMPARE(valMatrix, other.valMatrix);
+		COMPARE(valQuaternion, other.valQuaternion);
+		COMPARE(valAabbox3df, other.valAabbox3df);
+		COMPARE(valPlane3df, other.valPlane3df);
+		COMPARE(valTriangle3df, other.valTriangle3df);
+		COMPARE(valLine2df, other.valLine2df);
+		COMPARE(valLine3df, other.valLine3df);
+//		valTexture;
+		COMPARE(valPointer, other.valPointer);
+		return true;
+	}
+
+	void reset()
+	{
+		valInt = 0;
+		valFloat = 0.f;
+		valString = "";
+		valStringW = L"";
+		memset(valBinary, 0, BINARY_BLOCK_SIZE);
+		valStringWArray.clear();
+		valBool = false;
+		valEnum = EME_NONE;
+		valColor.set(0,0,0,0);
+		valColorf.set(0.f, 0.f, 0.f, 0.f);
+		valVector3df.set(0.f, 0.f, 0.f);
+		valPosition2di.set(0,0);
+		valRect = core::rect<s32>(0,0,0,0);
+		valMatrix.makeIdentity();
+		valQuaternion.set(0,0,0,0);
+		valAabbox3df.reset(0,0,0);
+		valPlane3df.setPlane(vector3df(0.f,0.f,0.f), 0.f);
+		valTriangle3df.set( vector3df(0.f,0.f,0.f), vector3df(0.f,0.f,0.f), vector3df(0.f,0.f,0.f) );
+		valLine2df.setLine(0.f, 0.f, 0.f, 0.f);
+		valLine3df.setLine(0.f, 0.f, 0.f, 0.f, 0.f, 0.f);
+		valTexture = NULL;
+		valPointer = 0;
+	}
+
+	void set()
+	{
+		valInt = 1;
+		valFloat = 1.f;
+		valString = "one";
+		valStringW = L"ONE";
+		memset(valBinary, 0xff, BINARY_BLOCK_SIZE);
+		valStringWArray.push_back( stringw("ONE") );
+		valStringWArray.push_back( stringw("TWO") );
+		valStringWArray.push_back( stringw("THREE") );
+		valBool = true;
+		valEnum = EME_ONE;
+		valColor.set(1,2,3,4);
+		valColorf.set(1.f, 2.f, 3.f, 4.f);
+		valVector3df.set(1.f, 2.f, 3.f);
+		valPosition2di.set(1,2);
+		valRect = core::rect<s32>(1,2,3,4);
+		valMatrix = 99.9f;
+		valQuaternion.set(1,2,3,4);
+		valAabbox3df.reset(1,2,3);
+		valPlane3df.setPlane(vector3df(1.f,2.f,3.f), 4.f);
+		valTriangle3df.set( vector3df(1.f,2.f,3.f), vector3df(4.f,5.f,6.f), vector3df(7.f,8.f,9.f) );
+		valLine2df.setLine(1.f, 2.f, 3.f, 4.f);
+		valLine3df.setLine(1.f, 2.f, 3.f, 4.f, 5.f, 6.f);
+		valTexture = NULL;	// TODO
+		valPointer = (void*)0xffffff;
+	}
+
+	s32 						valInt;
+	f32 						valFloat;
+	core::stringc 				valString;
+	core::stringw 				valStringW;
+	char 						valBinary[BINARY_BLOCK_SIZE];
+	core::array<core::stringw> 	valStringWArray;
+	bool 						valBool;
+	EMockEnum					valEnum;
+	video::SColor 				valColor;
+	video::SColorf 				valColorf;
+	core::vector3df 			valVector3df;
+	core::position2di 			valPosition2di;
+	core::rect<s32> 			valRect;
+	core::matrix4 				valMatrix;
+	core::quaternion 			valQuaternion;
+	core::aabbox3df 			valAabbox3df;
+	core::plane3df 				valPlane3df;
+	core::triangle3df 			valTriangle3df;
+	core::line2df 				valLine2df;
+	core::line3df 				valLine3df;
+	video::ITexture* 			valTexture;
+	void* 						valPointer;
+};
+
+bool serializeAttributes()
+{
+	IrrlichtDevice * device = irr::createDevice(video::EDT_NULL, dimension2d<u32>(1, 1));
+	assert(device);
+	if(!device)
+		return false;
+
+	io::IFileSystem * fs = device->getFileSystem ();
+	if ( !fs )
+		return false;
+
+	SerializableMock origMock, copyMock;
+	origMock.set();
+	copyMock.reset();
+
+	io::IAttributes* attr = fs->createEmptyAttributes();
+	origMock.serializeAttributes(attr, 0);
+	copyMock.deserializeAttributes(attr, 0);
+
+	return origMock == copyMock;
+}

tests/tests-last-passed-at.txt

-Test suite pass at GMT Mon Dec  7 22:44:25 2009
+Test suite pass at GMT Tue Dec  8 04:35:12 2009