data: Tests for DataType

* Added Array and Reference Modifier for DataType.
* Created basic tests for DataType.
* Fixed bug where qualifiers of modifiers were not copied correctly.
* Fixed bug where DataType modifiers were applied in the wrong (reverse) order.

src/lib/CMakeLists.txt

@@ -99,8 +99,13 @@ add_files(
 
 	data/type/modifier/DataTypeModifier.cpp
 	data/type/modifier/DataTypeModifier.h
+	data/type/modifier/DataTypeModifierArray.cpp
+	data/type/modifier/DataTypeModifierArray.h
 	data/type/modifier/DataTypeModifierPointer.cpp
 	data/type/modifier/DataTypeModifierPointer.h
+	data/type/modifier/DataTypeModifierReference.cpp
+	data/type/modifier/DataTypeModifierReference.h
+
 	data/type/DataType.cpp
 	data/type/DataType.h
 	data/type/DataTypeModifierStack.cpp

src/lib/data/parser/cxx/utilityCxx.cpp

@@ -1,7 +1,9 @@
 #include "data/parser/cxx/utilityCxx.h"
 
 #include "data/type/DataType.h"
+#include "data/type/modifier/DataTypeModifierArray.h"
 #include "data/type/modifier/DataTypeModifierPointer.h"
+#include "data/type/modifier/DataTypeModifierReference.h"
 #include "data/type/DataTypeModifierStack.h"
 #include "data/type/DataTypeQualifierList.h"
 
@@ -25,6 +27,23 @@ namespace utility
 
 				qualType = type->getPointeeType();
 			}
+			else if (type->isArrayType())
+			{
+				std::shared_ptr<DataTypeModifier> modifier = std::make_shared<DataTypeModifierArray>();
+				if (qualType.isConstQualified())
+					modifier->addQualifier(DataTypeQualifierList::QUALIFIER_CONST);
+				modifierStack.push(modifier);
+
+				qualType = clang::dyn_cast<clang::ArrayType>(type)->getElementType();
+			}
+			else if (type->isReferenceType())
+			{
+				std::shared_ptr<DataTypeModifier> modifier = std::make_shared<DataTypeModifierReference>();
+				// references can not be const qualified
+				modifierStack.push(modifier);
+
+				qualType = type->getPointeeType();
+			}
 			else if (type->isStructureOrClassType() || type->isEnumeralType())
 			{
 				typeName = qualType.getAsString();

src/lib/data/type/DataType.cpp

@@ -1,7 +1,18 @@
 #include "data/type/DataType.h"
 
+DataType::DataType(const std::string& typeName)
+	: m_typeName(typeName)
+{
+}
+
+DataType::DataType(const std::string& typeName, const DataTypeQualifierList& qualifierList)
+	: m_typeName(typeName)
+	, m_qualifierList(qualifierList)
+{
+}
+
 DataType::DataType(
-		const std::string& typeName, const DataTypeQualifierList qualifierList, const DataTypeModifierStack modifierStack
+		const std::string& typeName, const DataTypeQualifierList& qualifierList, const DataTypeModifierStack& modifierStack
 )
 	: m_typeName(typeName)
 	, m_qualifierList(qualifierList)

src/lib/data/type/DataType.h

@@ -10,8 +10,10 @@
 class DataType
 {
 public:
+	DataType(const std::string& typeName);
+	DataType(const std::string& typeName, const DataTypeQualifierList& qualifierList);
 	DataType(
-		const std::string& typeName, const DataTypeQualifierList qualifierList, const DataTypeModifierStack modifierStack
+		const std::string& typeName, const DataTypeQualifierList& qualifierList, const DataTypeModifierStack& modifierStack
 	);
 	~DataType();
 

src/lib/data/type/DataTypeModifierStack.cpp

@@ -12,6 +12,19 @@ DataTypeModifierStack::DataTypeModifierStack(const DataTypeModifierStack& o)
 	}
 }
 
+DataTypeModifierStack& DataTypeModifierStack::operator=(const DataTypeModifierStack &o)
+{
+	if (this != &o)
+	{
+		m_modifiers.clear();
+		for (std::shared_ptr<DataTypeModifier> modifier: o.m_modifiers)
+		{
+			m_modifiers.push_back(modifier->copy());
+		}
+	}
+	return *this;
+}
+
 DataTypeModifierStack::~DataTypeModifierStack()
 {
 }
@@ -23,10 +36,11 @@ void DataTypeModifierStack::push(std::shared_ptr<DataTypeModifier> modifier)
 
 std::string DataTypeModifierStack::applyTo(const std::string& typeName) const
 {
+	typedef std::vector<std::shared_ptr<DataTypeModifier>>::const_reverse_iterator StackIterator;
 	std::string modifiedTypeName = typeName;
-	for (std::shared_ptr<DataTypeModifier> modifier: m_modifiers)
+	for (StackIterator it = m_modifiers.rbegin(); it != m_modifiers.rend(); it++)
 	{
-		modifier->applyTo(modifiedTypeName);
+		(*it)->applyTo(modifiedTypeName);
 	}
 	return modifiedTypeName;
 }

src/lib/data/type/DataTypeModifierStack.h

@@ -12,8 +12,10 @@ class DataTypeModifierStack
 public:
 	DataTypeModifierStack();
 	DataTypeModifierStack(const DataTypeModifierStack& o);
+	DataTypeModifierStack& operator=(const DataTypeModifierStack &o);
 	~DataTypeModifierStack();
 
+
 	void push(std::shared_ptr<DataTypeModifier> modifier);
 
 	std::string applyTo(const std::string& typeName) const;

src/lib/data/type/modifier/DataTypeModifier.cpp

@@ -8,6 +8,13 @@ DataTypeModifier::~DataTypeModifier()
 {
 }
 
+std::shared_ptr<DataTypeModifier> DataTypeModifier::copy() const
+{
+	std::shared_ptr<DataTypeModifier> copy = doCopy();
+	copy->m_qualifierList = m_qualifierList;
+	return copy;
+}
+
 void DataTypeModifier::applyTo(std::string& typeName) const
 {
 	doApplyTo(typeName);

src/lib/data/type/modifier/DataTypeModifier.h

@@ -11,7 +11,7 @@ public:
 	DataTypeModifier();
 	virtual ~DataTypeModifier();
 
-	virtual std::shared_ptr<DataTypeModifier> copy() const = 0;
+	std::shared_ptr<DataTypeModifier> copy() const;
 
 	void applyTo(std::string& typeName) const;
 
@@ -20,6 +20,7 @@ public:
 	bool hasQualifier(DataTypeQualifierList::QualifierType qualifier) const;
 
 private:
+	virtual std::shared_ptr<DataTypeModifier> doCopy() const = 0;
 	virtual void doApplyTo(std::string& typeName) const = 0;
 
 	DataTypeQualifierList m_qualifierList;

src/lib/data/type/modifier/DataTypeModifierArray.cpp

@@ -0,0 +1,19 @@
+#include "data/type/modifier/DataTypeModifierArray.h"
+
+DataTypeModifierArray::DataTypeModifierArray()
+{
+}
+
+DataTypeModifierArray::~DataTypeModifierArray()
+{
+}
+
+std::shared_ptr<DataTypeModifier> DataTypeModifierArray::doCopy() const
+{
+	return std::make_shared<DataTypeModifierArray>();
+}
+
+void DataTypeModifierArray::doApplyTo(std::string& typeName) const
+{
+	typeName.append(" []");
+}

src/lib/data/type/modifier/DataTypeModifierArray.h

@@ -0,0 +1,17 @@
+#ifndef DATA_TYPE_MODIFIER_ARRAY_H
+#define DATA_TYPE_MODIFIER_ARRAY_H
+
+#include "data/type/modifier/DataTypeModifier.h"
+
+class DataTypeModifierArray: public DataTypeModifier
+{
+public:
+	DataTypeModifierArray();
+	virtual ~DataTypeModifierArray();
+
+private:
+	virtual std::shared_ptr<DataTypeModifier> doCopy() const;
+	virtual void doApplyTo(std::string& typeName) const;
+};
+
+#endif // DATA_TYPE_MODIFIER_ARRAY_H

src/lib/data/type/modifier/DataTypeModifierPointer.cpp

@@ -8,7 +8,7 @@ DataTypeModifierPointer::~DataTypeModifierPointer()
 {
 }
 
-std::shared_ptr<DataTypeModifier> DataTypeModifierPointer::copy() const
+std::shared_ptr<DataTypeModifier> DataTypeModifierPointer::doCopy() const
 {
 	return std::make_shared<DataTypeModifierPointer>();
 }

src/lib/data/type/modifier/DataTypeModifierPointer.h

@@ -9,9 +9,8 @@ public:
 	DataTypeModifierPointer();
 	virtual ~DataTypeModifierPointer();
 
-	virtual std::shared_ptr<DataTypeModifier> copy() const;
-
 private:
+	virtual std::shared_ptr<DataTypeModifier> doCopy() const;
 	virtual void doApplyTo(std::string& typeName) const;
 };
 

src/lib/data/type/modifier/DataTypeModifierQualifier.cpp

@@ -1,33 +0,0 @@
-#include "data/type/modifier/DataTypeModifierQualifier.h"
-
-DataTypeModifierQualifier::DataTypeModifierQualifier()
-	: m_qualifiers(QUALIFIER_NONE)
-{
-}
-
-DataTypeModifierQualifier::~DataTypeModifierQualifier()
-{
-}
-
-void DataTypeModifierQualifier::addQualifier(QualifierType qualifier)
-{
-	m_qualifiers = m_qualifiers | qualifier;
-}
-
-void DataTypeModifierQualifier::removeQualifier(QualifierType qualifier)
-{
-	m_qualifiers = m_qualifiers & ~qualifier;
-}
-
-bool DataTypeModifierQualifier::hasQualifier(QualifierType qualifier) const
-{
-	return (m_qualifiers & qualifier) > 0;
-}
-
-void DataTypeModifierQualifier::applyTo(std::string& typeName) const
-{
-	if (hasQualifier)
-	{
-		typeName.append(" const");
-	}
-}

src/lib/data/type/modifier/DataTypeModifierQualifier.h

@@ -1,28 +0,0 @@
-#ifndef DATA_TYPE_MODIFIER_QUALIFIER_H
-#define DATA_TYPE_MODIFIER_QUALIFIER_H
-
-#include "data/type/modifier/DataTypeModifier.h"
-
-class DataTypeModifierQualifier: public DataTypeModifier
-{
-public:
-	enum QualifierType
-	{
-		QUALIFIER_NONE = 0,
-		QUALIFIER_CONST = 1
-	};
-
-	DataTypeModifierQualifier();
-	virtual ~DataTypeModifierQualifier();
-
-	void addQualifier(QualifierType qualifier);
-	void removeQualifier(QualifierType qualifier);
-	bool hasQualifier(QualifierType qualifier) const;
-
-	virtual void applyTo(std::string& typeName) const;
-
-private:
-	char m_qualifiers;
-};
-
-#endif // DATA_TYPE_MODIFIER_QUALIFIER_H

src/lib/data/type/modifier/DataTypeModifierReference.cpp

@@ -0,0 +1,19 @@
+#include "data/type/modifier/DataTypeModifierReference.h"
+
+DataTypeModifierReference::DataTypeModifierReference()
+{
+}
+
+DataTypeModifierReference::~DataTypeModifierReference()
+{
+}
+
+std::shared_ptr<DataTypeModifier> DataTypeModifierReference::doCopy() const
+{
+	return std::make_shared<DataTypeModifierReference>();
+}
+
+void DataTypeModifierReference::doApplyTo(std::string& typeName) const
+{
+	typeName.append(" &");
+}

src/lib/data/type/modifier/DataTypeModifierReference.h

@@ -0,0 +1,17 @@
+#ifndef DATA_TYPE_MODIFIER_REFERENCE_H
+#define DATA_TYPE_MODIFIER_REFERENCE_H
+
+#include "data/type/modifier/DataTypeModifier.h"
+
+class DataTypeModifierReference: public DataTypeModifier
+{
+public:
+	DataTypeModifierReference();
+	virtual ~DataTypeModifierReference();
+
+private:
+	virtual std::shared_ptr<DataTypeModifier> doCopy() const;
+	virtual void doApplyTo(std::string& typeName) const;
+};
+
+#endif // DATA_TYPE_MODIFIER_REFERENCE_H

src/test/CMakeLists.txt

@@ -3,6 +3,7 @@ add_files(
 
 	ConfigManagerTestSuite.h
 	CxxParserTestSuite.h
+	DataTypeTestSuite.h
 	FileSystemTestSuite.h
 	GraphTestSuite.h
 	LogManagerTestSuite.h

src/test/DataTypeTestSuite.h

@@ -0,0 +1,87 @@
+#include "cxxtest/TestSuite.h"
+
+#include "data/type/DataType.h"
+#include "data/type/modifier/DataTypeModifierArray.h"
+#include "data/type/modifier/DataTypeModifierPointer.h"
+#include "data/type/modifier/DataTypeModifierReference.h"
+
+class DataTypeTestSuite: public CxxTest::TestSuite
+{
+public:
+	void test_datatype_created_with_name_has_no_qualifiers_or_modifiers()
+	{
+		DataType dataType("int");
+		TS_ASSERT_EQUALS("int", dataType.getFullTypeName());
+	}
+
+	void test_datatype_created_with_name_and_empty_qualifiers_has_no_qualifiers_or_modifiers()
+	{
+		DataTypeQualifierList qualifierList;
+		DataType dataType("int", qualifierList);
+		TS_ASSERT_EQUALS("int", dataType.getFullTypeName());
+	}
+
+	void test_datatype_created_with_name_and_const_qualifier_has_no_modifiers()
+	{
+		DataTypeQualifierList qualifierList;
+		qualifierList.addQualifier(DataTypeQualifierList::QUALIFIER_CONST);
+		DataType dataType("int", qualifierList);
+		TS_ASSERT_EQUALS("int const", dataType.getFullTypeName());
+	}
+
+	void test_datatype_created_with_name_and_empty_modifierstack_has_no_modifiers()
+	{
+		DataTypeQualifierList qualifierList;
+		DataTypeModifierStack modifierStack;
+		DataType dataType("int", qualifierList, modifierStack);
+		TS_ASSERT_EQUALS("int", dataType.getFullTypeName());
+	}
+
+	void test_datatype_created_with_name_and_array_modifier_has_array_modifier()
+	{
+		DataTypeQualifierList qualifierList;
+		DataTypeModifierStack modifierStack;
+		modifierStack.push(std::make_shared<DataTypeModifierArray>());
+		DataType dataType("int", qualifierList, modifierStack);
+		TS_ASSERT_EQUALS("int []", dataType.getFullTypeName());
+	}
+
+	void test_datatype_created_with_name_and_pointer_modifier_has_pointer_modifier()
+	{
+		DataTypeQualifierList qualifierList;
+		DataTypeModifierStack modifierStack;
+		modifierStack.push(std::make_shared<DataTypeModifierPointer>());
+		DataType dataType("int", qualifierList, modifierStack);
+		TS_ASSERT_EQUALS("int *", dataType.getFullTypeName());
+	}
+
+	void test_datatype_created_with_name_and_reference_modifier_has_reference_modifier()
+	{
+		DataTypeQualifierList qualifierList;
+		DataTypeModifierStack modifierStack;
+		modifierStack.push(std::make_shared<DataTypeModifierReference>());
+		DataType dataType("int", qualifierList, modifierStack);
+		TS_ASSERT_EQUALS("int &", dataType.getFullTypeName());
+	}
+
+	void test_datatype_created_with_name_and_const_pointer_modifier_has_const_pointer_modifier()
+	{
+		DataTypeQualifierList qualifierList;
+		DataTypeModifierStack modifierStack;
+		std::shared_ptr<DataTypeModifier> modifier = std::make_shared<DataTypeModifierPointer>();
+		modifier->addQualifier(DataTypeQualifierList::QUALIFIER_CONST);
+		modifierStack.push(modifier);
+		DataType dataType("int", qualifierList, modifierStack);
+		TS_ASSERT_EQUALS("int * const", dataType.getFullTypeName());
+	}
+
+	void test_datatype_created_with_name_and_pointer_pointer_modifier_has_pointer_pointer_modifier()
+	{
+		DataTypeQualifierList qualifierList;
+		DataTypeModifierStack modifierStack;
+		modifierStack.push(std::make_shared<DataTypeModifierPointer>());
+		modifierStack.push(std::make_shared<DataTypeModifierPointer>());
+		DataType dataType("int", qualifierList, modifierStack);
+		TS_ASSERT_EQUALS("int * *", dataType.getFullTypeName());
+	}
+};