diff --git a/librerie/exercise1/container/container.cpp b/librerie/exercise1/container/container.cpp index 6a22d84..6bbe4bf 100644 --- a/librerie/exercise1/container/container.cpp +++ b/librerie/exercise1/container/container.cpp @@ -14,4 +14,5 @@ bool FoldableContainer::Exists(const Data& dat) const noexcept{ FoldPreOrder(&AuxFoldExists, &dat, &exists); return exists; } + } diff --git a/librerie/exercise1/container/container.hpp b/librerie/exercise1/container/container.hpp index bd42995..c1aeca4 100644 --- a/librerie/exercise1/container/container.hpp +++ b/librerie/exercise1/container/container.hpp @@ -2,17 +2,11 @@ #ifndef CONTAINER_HPP #define CONTAINER_HPP -/* ************************************************************************** */ - #include #include -/* ************************************************************************** */ - namespace lasd { -/* ************************************************************************** */ - class Container { private: @@ -26,40 +20,35 @@ public: // Destructor virtual ~Container() = default; - /* ************************************************************************ */ - // Copy assignment - Container& operator=(const Container&) = delete; // Copy assignment of abstract types should not be possible. + Container& operator=(const Container&) = delete; // Copy assignment of abstract types should not be possible. // Move assignment - Container& operator=(Container&&) noexcept = delete; // Move assignment of abstract types should not be possible. - - /* ************************************************************************ */ + Container& operator=(Container&&) noexcept = delete;; // Move assignment of abstract types should not be possible. // Comparison operators - bool operator==(const Container&) const noexcept = delete; // Comparison of abstract types might not be possible. - bool operator!=(const Container&) const noexcept = delete; // Comparison of abstract types might not be possible. - - /* ************************************************************************ */ + bool operator==(const Container&) const noexcept = delete; // Comparison of abstract types might not be possible. + bool operator!=(const Container&&) const noexcept = delete; // Comparison of abstract types might not be possible. // Specific member functions - virtual bool Empty() const noexcept { // (concrete function should not throw exceptions) - return (size==0); - }; + virtual bool Empty() const noexcept { + return (size == 0); + } // (concrete function should not throw exceptions) - virtual ulong Size() const noexcept{ - return size; - } // (concrete function should not throw exceptions) - - virtual void Clear() = 0; + virtual ulong Size() const noexcept { + return size; + } // (concrete function should not throw exceptions) + virtual void Clear() = 0; }; /* ************************************************************************** */ + + template -class LinearContainer : virtual public Container { // Must extend Container +class LinearContainer : virtual public Container{ // Must extend Container private: @@ -70,15 +59,11 @@ public: // Destructor virtual ~LinearContainer() = default; - /* ************************************************************************ */ - // Copy assignment LinearContainer& operator=(const LinearContainer&) = delete; // Copy assignment of abstract types should not be possible. // Move assignment - LinearContainer& operator=(LinearContainer&&) = delete; // Move assignment of abstract types should not be possible. - - /* ************************************************************************ */ + LinearContainer& operator=(LinearContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. // Comparison operators bool operator==(const LinearContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. @@ -95,10 +80,8 @@ public: }; -/* ************************************************************************** */ - template -class TestableContainer : public Container { // Must extend Container +class TestableContainer : virtual public Container{ // Must extend Container private: @@ -109,16 +92,12 @@ public: // Destructor virtual ~TestableContainer() = default; - /* ************************************************************************ */ - // Copy assignment TestableContainer& operator=(const TestableContainer&) = delete; // Copy assignment of abstract types should not be possible. // Move assignment TestableContainer& operator=(TestableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. - /* ************************************************************************ */ - // Comparison operators bool operator==(const TestableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. bool operator!=(const TestableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. @@ -131,8 +110,6 @@ public: }; -/* ************************************************************************** */ - template class MappableContainer : virtual public Container { // Must extend Container @@ -145,22 +122,16 @@ public: // Destructor virtual ~MappableContainer() = default; - /* ************************************************************************ */ - // Copy assignment - MappableContainer& operator=(const MappableContainer&) = delete; // Copy assignment of abstract types should not be possible. + MappableContainer& operator=(const MappableContainer&) = delete; // Copy assignment of abstract types should not be possible. // Move assignment MappableContainer& operator=(MappableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. - /* ************************************************************************ */ - // Comparison operators bool operator==(const MappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. bool operator!=(const MappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - /* ************************************************************************ */ - // Specific member functions typedef std::function MapFunctor; @@ -170,8 +141,6 @@ public: }; -/* ************************************************************************** */ - template class FoldableContainer : virtual public TestableContainer{ // Must extend TestableContainer @@ -184,25 +153,19 @@ public: // Destructor virtual ~FoldableContainer() = default; - /* ************************************************************************ */ - // Copy assignment FoldableContainer& operator=(const FoldableContainer&) = delete; // Copy assignment of abstract types should not be possible. // Move assignment FoldableContainer& operator=(FoldableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. - /* ************************************************************************ */ - // Comparison operators - bool operator==(const FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - bool operator!=(const FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - - /* ************************************************************************ */ + bool operator==(FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. + bool operator!=(FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. // Specific member functions - typedef std::function FoldFunctor; + typedef std::function FoldFunctor; virtual void FoldPreOrder(const FoldFunctor, const void*, void*) const = 0; virtual void FoldPostOrder(const FoldFunctor, const void*, void*) const = 0; diff --git a/librerie/exercise1/list/list.cpp b/librerie/exercise1/list/list.cpp index 0786682..14e8c61 100644 --- a/librerie/exercise1/list/list.cpp +++ b/librerie/exercise1/list/list.cpp @@ -1,141 +1,149 @@ + namespace lasd { - // Specific constructor - template - List::Node::Node(Data newValue){ - value = newValue; - next = nullptr; - } - // Copy constructor - template - List::Node::Node(const Node& copyFrom){ - value = copyFrom.value; - } - template - List::Node::Node(const Data& copyFrom){ - value = copyFrom; - } +/* ************************************************************************** */ - // Move constructor - template - List::Node::Node(Node&& moveFrom){ - std::move(value, moveFrom.value); - std::move(next, moveFrom.next); - } - template - List::Node::Node(Data&& moveFrom){ - std::move(value, moveFrom); - } +// Specific constructors +template +List::Node::Node(Data newValue){ + value = newValue; + next = nullptr; +} - // Comparison operator - template - bool List::Node::operator==(const Node& node) const noexcept{ - if(node.value == value) return true; - else return false; - // TODO: deve confrontare anche il puntatore? - } - template - bool List::Node::operator!=(const Node& node) const noexcept{ - if(node.value != value) return true; - else return false; - // TODO: deve confrontare anche il puntatore? - // return !(this==node) - } +// Copy constructor +template +List::Node::Node(const Node& copyFrom){ + value = copyFrom.value; +} - template - List::List(const LinearContainer& con){ - for(ulong i=0 ; i +List::Node::Node(Node&& moveFrom){ + std::move(value, moveFrom.value); + std::move(next, moveFrom.next); +} + +template +List::Node::Node(Data&& moveFrom){ + std::move(value, moveFrom); +} + + +// Comparison operator +template +bool List::Node::operator==(const Node& node)const noexcept{ + return (node.value == value); +} + +template +bool List::Node::operator!=(const Node& node)const noexcept{ + return !(*this == node); +} + + +// Specific constructor +template +List::List(const LinearContainer& con){ + for(ulong i = 0; i - List::List(const List& copyFrom){ - for(ulong i=0 ; i +List::List(const List& copyFrom){ + for(ulong i = 0; i - List::List(List&& moveFrom){ - std::swap(size, moveFrom.size); - std::swap(head, moveFrom.head); - std::swap(tail, moveFrom.tail); - } +// Move constructor +template +List::List(List&& moveFrom){ + std::swap(size, moveFrom.size); + std::swap(head, moveFrom.head); + std::swap(tail, moveFrom.tail); +} - // Destructor - template - List::~List(){ - Clear(); - } +template +List::~List(){ + Clear(); +} - // Copy assignment - template - List& List::operator=(const List& copyFrom){ - if(*this != copyFrom){ - Clear(); - for(ulong i=0 ; i + List& List::operator=(const List& copyFrom){ + if(*this != copyFrom){ + Clear(); + for(ulong i = 0; i - List& List::operator=(List&& moveFrom){ - if(*this != moveFrom){ - Clear(); - std::swap(size, moveFrom.size); - std::swap(head, moveFrom.head); - std::swap(tail, moveFrom.tail); - } - return *this; + //Move assignment + template + List& List::operator=(List&& moveFrom)noexcept{ + if(*this != moveFrom){ + //Clear(); + std::swap(size, moveFrom.size); + std::swap(head, moveFrom.head); + std::swap(tail, moveFrom.tail); } + return *this; + } - // Comparison operators - template - bool List::operator==(const List& list) const noexcept{ - if(this->size != list.Size()) return false; - for(ulong i=0 ; i<(this->size) ; ++i){ - if(*this[i] != list[i]) return false; - } - return true; - } + //Comparison operators + template + bool List::operator==(const List& list) const noexcept{ + if(this->size != list.Size()) return false; + for(ulong i = 0; i < (this->size); ++i){ + if((*this)[i] != list[i]) return false; + } + return true; + } - template - bool List::operator!=(const List& list) const noexcept{ - return !(*this == list); - } +template +bool List::operator!=(const List& list) const noexcept{ + return !(*this==list); +} - // Specific member functions - template - void List::InsertAtFront(const Data& data){ - struct Node* tmp = new Node(data); - tmp->next = head; - head = tmp; - size++; - if(size==1){ +// Specific member functions + + template + void List::InsertAtFront(const Data& data){ + struct Node* tmp = new Node(data); + tmp->next = head; + head =tmp; + size++; + + if(size == 1){ tail = head; } - } + } + template void List::InsertAtFront(Data&& data){ struct Node* tmp = new Node(data); tmp->next = head; - head = tmp; + head =tmp; size++; - if(size==1){ - tail = head; - } + + if(size == 1){ + tail = head; + } } template void List::RemoveFromFront(){ - if(head==nullptr){ + if(head == nullptr){ throw std::length_error("List is empty!"); - }else{ + } + else{ struct Node* tmp = head; head = head->next; delete tmp; @@ -145,9 +153,10 @@ namespace lasd { template Data List::FrontNRemove(){ - if(head==nullptr){ + if(head == nullptr){ throw std::length_error("List is empty!"); - }else{ + } + else{ Data value = head->value; RemoveFromFront(); return value; @@ -156,9 +165,10 @@ namespace lasd { template void List::InsertAtBack(const Data& data){ - if(size==0){ + if(size == 0){ InsertAtFront(data); - }else{ + } + else{ struct Node* last = new Node(data); tail->next = last; tail = last; @@ -168,9 +178,10 @@ namespace lasd { template void List::InsertAtBack(Data&& data){ - if(size==0){ + if(size == 0){ InsertAtFront(data); - }else{ + } + else{ struct Node* last = new Node(data); tail->next = last; tail = last; @@ -180,14 +191,14 @@ namespace lasd { template void List::Clear(){ - while(head!=nullptr){ + while(head != nullptr){ RemoveFromFront(); } } template Data& List::Front() const{ - if(size==0){ + if(size == 0){ throw std::length_error("List is empty!"); }else{ return head->value; @@ -196,7 +207,7 @@ namespace lasd { template Data& List::Back() const{ - if(size==0){ + if(size == 0){ throw std::length_error("List is empty!"); }else{ return tail->value; @@ -204,67 +215,77 @@ namespace lasd { } template - Data& List::operator[](const ulong index) const{ - if(index>=size || index<0){ - throw std::out_of_range("Out of range!"); - }else{ + Data& List::operator[](const ulong idx) const{ + if(idx >= size || idx < 0){ + throw std::out_of_range("Out of Range!"); + }else + { struct Node* tmp = head; - for(ulong i=0 ; inext; } return tmp->value; } } - template - void List::MapPreOrder(const MapFunctor fun, void* par){ - MapPreOrder(fun, par, head); - } template - void List::MapPreOrder(MapFunctor function, void* par, struct Node* node){ - if(node == nullptr) - return; - function(node->value, par); - MapPreOrder(function, par, node->next); - } + void List::MapPreOrder(MapFunctor function, void* par){ + MapPreOrder(function, par, head); + } - template - void List::MapPostOrder(MapFunctor function, void* par){ - MapPostOrder(function, par, head); - } + template + void List::MapPostOrder(MapFunctor function, void* par){ + MapPostOrder(function, par, head); + } - template - void List::MapPostOrder(MapFunctor function, void* par, struct Node* node){ - if(node == nullptr) - return; - MapPostOrder(function, par, node->next); - function(node->value, par); - } + template + void List::FoldPreOrder(FoldFunctor function, const void* constPar, void* par) const{ + FoldPreOrder(function, constPar, par, head); + } - template - void List::FoldPreOrder(FoldFunctor function, const void* constPar, void* par) const{ - FoldPreOrder(function, constPar, par, head); - } + template + void List::FoldPostOrder(FoldFunctor function, const void* constPar, void* par) const{ + FoldPostOrder(function, constPar, par, head); + } - template - void List::FoldPreOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{ - if(node == nullptr) - return; - function(node->value, constPar, par); - FoldPreOrder(function, constPar, par, node->next); - } + //OVERLOAD Accessory Function - template - void List::FoldPostOrder(FoldFunctor function, const void* constPar, void* par) const{ - FoldPostOrder(function, constPar, par, head); -} - - template - void List::FoldPostOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{ - if(node == nullptr) - return; - FoldPostOrder(function, constPar, par, node->next); - function(node->value, constPar, par); - } + template + void List::MapPreOrder(MapFunctor function, void* par, struct Node* node){ + if(node == nullptr) + return; + + function(node->value, par); + MapPreOrder(function, par, node->next); + } + + template + void List::MapPostOrder(MapFunctor function, void* par, struct Node* node){ + if(node == nullptr) + return; + + MapPostOrder(function, par, node->next); + function(node->value, par); + } + + template + void List::FoldPreOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{ + + if(node == nullptr) + return; + + function(node->value, constPar, par); + FoldPreOrder(function, constPar, par, node->next); + } + + template + void List::FoldPostOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{ + if(node == nullptr) + return; + + FoldPostOrder(function, constPar, par, node->next); + function(node->value, constPar, par); + } +/* ************************************************************************** */ } diff --git a/librerie/exercise1/list/list.hpp b/librerie/exercise1/list/list.hpp index c0ce133..debbf72 100644 --- a/librerie/exercise1/list/list.hpp +++ b/librerie/exercise1/list/list.hpp @@ -13,31 +13,30 @@ namespace lasd { /* ************************************************************************** */ template -class List : virtual public LinearContainer, - virtual public MappableContainer, - virtual public FoldableContainer { // Must extend LinearContainer, MappableContainer, and FoldableContainer +class List : virtual public LinearContainer, + virtual public MappableContainer, + virtual public FoldableContainer{ // Must extend LinearContainer, MappableContainer, and FoldableContainer private: protected: - using LinearContainer::size; + using LinearContainer:: size; struct Node { Data value; - Node* next = nullptr; + Node* next = nullptr; /* ********************************************************************** */ // Specific constructors - Node(Data); + Node(Data); /* ********************************************************************** */ // Copy constructor Node(const Node&); - Node(const Data&); // Move constructor Node(Node&&); @@ -53,6 +52,11 @@ protected: // Comparison operators bool operator==(const Node&) const noexcept; bool operator!=(const Node&) const noexcept; + + /* ********************************************************************** */ + + // Specific member functions + }; struct Node* head = nullptr; @@ -66,14 +70,14 @@ public: /* ************************************************************************ */ // Specific constructor - List(const LinearContainer&); // A list obtained from a LinearContainer + List(const LinearContainer&); // A list obtained from a LinearContainer /* ************************************************************************ */ // Copy constructor List(const List&); - //Move constructor + // Move constructor List(List&&); /* ************************************************************************ */ @@ -84,16 +88,16 @@ public: /* ************************************************************************ */ // Copy assignment - List& operator=(const List&); + List& operator=(const List&); // Move assignment - List& operator=(List&&) noexcept; + List& operator=(List&&) noexcept; /* ************************************************************************ */ // Comparison operators - bool operator==(const List&) const noexcept; - bool operator!=(const List&) const noexcept; + bool operator==(const List&) const noexcept; + bool operator!=(const List&) const noexcept; /* ************************************************************************ */ @@ -111,14 +115,14 @@ public: // Specific member functions (inherited from Container) - void Clear() override; // Override Container member + void Clear() override; // Override Container member /* ************************************************************************ */ // Specific member functions (inherited from LinearContainer) - Data& Front() override const; // Override LinearContainer member (must throw std::length_error when empty) - Data& Back() override const; // Override LinearContainer member (must throw std::length_error when empty) + Data& Front() const override; // Override LinearContainer member (must throw std::length_error when empty) + Data& Back() const override; // Override LinearContainer member (must throw std::length_error when empty) Data& operator[](const ulong) const override; // Override LinearContainer member (must throw std::out_of_range when out of range) @@ -144,15 +148,15 @@ protected: // Auxiliary member functions (for MappableContainer) - void MapPreOrder(const MapFunctor, void*, struct Node*); // Accessory function executing from one point of the list onwards - void MapPostOrder(const MapFunctor, void*, struct Node*); // Accessory function executing from one point of the list onwards + void MapPreOrder(const MapFunctor, void* , struct Node*); // Accessory function executing from one point of the list onwards + void MapPostOrder(const MapFunctor, void* , struct Node*); // Accessory function executing from one point of the list onwards /* ************************************************************************ */ // Auxiliary member functions (for FoldableContainer) void FoldPreOrder(const FoldFunctor, const void*, void*, struct Node*) const; // Accessory function executing from one point of the list onwards - void FoldPostOrder(const FoldFunctor, const void*, void*, struct Node*) const; // Accessory function executing from one point of the list onwards + void FoldPostOrder(const FoldFunctor, const void*, void*, struct Node*) const;; // Accessory function executing from one point of the list onwards }; diff --git a/librerie/exercise1/main b/librerie/exercise1/main new file mode 100755 index 0000000..d4c3fa9 Binary files /dev/null and b/librerie/exercise1/main differ diff --git a/librerie/exercise1/main.cpp b/librerie/exercise1/main.cpp index 16c4875..40f1274 100644 --- a/librerie/exercise1/main.cpp +++ b/librerie/exercise1/main.cpp @@ -1,8 +1,10 @@ - -// #include "zlasdtest/test.hpp" -// -// #include "zmytest/test.hpp" #include "container/container.hpp" +#include "vector/vector.hpp" +#include "list/list.hpp" +#include "zlasdtest/test.hpp" + +#include "zmytest/test.hpp" + /* ************************************************************************** */ #include @@ -11,6 +13,7 @@ int main() { std::cout << "Lasd Libraries 2020" << std::endl; + menu(); //lasdtest(); // To call in the menu of your library test! return 0; } diff --git a/librerie/exercise1/vector/vector.cpp b/librerie/exercise1/vector/vector.cpp index 1c72e0a..2ebef36 100644 --- a/librerie/exercise1/vector/vector.cpp +++ b/librerie/exercise1/vector/vector.cpp @@ -1,180 +1,169 @@ + namespace lasd { - // Specific constructor - template typename - Vector::Vector(const ulong dimension){ - Elements = new Data[dimenion] {}; - size = dimenion; - } - // Specific constructor - template typename - Vector::Vector(const LinearContainer& con){ - size = con.Size(); - Elements = new Data[size] {}; - for(ulong i ; i +Vector::Vector(const ulong newsize){ + Elements = new Data[newsize]{}; + size = newsize; +} - // Copy constructor - template typename - Vector::Vector(const Vector& vec){ - size = vec.size; - Elements = new Data[size] {}; - for(ulong i=0 ; i +Vector::Vector(const LinearContainer& con){ + size = con.Size(); + Elements = new Data[size]{}; + for(ulong i=0; i - Vector::Vector(Vector&& vec) noexcept{ - std::swap(Elements, vec.Elements); - std::swap(size, vec.size); +// Copy constructor +template +Vector::Vector(const Vector& vec){ + size = vec.size; + Elements = new Data[size]{}; + for(ulong i=0; i +// Move constructor +template + Vector::Vector(Vector&& vec)noexcept{ + std::swap(Elements, vec.Elements); + std::swap(size, vec.size); + } + + // Destructor + template Vector::~Vector(){ - delete[] Elements; + Clear(); } // Copy assignment - template typename - Vector& Vector::operator=(const Vector& vec){ - Vector* tmpvec = new Vector(vec); - std::swap(*tmpvec,*this); - delete tmpvec; - return *this; - } + template + Vector& Vector::operator=(const Vector& vec){ + Vector* tmpvec = new Vector(vec); + std::swap(*tmpvec, *this); + delete tmpvec; + return *this; + } - // Move assignment - template typename - Vector& Vector::operator=(Vector&& vec) noexcept{ - std::swap(Elements, vec.Elements); - std::swap(size, vec.size); - return *this; - } + // Move assignment + template + Vector& Vector::operator=(Vector&& vec)noexcept{ + std::swap(Elements,vec.Elements); + std::swap(size, vec.size); + return *this; + } - // Comparison operators - template typename - bool Vector::operator==(const Vector& vec) const noexcept{ - if(size!=vec.size) return false; - for(ulong i=0 ; i + bool Vector::operator==(const Vector& vec) const noexcept{ + if(size == vec.size){ + for(ulong i=0; i + bool Vector::operator!=(const Vector& vec)const noexcept{ + return !(*this == vec); + } + + template + void Vector::Resize(const ulong newsize){ + if(newsize == 0){ + Clear(); + }else if(size != newsize) + { + ulong limit = (size < newsize) ? size : newsize; + Data* TmpElements = new Data[newsize]{}; + for(ulong i=0; i + void Vector::Clear(){ + delete[] Elements; + Elements = nullptr; + size = 0; + } + + template + Data& Vector::Front() const { + if(size != 0) + { + return Elements[0]; + }else{ + throw std::length_error("Access to an empty vector!"); + } + } + + template + Data& Vector::Back() const { + if(size != 0) + { + return Elements[size - 1]; + }else{ + throw std::length_error("Access to an empty vector!"); + } + } + + + template + Data& Vector::operator[](const ulong idx) const{ + if(idx < size) + { + return Elements[idx]; + } + else + { + throw std::out_of_range("Tried to access index " + std::to_string(idx) + " but the dimension of the vector is " + std::to_string(size)); } } - return true; - } - template typename - bool Vector::operator!=(const Vector& vec) const noexcept{ - return !(*this == vec); - } - // Specific member function - // template typename - // void Vector::Resize(const ulong newsize){ - // if(newsize == 0){ - // Clear(); - // } - // else{ - // size = newsize; - // if(newsize < size){ - // Data* tmpvec = new Data[newsize] {}; - // for(ulong i=0;i size){ - // Data* tmpvec = new Data[newsize] {}; - // for(ulong i=0;i - void Vector::Resize(const ulong newsize){ - if(newsize == 0){ - Clear(); - }else if(size != newsize){ - ulong limit = (size < newsize) ? size : newsize; - Data* TmpElements = new Data[newsize] {}; - for(ulong i = 0 ; i + void Vector::MapPreOrder(const MapFunctor fun, void* par){ + for(ulong i=0; i + void Vector::MapPostOrder(const MapFunctor fun, void* par){ + ulong idx = size; + while(idx > 0) + { + fun(Elements[--idx], par); + } + } + + + template + void Vector::FoldPreOrder(const FoldFunctor fun, const void* par, void* acc) const{ + for(ulong i=0; i + void Vector::FoldPostOrder(const FoldFunctor fun, const void* par, void* acc) const{ + ulong idx = size; + while(idx > 0){ + fun(Elements[--idx], par, acc); + } } } - -template typename -void Vector::Clear(){ - delete[] Elements; - Elements = nullptr; - size = 0; -} - -template typename -Data& Vector::Front() const{ - if(size!=0){ - return Elements[0]; - }else{ - return std::length_error("Access to an empty vector"); - } -} - -template typename -Data& Vector::Back() const{ - if(size!=0){ - return Elements[size-1]; - }else{ - return std::length_error("Access to an empty vector"); - } -} - -template typename -Data& Vector::operator[](const ulong index) const{ - if(index < size){ - return Elements[index]; - }else{ - throw std::out_of_range("Access at index " + std::to_string(index) + " invalid because the vector size is" + std::to_string(size)); - } -} - -template typename -void Vector::MapPreOrder(const MapFunctor fun, void* par){ - for(ulong i = 0 ; i -void Vector::MapPostOrder(const MapFunctor fun, void* par){ - ulong i = size; - while(i>0){ - fun(Elements[--i], par); - } -} - -template typename -void Vector::FoldPreOrder(const FoldFunctor fun, const void* par, void* acc) const{ - for(ulong i = 0 ; i -void Vector::FoldPostOrder(const FoldFunctor fun, const void* par, void* acc) const{ - ulong i = size; - while(i>0){ - fun(Elements[--i], par, acc); - } -} diff --git a/librerie/exercise1/vector/vector.hpp b/librerie/exercise1/vector/vector.hpp index 8fedf96..b5fcbe5 100644 --- a/librerie/exercise1/vector/vector.hpp +++ b/librerie/exercise1/vector/vector.hpp @@ -2,10 +2,16 @@ #ifndef VECTOR_HPP #define VECTOR_HPP +/* ************************************************************************** */ + #include "../container/container.hpp" +/* ************************************************************************** */ + namespace lasd { +/* ************************************************************************** */ + template class Vector : virtual public LinearContainer, virtual public MappableContainer, @@ -13,14 +19,20 @@ class Vector : virtual public LinearContainer, private: + protected: using LinearContainer::size; Data* Elements = nullptr; + + // ... + public: // Default constructor - Vector() = default; + // Vector() specifiers; + Vector() = default; + /* ************************************************************************ */ @@ -31,20 +43,20 @@ public: /* ************************************************************************ */ // Copy constructor - Vector(const Vector&); + Vector(const Vector&); // Move constructor - Vector(Vector&&) noexcept; + Vector(Vector&&)noexcept; /* ************************************************************************ */ // Destructor - ~Vector(); + ~Vector(); /* ************************************************************************ */ // Copy assignment - Vector& operator=(const Vector&); + Vector& operator=(const Vector&); // Move assignment Vector& operator=(Vector&&) noexcept; @@ -52,8 +64,8 @@ public: /* ************************************************************************ */ // Comparison operators - bool operator==(const Vector&&) const noexcept; - bool operator!=(const Vector&&) const noexcept; + bool operator==(const Vector&) const noexcept; + bool operator!=(const Vector&) const noexcept; /* ************************************************************************ */ @@ -80,20 +92,19 @@ public: // Specific member functions (inherited from MappableContainer) - using typename MappableContainer::MapFunctor; + using typename MappableContainer::MapFunctor; - void MapPreOrder(const MapFunctor, void*) override; // Override MappableContainer member - void MapPostOrder(const MapFunctor, void*) override; // Override MappableContainer member + void MapPreOrder(const MapFunctor, void*) override; // Override MappableContainer member + void MapPostOrder(const MapFunctor, void*) override; // Override MappableContainer member /* ************************************************************************ */ // Specific member functions (inherited from FoldableContainer) - using typename FoldableContainer::FoldFunctor; + using typename FoldableContainer::FoldFunctor; void FoldPreOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member void FoldPostOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member - }; /* ************************************************************************** */ diff --git a/librerie/exercise1/zmytest/test.cpp b/librerie/exercise1/zmytest/test.cpp index c3981ba..f7d28f3 100644 --- a/librerie/exercise1/zmytest/test.cpp +++ b/librerie/exercise1/zmytest/test.cpp @@ -1,3 +1,7 @@ +#include"test.hpp" +#include +#include + void menu(){ unsigned short int choice; DataStructure chosenDataStructure; @@ -11,7 +15,7 @@ void menu(){ switch(choice){ case 1: - lasdtest(); + //lasd::lasdtest(); break; case 2: chosenDataStructure = ChooseDataStructure(); @@ -23,10 +27,10 @@ void menu(){ } UseChosenType(chosenDataStructure,chosenDataType); } - DataStructure ChooseDataStructure(){ unsigned short int choice; do{ + std::cout<<"Choose a data structure:"<>std::ws; @@ -37,12 +41,12 @@ DataStructure ChooseDataStructure(){ else if(choice == 2) return DataStructure::list; } - DataType ChooseDataType(){ unsigned short int choice; do{ + std::cout<<"Choose a data type:"<>std::ws; std::cin>>choice; @@ -50,21 +54,553 @@ DataType ChooseDataType(){ if(choice==1) return DataType::integer; else if(choice==2) - return DataType::double; + return DataType::ffloat; else if(choice==3) - return DataType::string; + return DataType::sstring; } void UseChosenType(DataStructure chosenDataStructure, DataType chosenDataType){ - std::cout<<"\tTest on "; - if(chosenDataStructure == DataStructure::vector) - std::cout<<"vector of "; - else if(chosenDataStructure == DataStructure::list) - std::cout<<"list of "; - if(chosenDataType == DataType::integer) - std::cout<<" integers"< myvec; + myvec = generateVectorOfIntegers(); + VectorIntegerFunctions(myvec); + }else if(chosenDataType == DataType::ffloat){ + lasd::Vector myvec; + myvec = generateVectorOfFloat(); + VectorFloatFunctions(myvec); + }else if(chosenDataType == DataType::sstring){ + lasd::Vector myvec; + myvec = generateVectorOfStrings(); + VectorStringFunctions(myvec); + } + }else if(chosenDataStructure == DataStructure::list){ + if(chosenDataType == DataType::integer){ + lasd::List mylist; + mylist = generateListOfIntegers(); + ListIntegerFunctions(mylist); + }else if(chosenDataType == DataType::ffloat){ + lasd::List mylist; + mylist = generateListOfFloat(); + ListFloatFunctions(mylist); + }else if(chosenDataType == DataType::sstring){ + lasd::List mylist; + mylist = generateListOfStrings(); + ListStringFunctions(mylist); + } + } +} + +/* +********** VECTOR FUNCTIONS ********** +*/ +void VectorIntegerFunctions(lasd::Vector myvec){ + unsigned short int choice; + do{ + std::cout<<"Choose one of the following options:"<>std::ws; + std::cin>>choice; + + switch(choice){ + case 1: + ShowFirstElement(myvec); + break; + case 2: + ShowLastElement(myvec); + break; + case 3: + ShowElementWithASpecificIndex(myvec); + break; + case 4: + ShowAllElements(myvec); + break; + case 5: + CheckElementExists(myvec); + break; + case 6: + SumLessThan(myvec); + break; + case 7: + DoubleIntegers(myvec); + break; + } + }while(choice!=8); +} +void VectorFloatFunctions(lasd::Vector myvec){ + unsigned short int choice; + do{ + std::cout<<"Choose one of the following options:"<>std::ws; + std::cin>>choice; + switch(choice){ + case 1: + ShowFirstElement(myvec); + break; + case 2: + ShowLastElement(myvec); + break; + case 3: + ShowElementWithASpecificIndex(myvec); + break; + case 4: + ShowAllElements(myvec); + break; + case 5: + CheckElementExists(myvec); + break; + case 6: + ProductMoreThan(myvec); + break; + case 7: + SquareFloats(myvec); + break; + } + }while(choice!=8); +} +void VectorStringFunctions(lasd::Vector myvec){ + unsigned short int choice; + do{ + std::cout<<"Choose one of the following options:"<>std::ws; + std::cin>>choice; + switch(choice){ + case 1: + ShowFirstElement(myvec); + break; + case 2: + ShowLastElement(myvec); + break; + case 3: + ShowElementWithASpecificIndex(myvec); + break; + case 4: + ShowAllElements(myvec); + break; + case 5: + CheckElementExists(myvec); + break; + case 6: + ConcatLessThan(myvec); + break; + case 7: + Uppercase(myvec); + break; + } + }while(choice!=8); +} +template +void ShowFirstElement(lasd::Vector& vec){ + std::cout< +void ShowLastElement(lasd::Vector& vec){ + std::cout< +void ShowElementWithASpecificIndex(lasd::Vector& vec){ + ulong index; + std::cout<<"Insert the index: "; + std::cin>>std::ws; + std::cin>>index; + try{ + std::cout< +void ShowAllElements(lasd::Vector& vec){ + void (*AuxMapPreOrder) (Data&, void*) = PrintSingleElement; + std::cout<<"The vector contains:"< +void PrintSingleElement(Data& data, void* _){ + std::cout << data << " "; +} +template +void CheckElementExists(lasd::Vector& vec){ + Data element; + std::cout<<"What element do you wanna check its exsistence on? "; + std::cin>>std::ws; + std::cin>>element; + if(vec.Exists(element)) + std::cout<<"The element exists"<& vec){ + int pivot; + ulong acc=0; + void (*func)(const int&, const void*, void*) = AccumulateSum; + std::cout<<"Which element do you choose to performa a sum under it? "; + std::cin>>std::ws; + std::cin>>pivot; + vec.FoldPreOrder(func, (void*)&pivot, (void*)&acc); + std::cout<<"The result of the sum is "<& vec){ + void (*fun)(int&, void*) = DoubleAnInteger; + vec.MapPreOrder(fun, nullptr); + std::cout<<"The doubled elements of the vector are: "; + for (ulong i=0 ; i < vec.Size(); ++i){ + std::cout<& vec){ + float pivot, acc=1; + void (*func)(const float&, const void*, void*) = AccumulateProduct; + std::cout<<"Which element do you choose to performa a product above it? "; + std::cin>>std::ws; + std::cin>>pivot; + vec.FoldPreOrder(func, (void*)&pivot, (void*)&acc); + std::cout<<"The result of the product is "< (*(float*)par)){ + *(float*)acc *= data; + } +} +void SquareFloats(lasd::Vector& vec){ + void (*fun)(float&, void*) = SquareAFloat; + vec.MapPreOrder(fun, nullptr); + std::cout<<"The squared elements of the vector are: "; + for (ulong i=0 ; i < vec.Size(); ++i){ + std::cout<& vec){ + ulong pivot; + std::string acc = ""; + void (*func)(const std::string&, const void*, void*) = ConcatAux; + std::cout<<"Concat elements whose length is less than: "; + std::cin>>std::ws; + std::cin>>pivot; + vec.FoldPreOrder(func, (void*)&pivot, (void*)&acc); + std::cout<<"The concatenated string is "<& vec){ + void (*fun)(std::string&, void*) = UppercaseAString; + vec.MapPreOrder(fun, nullptr); + std::cout<<"The uppercased strings are: "< mylist){ + unsigned short int choice; + do{ + std::cout<<"Choose one of the following options:"<>std::ws; + std::cin>>choice; + + switch(choice){ + case 1: + ShowFirstElement(mylist); + break; + case 2: + ShowLastElement(mylist); + break; + case 3: + ShowElementWithASpecificIndex(mylist); + break; + case 4: + //ShowAllElements(mylist); + break; + case 5: + //CheckElementExists(mylist); + break; + case 6: + //SumLessThan(mylist); + break; + case 7: + //DoubleIntegers(mylist); + break; + } + }while(choice!=8); +} +void ListFloatFunctions(lasd::List mylist){ + unsigned short int choice; + do{ + std::cout<<"Choose one of the following options:"<>std::ws; + std::cin>>choice; + switch(choice){ + case 1: + ShowFirstElement(mylist); + break; + case 2: + ShowLastElement(mylist); + break; + case 3: + ShowElementWithASpecificIndex(mylist); + break; + case 4: + //ShowAllElements(myvec); + break; + case 5: + //CheckElementExists(myvec); + break; + case 6: + //ProductMoreThan(myvec); + break; + case 7: + //SquareFloats(myvec); + break; + } + }while(choice!=8); +} +void ListStringFunctions(lasd::List mylist){ + unsigned short int choice; + do{ + std::cout<<"Choose one of the following options:"<>std::ws; + std::cin>>choice; + switch(choice){ + case 1: + ShowFirstElement(mylist); + break; + case 2: + ShowLastElement(mylist); + break; + case 3: + ShowElementWithASpecificIndex(mylist); + break; + case 4: + //ShowAllElements(myvec); + break; + case 5: + // CheckElementExists(myvec); + break; + case 6: + //ConcatLessThan(myvec); + break; + case 7: + //Uppercase(myvec); + break; + } + }while(choice!=8); +} + +template +void ShowFirstElement(lasd::List& list){ + std::cout< +void ShowLastElement(lasd::List& list){ + std::cout< +void ShowElementWithASpecificIndex(lasd::List& list){ + ulong index; + std::cout<<"Insert the index: "; + std::cin>>std::ws; + std::cin>>index; + try{ + std::cout< generateListOfStrings(){ + ulong dim = getDimension(); + lasd::List mylist = lasd::List(); + + std::default_random_engine gen(std::random_device{}()); + std::uniform_int_distribution dist(1,5); + + for(unsigned long i = 0; i < dim; ++i){ + mylist.InsertAtFront(generateRandomString(dist(gen))); + } + std::cout<<"Elements of the list:"< generateListOfFloat(){ + ulong dim = getDimension(); + lasd::List mylist = lasd::List(); + + std::default_random_engine gen(std::random_device{}()); + std::uniform_real_distribution distr(0,5); + for(unsigned long i = 0; i < dim; ++i){ + mylist.InsertAtFront((round(distr(gen)*10000))/100); + } + std::cout<<"Elements of the list:"< generateListOfIntegers(){ + ulong dim = getDimension(); + lasd::List mylist = lasd::List(); + std::default_random_engine gen(std::random_device{}()); + std::uniform_int_distribution dist(0,1000); + for(ulong i=0 ; i generateVectorOfIntegers(){ + ulong dim = getDimension(); + lasd::Vector myvec = lasd::Vector(dim); + + std::default_random_engine gen(std::random_device{}()); + std::uniform_int_distribution dist(0,1000); + + for(ulong i = 0 ; i generateVectorOfFloat(){ + ulong dim = getDimension(); + lasd::Vector myvec = lasd::Vector(dim); + + std::default_random_engine gen(std::random_device{}()); + std::uniform_real_distribution distr(0,5); + for(unsigned long i = 0; i < dim; ++i){ + myvec[i] = (round(distr(gen)*10000))/100; + } + std::cout<<"Elements of the vector:"< generateVectorOfStrings(){ + ulong dim = getDimension(); + lasd::Vector myvec = lasd::Vector(dim); + + std::default_random_engine gen(std::random_device{}()); + std::uniform_int_distribution dist(1,5); + + for(unsigned long i = 0; i < dim; ++i){ + myvec[i] = generateRandomString(dist(gen)); + } + std::cout<<"Elements of the vector:"< character('a','z'); + char newString[dim+1]; + for(int i=0;i>dimension; + return dimension; } diff --git a/librerie/exercise1/zmytest/test.hpp b/librerie/exercise1/zmytest/test.hpp index bdd88c4..6cf26d7 100644 --- a/librerie/exercise1/zmytest/test.hpp +++ b/librerie/exercise1/zmytest/test.hpp @@ -1,12 +1,85 @@ #ifndef MYTEST_HPP #define MYTEST_HPP - +#include +#include"../vector/vector.hpp" +#include"../list/list.hpp" enum class DataStructure{vector,list}; -enum class DataType{integer,double,string}; +enum class DataType{integer,ffloat,sstring}; void menu(); -DataType ChooseDataType(); -void UseChosenType(DataStructure, DataType); +DataType ChooseDataType(); //choose data type DataStructure ChooseDataStructure(); +void UseChosenType(DataStructure, DataType); +lasd::Vector generateVectorOfIntegers(); +lasd::Vector generateVectorOfFloat(); +lasd::Vector generateVectorOfStrings(); +lasd::List generateListOfStrings(); +lasd::List generateListOfFloat(); +lasd::List generateListOfIntegers(); +std::string generateRandomString(ulong dim); + +void VectorIntegerFunctions(lasd::Vector); +void VectorFloatFunctions(lasd::Vector); +void VectorStringFunctions(lasd::Vector); +template +void ShowFirstElement(lasd::Vector&); +template +void ShowLastElement(lasd::Vector&); +template +void ShowElementWithASpecificIndex(lasd::Vector&); +template +void ShowAllElements(lasd::Vector&); +template +void PrintSingleElement(Data&, void*); +template +void CheckElementExists(lasd::Vector&); +void SumLessThan(lasd::Vector&); +void AccumulateSum(const int&, const void*, void*); +void DoubleIntegers(lasd::Vector&); +void DoubleAnInteger(int&, void*); +void AccumulateProduct(const float&, const void*, void*); +void ProductMoreThan(lasd::Vector&); +void SquareAFloat(float&, void*); +void SquareFloats(lasd::Vector&); +void ConcatLessThan(lasd::Vector&); +void ConcatAux(const std::string&, const void*, void*); +void Uppercase(lasd::Vector&); +void UppercaseAString(std::string&, void*); +void ListIntegerFunctions(lasd::List); +void ListFloatFunctions(lasd::List); +void ListStringFunctions(lasd::List); +template +void ShowFirstElement(lasd::List&); +template +void ShowLastElement(lasd::List&); +template +void ShowElementWithASpecificIndex(lasd::List&); +ulong getDimension(); +/* +void ChooseDimension(ulong&); +LinearContainer GenerateRandomStructure(const ulong&); +void ViewElement(const LinearContainer&); +void PrintAllElements(const LinearContainer&); +void PrintElement(Data&, void*); // funzione richiamata dalla map +void CheckExists(const LinearContainer&); +void ChooseFoldFunction(const LinearContainer&); +void SumLessThan(const LinearContainer&, const ulong&); +void SumLessThanFold(int&, const void*, void*); +void ProductMoreThan(const LinearContainer&, const ulong&); +void ProductMoreThanFold(float&, const void*, void*); +void ConcatStringLessThan(const LinearContainer&, const ulong&); +void ConcatStringLessThanFold(string&, const void*, void*); + +//7 +void ChooseMapFunction(const LinearContainer); +void DoubleN(const LinearContainer&, const ulong&); +void DoubleNMap(int&, void*); + +void SquareN(const LinearContainer&, const ulong&); +void SquareNMap(float&, void*); + +void Uppercase(const LinearContainer&, const ulong&); +void UppercaseMap(string&, void*); +*/ #endif diff --git a/librerie/exercise1/Exercise1.pdf b/librerie/exercise1old/Exercise1.pdf similarity index 100% rename from librerie/exercise1/Exercise1.pdf rename to librerie/exercise1old/Exercise1.pdf diff --git a/librerie/exercise1old/build.sh b/librerie/exercise1old/build.sh new file mode 100755 index 0000000..bbee40e --- /dev/null +++ b/librerie/exercise1old/build.sh @@ -0,0 +1,7 @@ + +#! /bin/bash + +g++ -O3 -o main \ + zlasdtest/exercise1/simpletest.cpp zlasdtest/exercise1/fulltest.cpp \ + zlasdtest/container/container.cpp \ + zlasdtest/test.cpp zmytest/test.cpp main.cpp diff --git a/librerie/exercise1old/container/container.cpp b/librerie/exercise1old/container/container.cpp new file mode 100644 index 0000000..6a22d84 --- /dev/null +++ b/librerie/exercise1old/container/container.cpp @@ -0,0 +1,17 @@ + +namespace lasd { + +template +void AuxFoldExists(const Data& dat, const void* val, void* exists){ + if(dat == *((Data*)val)){ + *((bool*)exists) = true; + } +} + +template +bool FoldableContainer::Exists(const Data& dat) const noexcept{ + bool exists = false; + FoldPreOrder(&AuxFoldExists, &dat, &exists); + return exists; +} +} diff --git a/librerie/exercise1old/container/container.hpp b/librerie/exercise1old/container/container.hpp new file mode 100644 index 0000000..021fcc0 --- /dev/null +++ b/librerie/exercise1old/container/container.hpp @@ -0,0 +1,304 @@ + +#ifndef CONTAINER_HPP +#define CONTAINER_HPP + +/* ************************************************************************** */ + +#include +#include + +/* ************************************************************************** */ + +namespace lasd { + +/* ************************************************************************** */ + +class Container { + +private: + +protected: + + ulong size = 0; + +public: + + // Destructor + virtual ~Container() = default; + + /* ************************************************************************ */ + + // Copy assignment + Container& operator=(const Container&) = delete; // Copy assignment of abstract types should not be possible. + + // Move assignment + Container& operator=(Container&&) noexcept = delete; // Move assignment of abstract types should not be possible. + + /* ************************************************************************ */ + + // Comparison operators + bool operator==(const Container&) const noexcept = delete; // Comparison of abstract types might not be possible. + bool operator!=(const Container&) const noexcept = delete; // Comparison of abstract types might not be possible. + + /* ************************************************************************ */ + + // Specific member functions + + virtual bool Empty() const noexcept { // (concrete function should not throw exceptions) + return (size == 0); + } + + virtual ulong Size() const noexcept{ + return size; + } + + virtual void Clear() = 0; + +}; + +/* ************************************************************************** */ + +template +class LinearContainer : virtual public Container { // Must extend Container + +private: + +protected: + +public: + + // Destructor + virtual ~LinearContainer() = default; + + /* ************************************************************************ */ + + // Copy assignment + LinearContainer& operator=(const LinearContainer&) = delete; // Copy assignment of abstract types should not be possible. + + // Move assignment + LinearContainer& operator=(LinearContainer&&) = delete; // Move assignment of abstract types should not be possible. + + /* ************************************************************************ */ + + // Comparison operators + bool operator==(const LinearContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. + bool operator!=(const LinearContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. + + /* ************************************************************************ */ + + // Specific member functions + + virtual Data& Front() const = 0; // (concrete function must throw std::length_error when empty) + virtual Data& Back() const = 0; // (concrete function must throw std::length_error when empty) + + virtual Data& operator[](const ulong) const = 0; // (concrete function must throw std::out_of_range when out of range) + +}; + +/* ************************************************************************** */ + +template +class TestableContainer : virtual public Container { // Must extend Container + +private: + +protected: + +public: + + // Destructor + virtual ~TestableContainer() = default; + + /* ************************************************************************ */ + + // Copy assignment + TestableContainer& operator=(const TestableContainer&) = delete; // Copy assignment of abstract types should not be possible. + + // Move assignment + TestableContainer& operator=(TestableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. + + /* ************************************************************************ */ + + // Comparison operators + bool operator==(const TestableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. + bool operator!=(const TestableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. + + /* ************************************************************************ */ + + // Specific member functions + + virtual bool Exists(const Data&) const noexcept = 0; // (concrete function should not throw exceptions) + +}; + +/* ************************************************************************** */ + +template +class MappableContainer : virtual public Container { // Must extend Container + +private: + +protected: + +public: + + // Destructor + virtual ~MappableContainer() = default; + + /* ************************************************************************ */ + + // Copy assignment + MappableContainer& operator=(const MappableContainer&) = delete; // Copy assignment of abstract types should not be possible. + + // Move assignment + MappableContainer& operator=(MappableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. + + /* ************************************************************************ */ + + // Comparison operators + bool operator==(const MappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. + bool operator!=(const MappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. + + /* ************************************************************************ */ + + // Specific member functions + + typedef std::function MapFunctor; + + virtual void MapPreOrder(const MapFunctor, void*) = 0; + virtual void MapPostOrder(const MapFunctor, void*) = 0; + +}; + +/* ************************************************************************** */ + +template +class FoldableContainer : virtual public TestableContainer{ // Must extend TestableContainer + +private: + +protected: + +public: + + // Destructor + virtual ~FoldableContainer() = default; + + /* ************************************************************************ */ + + // Copy assignment + FoldableContainer& operator=(const FoldableContainer&) = delete; // Copy assignment of abstract types should not be possible. + + // Move assignment + FoldableContainer& operator=(FoldableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. + + /* ************************************************************************ */ + + // Comparison operators + bool operator==(const FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. + bool operator!=(const FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. + + /* ************************************************************************ */ + + // Specific member functions + + typedef std::function FoldFunctor; + + virtual void FoldPreOrder(const FoldFunctor, const void*, void*) const = 0; + virtual void FoldPostOrder(const FoldFunctor, const void*, void*) const = 0; + + virtual bool Exists(const Data&) const noexcept override; // Override TestableContainer member + +}; + +/* ************************************************************************** */ + +template +class BreadthMappableContainer { // Must extend MappableContainer + +private: + + // ... + +protected: + + // ... + +public: + + // Destructor + // ~BreadthMappableContainer() specifiers + + /* ************************************************************************ */ + + // Copy assignment + // type operator=(argument); // Copy assignment of abstract types should not be possible. + + // Move assignment + // type operator=(argument); // Move assignment of abstract types should not be possible. + + /* ************************************************************************ */ + + // Comparison operators + // type operator==(argument) specifiers; // Comparison of abstract types might not be possible. + // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible. + + /* ************************************************************************ */ + + // Specific member functions + + // using typename MappableContainer::MapFunctor; + + // type MapBreadth(arguments) specifiers; + +}; + +/* ************************************************************************** */ + +template +class BreadthFoldableContainer { // Must extend FoldableContainer + +private: + + // ... + +protected: + + // ... + +public: + + // Destructor + // ~BreadthFoldableContainer() specifiers + + /* ************************************************************************ */ + + // Copy assignment + // type operator=(argument); // Copy assignment of abstract types should not be possible. + + // Move assignment + // type operator=(argument); // Move assignment of abstract types should not be possible. + + /* ************************************************************************ */ + + // Comparison operators + // type operator==(argument) specifiers; // Comparison of abstract types might not be possible. + // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible. + + /* ************************************************************************ */ + + // Specific member functions + + // using typename FoldableContainer::FoldFunctor; + + // type FoldBreadth(arguments) specifiers; + +}; + +/* ************************************************************************** */ + +} + +#include "container.cpp" + +#endif diff --git a/librerie/exercise1old/list/list.cpp b/librerie/exercise1old/list/list.cpp new file mode 100644 index 0000000..ce55016 --- /dev/null +++ b/librerie/exercise1old/list/list.cpp @@ -0,0 +1,264 @@ +namespace lasd { + // Specific constructor + template + List::Node::Node(Data newValue){ + value = newValue; + next = nullptr; + } + + // Copy constructor + template + List::Node::Node(const Node& copyFrom){ + value = copyFrom.value; + } + + // Move constructor + template + List::Node::Node(Node&& moveFrom){ + std::move(value, moveFrom.value); + std::move(next, moveFrom.next); + } + template + List::Node::Node(Data&& moveFrom){ + std::move(value, moveFrom); + } + + // Comparison operator + template + bool List::Node::operator==(const Node& node) const noexcept{ + if(node.value == value) return true; + else return false; + } + + template + bool List::Node::operator!=(const Node& node) const noexcept{ + if(node.value != value) return true; + else return false; + } + + template + List::List(const LinearContainer& con){ + for(ulong i=0 ; i + List::List(const List& copyFrom){ + for(ulong i=0 ; i + List::List(List&& moveFrom){ + std::swap(size, moveFrom.size); + std::swap(head, moveFrom.head); + std::swap(tail, moveFrom.tail); + } + + // Destructor + template + List::~List(){ + Clear(); + } + + // Copy assignment + template + List& List::operator=(const List& copyFrom){ + if(*this != copyFrom){ + Clear(); + for(ulong i=0 ; i + List& List::operator=(List&& moveFrom) noexcept{ + if(*this != moveFrom){ + Clear(); + std::swap(size, moveFrom.size); + std::swap(head, moveFrom.head); + std::swap(tail, moveFrom.tail); + } + return *this; + } + + // Comparison operators + template + bool List::operator==(const List& list) const noexcept{ + if(this->size != list.Size()) return false; + for(ulong i=0 ; i<(this->size) ; ++i){ + if((*this)[i] != list[i]) return false; + } + return true; + } + + template + bool List::operator!=(const List& list) const noexcept{ + return !(*this == list); + } + + // Specific member functions + template + void List::InsertAtFront(const Data& data){ + struct Node* tmp = new Node(data); + tmp->next = head; + head = tmp; + size++; + if(size==1){ + tail = head; + } + } + + template + void List::InsertAtFront(Data&& data){ + struct Node* tmp = new Node(data); + tmp->next = head; + head = tmp; + size++; + if(size==1){ + tail = head; + } + } + + template + void List::RemoveFromFront(){ + if(head==nullptr){ + throw std::length_error("List is empty!"); + }else{ + struct Node* tmp = head; + head = head->next; + delete tmp; + size--; + } + } + + template + Data List::FrontNRemove(){ + if(head==nullptr){ + throw std::length_error("List is empty!"); + }else{ + Data value = head->value; + RemoveFromFront(); + return value; + } + } + + template + void List::InsertAtBack(const Data& data){ + if(size==0){ + InsertAtFront(data); + }else{ + struct Node* last = new Node(data); + tail->next = last; + tail = last; + size++; + } + } + + template + void List::InsertAtBack(Data&& data){ + if(size==0){ + InsertAtFront(data); + }else{ + struct Node* last = new Node(data); + tail->next = last; + tail = last; + size++; + } + } + + template + void List::Clear(){ + while(head!=nullptr){ + RemoveFromFront(); + } + } + + template + Data& List::Front() const{ + if(size==0){ + throw std::length_error("List is empty!"); + }else{ + return head->value; + } + } + + template + Data& List::Back() const{ + if(size==0){ + throw std::length_error("List is empty!"); + }else{ + return tail->value; + } + } + + template + Data& List::operator[](const ulong index) const{ + if(index>=size || index<0){ + throw std::out_of_range("Out of range!"); + }else{ + struct Node* tmp = head; + for(ulong i=0 ; inext; + } + return tmp->value; + } + } + + template + void List::MapPreOrder(const MapFunctor fun, void* par){ + MapPreOrder(fun, par, head); + } + + template + void List::MapPreOrder(MapFunctor function, void* par, struct Node* node){ + if(node == nullptr) + return; + function(node->value, par); + MapPreOrder(function, par, node->next); + } + + template + void List::MapPostOrder(MapFunctor function, void* par){ + MapPostOrder(function, par, head); + } + + template + void List::MapPostOrder(MapFunctor function, void* par, struct Node* node){ + if(node == nullptr) + return; + MapPostOrder(function, par, node->next); + function(node->value, par); + } + + template + void List::FoldPreOrder(FoldFunctor function, const void* constPar, void* par) const{ + FoldPreOrder(function, constPar, par, head); + } + + template + void List::FoldPreOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{ + if(node == nullptr) + return; + function(node->value, constPar, par); + FoldPreOrder(function, constPar, par, node->next); + } + + template + void List::FoldPostOrder(FoldFunctor function, const void* constPar, void* par) const{ + FoldPostOrder(function, constPar, par, head); +} + + template + void List::FoldPostOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{ + if(node == nullptr) + return; + FoldPostOrder(function, constPar, par, node->next); + function(node->value, constPar, par); + } +} diff --git a/librerie/exercise1old/list/list.hpp b/librerie/exercise1old/list/list.hpp new file mode 100644 index 0000000..99bf595 --- /dev/null +++ b/librerie/exercise1old/list/list.hpp @@ -0,0 +1,164 @@ + +#ifndef LIST_HPP +#define LIST_HPP + +/* ************************************************************************** */ + +#include "../container/container.hpp" + +/* ************************************************************************** */ + +namespace lasd { + +/* ************************************************************************** */ + +template +class List : virtual public LinearContainer, + virtual public MappableContainer, + virtual public FoldableContainer { // Must extend LinearContainer, MappableContainer, and FoldableContainer + +private: + +protected: + + using LinearContainer:: size; + + struct Node + { + Data value; + Node* next = nullptr; + + /* ********************************************************************** */ + + // Specific constructors + Node(Data); + + /* ********************************************************************** */ + + // Copy constructor + Node(const Node&); + + // Move constructor + Node(Node&&); + Node(Data&&); + + /* ********************************************************************** */ + + // Destructor + ~Node() = default; + + /* ********************************************************************** */ + + // Comparison operators + bool operator==(const Node&) const noexcept; + bool operator!=(const Node&) const noexcept; + }; + + struct Node* head = nullptr; + struct Node* tail = nullptr; + +public: + + // Default constructor + List() = default; + + /* ************************************************************************ */ + + // Specific constructor + List(const LinearContainer&); // A list obtained from a LinearContainer + + /* ************************************************************************ */ + + // Copy constructor + List(const List&); + + //Move constructor + List(List&&); + + /* ************************************************************************ */ + + // Destructor + ~List(); + + /* ************************************************************************ */ + + // Copy assignment + List& operator=(const List&); + + // Move assignment + List& operator=(List&&) noexcept; + + /* ************************************************************************ */ + + // Comparison operators + bool operator==(const List&) const noexcept; + bool operator!=(const List&) const noexcept; + + /* ************************************************************************ */ + + // Specific member functions + + void InsertAtFront(const Data&); // Copy of the value + void InsertAtFront(Data&&); // Move of the value + void RemoveFromFront(); // (must throw std::length_error when empty) + Data FrontNRemove(); // (must throw std::length_error when empty) + + void InsertAtBack(const Data&); // Copy of the value + void InsertAtBack(Data&&); // Move of the value + + /* ************************************************************************ */ + + // Specific member functions (inherited from Container) + + void Clear() override; // Override Container member + + /* ************************************************************************ */ + + // Specific member functions (inherited from LinearContainer) + + Data& Front() const override; // Override LinearContainer member (must throw std::length_error when empty) + Data& Back() const override; // Override LinearContainer member (must throw std::length_error when empty) + + Data& operator[](const ulong) const override; // Override LinearContainer member (must throw std::out_of_range when out of range) + + /* ************************************************************************ */ + + // Specific member functions (inherited from MappableContainer) + + using typename MappableContainer::MapFunctor; + + void MapPreOrder(const MapFunctor, void*) override; // Override MappableContainer member + void MapPostOrder(const MapFunctor, void*) override; // Override MappableContainer member + + /* ************************************************************************ */ + + // Specific member functions (inherited from FoldableContainer) + + using typename FoldableContainer::FoldFunctor; + + void FoldPreOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member + void FoldPostOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member + +protected: + + // Auxiliary member functions (for MappableContainer) + + void MapPreOrder(const MapFunctor, void*, struct Node*); // Accessory function executing from one point of the list onwards + void MapPostOrder(const MapFunctor, void*, struct Node*); // Accessory function executing from one point of the list onwards + + /* ************************************************************************ */ + + // Auxiliary member functions (for FoldableContainer) + + void FoldPreOrder(const FoldFunctor, const void*, void*, struct Node*) const; // Accessory function executing from one point of the list onwards + void FoldPostOrder(const FoldFunctor, const void*, void*, struct Node*) const; // Accessory function executing from one point of the list onwards + +}; + +/* ************************************************************************** */ + +} + +#include "list.cpp" + +#endif diff --git a/librerie/exercise1old/main.cpp b/librerie/exercise1old/main.cpp new file mode 100644 index 0000000..9c587bb --- /dev/null +++ b/librerie/exercise1old/main.cpp @@ -0,0 +1,18 @@ +#include "container/container.hpp" +#include "vector/vector.hpp" +#include "list/list.hpp" +#include "zlasdtest/test.hpp" + +#include "zmytest/test.hpp" + +/* ************************************************************************** */ + +#include + +/* ************************************************************************** */ + +int main() { + std::cout << "Lasd Libraries 2020" << std::endl; + lasdtest(); // To call in the menu of your library test! + return 0; +} diff --git a/librerie/exercise1old/vector/vector.cpp b/librerie/exercise1old/vector/vector.cpp new file mode 100644 index 0000000..7b7d8ef --- /dev/null +++ b/librerie/exercise1old/vector/vector.cpp @@ -0,0 +1,181 @@ +namespace lasd { + + // Specific constructor + template + Vector::Vector(const ulong dimension){ + Elements = new Data[dimension] {}; + size = dimension; + } + + // Specific constructor + template + Vector::Vector(const LinearContainer& con){ + size = con.Size(); + Elements = new Data[size] {}; + for(ulong i ; i + Vector::Vector(const Vector& vec){ + size = vec.size; + Elements = new Data[size] {}; + for(ulong i=0 ; i + Vector::Vector(Vector&& vec) noexcept{ + std::swap(Elements, vec.Elements); + std::swap(size, vec.size); + } + + // Destructor + template + Vector::~Vector(){ + delete[] Elements; + } + + // Copy assignment + template + Vector& Vector::operator=(const Vector& vec){ + Vector* tmpvec = new Vector(vec); + std::swap(*tmpvec,*this); + delete tmpvec; + return *this; + } + + // Move assignment + template + Vector& Vector::operator=(Vector&& vec) noexcept{ + std::swap(Elements, vec.Elements); + std::swap(size, vec.size); + return *this; + } + + // Comparison operators + template + bool Vector::operator==(const Vector& vec) const noexcept{ + if(size!=vec.size) return false; + for(ulong i=0 ; i + bool Vector::operator!=(const Vector& vec) const noexcept{ + return !(*this == vec); + } + + // Specific member function + // template typename + // void Vector::Resize(const ulong newsize){ + // if(newsize == 0){ + // Clear(); + // } + // else{ + // size = newsize; + // if(newsize < size){ + // Data* tmpvec = new Data[newsize] {}; + // for(ulong i=0;i size){ + // Data* tmpvec = new Data[newsize] {}; + // for(ulong i=0;i + void Vector::Resize(const ulong newsize){ + if(newsize == 0){ + Clear(); + }else if(size != newsize){ + ulong limit = (size < newsize) ? size : newsize; + Data* TmpElements = new Data[newsize] {}; + for(ulong i = 0 ; i + void Vector::Clear(){ + delete[] Elements; + Elements = nullptr; + size = 0; + } + + template + Data& Vector::Front() const{ + if(size!=0){ + return Elements[0]; + }else{ + return std::length_error("Access to an empty vector"); + } + } + + template + Data& Vector::Back() const{ + if(size!=0){ + return Elements[size-1]; + }else{ + return std::length_error("Access to an empty vector"); + } + } + + template + Data& Vector::operator[](const ulong index) const{ + if(index < size){ + return Elements[index]; + }else{ + throw std::out_of_range("Access at index " + std::to_string(index) + " invalid because the vector size is" + std::to_string(size)); + } + } + + template + void Vector::MapPreOrder(const MapFunctor fun, void* par){ + for(ulong i = 0 ; i + void Vector::MapPostOrder(const MapFunctor fun, void* par){ + ulong i = size; + while(i>0){ + fun(Elements[--i], par); + } + } + + template + void Vector::FoldPreOrder(const FoldFunctor fun, const void* par, void* acc) const{ + for(ulong i = 0 ; i + void Vector::FoldPostOrder(const FoldFunctor fun, const void* par, void* acc) const{ + ulong i = size; + while(i>0){ + fun(Elements[--i], par, acc); + } + } diff --git a/librerie/exercise1old/vector/vector.hpp b/librerie/exercise1old/vector/vector.hpp new file mode 100644 index 0000000..3c25b30 --- /dev/null +++ b/librerie/exercise1old/vector/vector.hpp @@ -0,0 +1,105 @@ + +#ifndef VECTOR_HPP +#define VECTOR_HPP + +#include "../container/container.hpp" + +namespace lasd { + +template +class Vector : virtual public LinearContainer, + virtual public MappableContainer, + virtual public FoldableContainer{ // Must extend LinearContainer, MappableContainer, and FoldableContainer + +private: + +protected: + + using LinearContainer::size; + Data* Elements = nullptr; +public: + + // Default constructor + Vector() = default; + + /* ************************************************************************ */ + + // Specific constructors + Vector(const ulong); // A vector with a given initial dimension + Vector(const LinearContainer&); // A vector obtained from a LinearContainer + + /* ************************************************************************ */ + + // Copy constructor + Vector(const Vector&); + + // Move constructor + Vector(Vector&&) noexcept; + + /* ************************************************************************ */ + + // Destructor + ~Vector(); + + /* ************************************************************************ */ + + // Copy assignment + Vector& operator=(const Vector&); + + // Move assignment + Vector& operator=(Vector&&) noexcept; + + /* ************************************************************************ */ + + // Comparison operators + bool operator==(const Vector&) const noexcept; + bool operator!=(const Vector&) const noexcept; + + /* ************************************************************************ */ + + // Specific member functions + + void Resize(const ulong); // Resize the vector to a given size + + /* ************************************************************************ */ + + // Specific member functions (inherited from Container) + + void Clear() override; // Override Container member + + /* ************************************************************************ */ + + // Specific member functions (inherited from LinearContainer) + + Data& Front() const override; // Override LinearContainer member (must throw std::length_error when empty) + Data& Back() const override; // Override LinearContainer member (must throw std::length_error when empty) + + Data& operator[](const ulong) const override; // Override LinearContainer member (must throw std::out_of_range when out of range) + + /* ************************************************************************ */ + + // Specific member functions (inherited from MappableContainer) + + using typename MappableContainer::MapFunctor; + + void MapPreOrder(const MapFunctor, void*) override; // Override MappableContainer member + void MapPostOrder(const MapFunctor, void*) override; // Override MappableContainer member + + /* ************************************************************************ */ + + // Specific member functions (inherited from FoldableContainer) + + using typename FoldableContainer::FoldFunctor; + + void FoldPreOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member + void FoldPostOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member + +}; + +/* ************************************************************************** */ + +} + +#include "vector.cpp" + +#endif diff --git a/librerie/exercise1old/zlasdtest/container/container.cpp b/librerie/exercise1old/zlasdtest/container/container.cpp new file mode 100644 index 0000000..0f37c81 --- /dev/null +++ b/librerie/exercise1old/zlasdtest/container/container.cpp @@ -0,0 +1,49 @@ + +#include + +/* ************************************************************************** */ + +#include "../../container/container.hpp" + +/* ************************************************************************** */ + +// Container member functions! + +void Empty(uint& testnum, uint& testerr, const lasd::Container& con, bool chk) { + bool tst; + testnum++; + std::cout << " " << testnum << " The container is " << ((tst = con.Empty()) ? "" : "not ") << "empty: "; + std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; + testerr += (1 - (uint) tst); +} + +void Size(uint& testnum, uint& testerr, const lasd::Container& con, bool chk, ulong siz) { + bool tst; + testnum++; + std::cout << " " << testnum << " The container has size " << con.Size() << ": "; + std::cout << ((tst = ((con.Size() == siz) == chk)) ? "Correct" : "Error") << "!" << std::endl; + testerr += (1 - (uint) tst); +} + +/* ************************************************************************** */ + +// Auxiliary functions for MappableContainer! + +void MapStringAppend(std::string& dat, void* par) { + dat.append(*((std::string*) par)); +} + +/* ************************************************************************** */ + +// Auxiliary functions for FoldableContainer! + +void FoldParity(const int& dat, const void* _, void* acc) { + *((int*) acc) += dat; + *((int*) acc) %= 2; +} + +void FoldStringConcatenate(const std::string& dat, const void* _, void* acc) { + ((std::string*) acc)->append(dat); +} + +/* ************************************************************************** */ diff --git a/librerie/exercise1old/zlasdtest/container/container.hpp b/librerie/exercise1old/zlasdtest/container/container.hpp new file mode 100644 index 0000000..7b12b44 --- /dev/null +++ b/librerie/exercise1old/zlasdtest/container/container.hpp @@ -0,0 +1,301 @@ + +#ifndef CONTAINERTEST_HPP +#define CONTAINERTEST_HPP + +#include "../../container/container.hpp" + +/* ************************************************************************** */ + +// Container member functions! + +void Empty(uint&, uint&, const lasd::Container&, bool); + +void Size(uint&, uint&, const lasd::Container&, bool, ulong); + +/* ************************************************************************** */ + +// LinearContainer member functions! + +template +void GetFront(uint& testnum, uint& testerr, const lasd::LinearContainer& con, bool chk, const Data& val) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " The front of the linear container is \"" << con.Front() << "\": "; + std::cout << ((tst = ((con.Front() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::length_error exc) { + std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + tst = true; + std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void SetFront(uint& testnum, uint& testerr, const lasd::LinearContainer& con, bool chk, const Data& val) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " Setting the front of the linear container to \"" << val << "\": "; + con.Front() = val; + std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::length_error exc) { + std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + tst = true; + std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void GetBack(uint& testnum, uint& testerr, const lasd::LinearContainer& con, bool chk, const Data& val) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " The back of the linear container is \"" << con.Back() << "\": "; + std::cout << ((tst = ((con.Back() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::length_error exc) { + std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + tst = true; + std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void SetBack(uint& testnum, uint& testerr, const lasd::LinearContainer& con, bool chk, const Data& val) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " Setting the back of the linear container to \"" << val << "\": "; + con.Back() = val; + std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::length_error exc) { + std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + tst = true; + std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void SetAt(uint& testnum, uint& testerr, lasd::LinearContainer& con, bool chk, const ulong& ind, const Data& val) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " Set of the linear container at index \"" << ind << "\" with value \"" << val << "\": "; + con[ind] = val; + std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::out_of_range exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + tst = true; + std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void GetAt(uint& testnum, uint& testerr, lasd::LinearContainer& con, bool chk, const ulong& ind, const Data& val) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " Get of the linear container at index \"" << ind << "\" with value \"" << con[ind] << "\": "; + std::cout << ((tst = ((con[ind] == val) == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::out_of_range exc) { + std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + tst = true; + std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +/* ************************************************************************** */ + +// TestableContainer member functions! + +template +void Exists(uint& testnum, uint& testerr, const lasd::TestableContainer& con, bool chk, const Data& val) { + bool tst; + testnum++; + std::cout << " " << testnum << " Data \"" << val << "\" " << ((tst = con.Exists(val)) ? "does" : "does not") << " exist: "; + std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; + testerr += (1 - (uint) tst); +} + +/* ************************************************************************** */ + +// MappableContainer member functions! + +template +void MapPreOrder(uint& testnum, uint& testerr, lasd::MappableContainer& con, bool chk, typename lasd::MappableContainer::MapFunctor fun, const Parameter& inipar) { + bool tst = true; + testnum++; + Parameter par = {inipar}; + try { + std::cout << " " << testnum << " Executing map in pre order - "; + con.MapPreOrder(fun, &par); + std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void MapPostOrder(uint& testnum, uint& testerr, lasd::MappableContainer& con, bool chk, typename lasd::MappableContainer::MapFunctor fun, const Parameter& inipar) { + bool tst = true; + testnum++; + Parameter par = {inipar}; + try { + std::cout << " " << testnum << " Executing map in post order - "; + con.MapPostOrder(fun, &par); + std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void MapPrint(const Data& dat, void* _) { + std::cout << dat << " "; +} + +template +void MapIncrement(Data& dat, void* _) { + dat++; +} + +template +void MapIncrementNPrint(Data& dat, void* _) { + std::cout << dat++ << "->" << dat << "; "; +} + +template +void MapDouble(Data& dat, void* _) { + dat *= 2; +} + +template +void MapDoubleNPrint(Data& dat, void* _) { + std::cout << dat << "->" << (dat *= 2) << "; "; +} + +template +void MapInvert(Data& dat, void* _) { + dat = -dat; +} + +template +void MapInvertNPrint(Data& dat, void* _) { + std::cout << dat << "->" << (dat = -dat) << "; "; +} + +template +void MapParityInvert(Data& dat, void* _) { + if (dat % 2 != 0) { dat = -dat; } +} + +void MapStringAppend(std::string&, void*); + +/* ************************************************************************** */ + +// FoldableContainer member functions! + +template +void FoldPreOrder(uint& testnum, uint& testerr, const lasd::FoldableContainer& con, bool chk, typename lasd::FoldableContainer::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) { + bool tst; + testnum++; + Parameter par = {inipar}; + Value val = inival; + try { + std::cout << " " << testnum << " Executing fold in pre order - "; + con.FoldPreOrder(fun, &par, &val); + std::cout << "obtained value is \"" << val << "\": "; + std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void FoldPostOrder(uint& testnum, uint& testerr, const lasd::FoldableContainer& con, bool chk, typename lasd::FoldableContainer::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) { + bool tst; + testnum++; + Parameter par = {inipar}; + Value val = inival; + try { + std::cout << " " << testnum << " Executing fold in post order - "; + con.FoldPostOrder(fun, &par, &val); + std::cout << "obtained value is \"" << val << "\": "; + std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void FoldAdd(const Data& dat, const void* _, void* acc) { + *((Data*) acc) += dat; +} + +template +void FoldMultiply(const Data& dat, const void* _, void* acc) { + *((Data*) acc) *= dat; +} + +void FoldParity(const int&, const void*, void*); + +void FoldStringConcatenate(const std::string&, const void*, void*); + +/* ************************************************************************** */ + +// BreadthMappableContainer member functions! + +template +void MapBreadth(uint& testnum, uint& testerr, lasd::BreadthMappableContainer& con, bool chk, typename lasd::BreadthMappableContainer::MapFunctor fun, const Parameter& inipar) { + bool tst = true; + testnum++; + Parameter par = {inipar}; + try { + std::cout << " " << testnum << " Executing map in pre order - "; + con.MapBreadth(fun, &par); + std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +/* ************************************************************************** */ + +// BreadthFoldableContainer member functions! + +template +void FoldBreadth(uint& testnum, uint& testerr, const lasd::BreadthFoldableContainer& con, bool chk, typename lasd::BreadthFoldableContainer::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) { + bool tst; + testnum++; + Parameter par = {inipar}; + Value val = inival; + try { + std::cout << " " << testnum << " Executing fold in post order - "; + con.FoldBreadth(fun, &par, &val); + std::cout << "obtained value is \"" << val << "\": "; + std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +/* ************************************************************************** */ + +#endif diff --git a/librerie/exercise1old/zlasdtest/exercise1/fulltest.cpp b/librerie/exercise1old/zlasdtest/exercise1/fulltest.cpp new file mode 100644 index 0000000..27f84be --- /dev/null +++ b/librerie/exercise1old/zlasdtest/exercise1/fulltest.cpp @@ -0,0 +1,3 @@ + +void testFullExercise1() { +} diff --git a/librerie/exercise1old/zlasdtest/exercise1/simpletest.cpp b/librerie/exercise1old/zlasdtest/exercise1/simpletest.cpp new file mode 100644 index 0000000..8fbc655 --- /dev/null +++ b/librerie/exercise1old/zlasdtest/exercise1/simpletest.cpp @@ -0,0 +1,447 @@ + +#include + +/* ************************************************************************** */ + +#include "../container/container.hpp" + +#include "../vector/vector.hpp" + +#include "../list/list.hpp" + +/* ************************************************************************** */ + +using namespace std; + +/* ************************************************************************** */ + +void stestVectorInt(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + cout << endl << "Begin of Vector Test:" << endl; + try { + { + lasd::Vector vec; + Empty(loctestnum, loctesterr, vec, true); + + GetFront(loctestnum, loctesterr, vec, false, 0); + GetBack(loctestnum, loctesterr, vec, false, 0); + SetAt(loctestnum, loctesterr, vec, false, 1, 0); + GetAt(loctestnum, loctesterr, vec, false, 2, 0); + + Exists(loctestnum, loctesterr, vec, false, 0); + + MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); + MapPostOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); + + FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd, 0, 0, 0); + FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldAdd, 0, 0, 0); + } + { + lasd::Vector vec(3); + Empty(loctestnum, loctesterr, vec, false); + Size(loctestnum, loctesterr, vec, true, 3); + + SetAt(loctestnum, loctesterr, vec, true, 0, 4); + SetAt(loctestnum, loctesterr, vec, true, 1, 3); + SetAt(loctestnum, loctesterr, vec, true, 2, 1); + + GetFront(loctestnum, loctesterr, vec, true, 4); + GetBack(loctestnum, loctesterr, vec, true, 1); + + SetFront(loctestnum, loctesterr, vec, true, 5); + SetBack(loctestnum, loctesterr, vec, true, 4); + + Exists(loctestnum, loctesterr, vec, true, 4); + + MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); + MapPostOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); + FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd, 0, 0, 12); + FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply, 0, 1, 60); + + vec.Resize(2); + FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply, 0, 1, 15); + } + } catch(...) { + loctestnum++; loctesterr++; + cout << endl << "Unmanaged error! " << endl; + } + cout << "End of Vector Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; + testnum += loctestnum; + testerr += loctesterr; +} + +void stestVectorDouble(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + cout << endl << "Begin of Vector Test:" << endl; + try { + lasd::Vector vec(3); + Empty(loctestnum, loctesterr, vec, false); + Size(loctestnum, loctesterr, vec, true, 3); + + SetAt(loctestnum, loctesterr, vec, true, 0, 5.5); + SetAt(loctestnum, loctesterr, vec, true, 1, 3.3); + SetAt(loctestnum, loctesterr, vec, true, 2, 1.1); + + GetFront(loctestnum, loctesterr, vec, true, 5.5); + GetBack(loctestnum, loctesterr, vec, true, 1.1); + + Exists(loctestnum, loctesterr, vec, true, 3.3); + + FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd, 0.0, 0.0, 9.9); + FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply, 0.0, 1.0, 19.965); + } catch(...) { + loctestnum++; loctesterr++; + cout << endl << "Unmanaged error! " << endl; + } + cout << "End of Vector Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; + testnum += loctestnum; + testerr += loctesterr; +} + +void stestVectorString(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + cout << endl << "Begin of Vector Test:" << endl; + try { + lasd::Vector vec(2); + Empty(loctestnum, loctesterr, vec, false); + Size(loctestnum, loctesterr, vec, true, 2); + + SetAt(loctestnum, loctesterr, vec, true, 0, string("A")); + SetAt(loctestnum, loctesterr, vec, true, 1, string("B")); + + GetFront(loctestnum, loctesterr, vec, true, string("A")); + GetBack(loctestnum, loctesterr, vec, true, string("B")); + + Exists(loctestnum, loctesterr, vec, true, string("A")); + + MapPreOrder(loctestnum, loctesterr, vec, true, &MapStringAppend, string(" ")); + MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); + FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldStringConcatenate, string(""), string("X"), string("XA B ")); + FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldStringConcatenate, string(""), string("X"), string("XB A ")); + + Exists(loctestnum, loctesterr, vec, false, string("A")); + + lasd::Vector copvec(vec); + EqualVector(loctestnum, loctesterr, vec, copvec, true); + MapPreOrder(loctestnum, loctesterr, vec, true, &MapStringAppend, string("!")); + NonEqualVector(loctestnum, loctesterr, vec, copvec, true); + + copvec = std::move(vec); + FoldPreOrder(loctestnum, loctesterr, copvec, true, &FoldStringConcatenate, string(""), string("?"), string("?A !B !")); + + lasd::Vector movvec(std::move(vec)); + FoldPreOrder(loctestnum, loctesterr, movvec, true, &FoldStringConcatenate, string(""), string("?"), string("?A B ")); + SetAt(loctestnum, loctesterr, vec, false, 1, string("")); + vec.Resize(1); + SetAt(loctestnum, loctesterr, vec, true, 0, string("X")); + + movvec.Clear(); + Empty(loctestnum, loctesterr, movvec, true); + } catch(...) { + loctestnum++; loctesterr++; + cout << endl << "Unmanaged error! " << endl; + } + cout << "End of Vector Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; + testnum += loctestnum; + testerr += loctesterr; +} + +void stestVector(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + stestVectorInt(loctestnum, loctesterr); + stestVectorDouble(loctestnum, loctesterr); + stestVectorString(loctestnum, loctesterr); + testnum += loctestnum; + testerr += loctesterr; + cout << endl << "Exercise 1 - Vector (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; +} + +/* ************************************************************************** */ + +void stestListInt(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + cout << endl << "Begin of List Test:" << endl; + try { + lasd::List lst; + Empty(loctestnum, loctesterr, lst, true); + Size(loctestnum, loctesterr, lst, true, 0); + + GetFront(loctestnum, loctesterr, lst, false, 0); + GetBack(loctestnum, loctesterr, lst, false, 0); + + Exists(loctestnum, loctesterr, lst, false, 0); + + MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); + MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); + FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0, 0, 0); + FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0, 0, 0); + + RemoveFromFront(loctestnum, loctesterr, lst, false); + FrontNRemove(loctestnum, loctesterr, lst, false, 0); + + InsertAtBack(loctestnum, loctesterr, lst, true, 4); + InsertAtFront(loctestnum, loctesterr, lst, true, 5); + InsertAtFront(loctestnum, loctesterr, lst, true, 9); + InsertAtBack(loctestnum, loctesterr, lst, true, 2); + InsertAtFront(loctestnum, loctesterr, lst, true, 1); + + GetFront(loctestnum, loctesterr, lst, true, 1); + GetBack(loctestnum, loctesterr, lst, true, 2); + SetFront(loctestnum, loctesterr, lst, true, 2); + SetBack(loctestnum, loctesterr, lst, true, 6); + + GetAt(loctestnum, loctesterr, lst, true, 3, 4); + SetAt(loctestnum, loctesterr, lst, true, 3, 3); + + Exists(loctestnum, loctesterr, lst, false, 4); + + MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); + MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); + FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0, 0, 25); + FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply, 0, 1, 1620); + + RemoveFromFront(loctestnum, loctesterr, lst, true); + FrontNRemove(loctestnum, loctesterr, lst, true, 9); + FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply, 0, 1, 90); + + lasd::List coplst(lst); + EqualList(loctestnum, loctesterr, lst, coplst, true); + MapPreOrder(loctestnum, loctesterr, lst, true, &MapIncrement, 0); + NonEqualList(loctestnum, loctesterr, lst, coplst, true); + + InsertAtFront(loctestnum, loctesterr, lst, true, 0); + InsertAtBack(loctestnum, loctesterr, lst, true, 0); + NonEqualList(loctestnum, loctesterr, lst, coplst, true); + coplst = lst; + EqualList(loctestnum, loctesterr, lst, coplst, true); + + RemoveFromFront(loctestnum, loctesterr, coplst, true); + FrontNRemove(loctestnum, loctesterr, coplst, true, 6); + coplst = std::move(lst); + FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0, 0, 11); + FoldPreOrder(loctestnum, loctesterr, coplst, true, &FoldAdd, 0, 0, 17); + + lasd::List movlst(std::move(lst)); + MapPreOrder(loctestnum, loctesterr, movlst, true, &MapIncrement, 0); + FoldPreOrder(loctestnum, loctesterr, movlst, true, &FoldAdd, 0, 0, 14); + + movlst.Clear(); + Empty(loctestnum, loctesterr, movlst, true); + Size(loctestnum, loctesterr, movlst, true, 0); + } catch(...) { + loctestnum++; loctesterr++; + cout << endl << "Unmanaged error! " << endl; + } + cout << "End of List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; + testnum += loctestnum; + testerr += loctesterr; +} + +void stestListDouble(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + cout << endl << "Begin of List Test:" << endl; + try { + lasd::List lst; + Empty(loctestnum, loctesterr, lst, true); + Size(loctestnum, loctesterr, lst, true, 0); + + InsertAtBack(loctestnum, loctesterr, lst, true, -2.5); + InsertAtBack(loctestnum, loctesterr, lst, true, 2.5); + + lst.Clear(); + + InsertAtBack(loctestnum, loctesterr, lst, true, 0.5); + InsertAtFront(loctestnum, loctesterr, lst, true, 3.3); + InsertAtFront(loctestnum, loctesterr, lst, true, 5.5); + InsertAtBack(loctestnum, loctesterr, lst, true, 1.1); + + GetFront(loctestnum, loctesterr, lst, true, 5.5); + GetBack(loctestnum, loctesterr, lst, true, 1.1); + + Exists(loctestnum, loctesterr, lst, false, 0.0); + + MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); + MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); + FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0.0, 0.0, 10.4); + FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply, 0.0, 1.0, 9.9825); + } catch(...) { + loctestnum++; loctesterr++; + cout << endl << "Unmanaged error! " << endl; + } + cout << "End of List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; + testnum += loctestnum; + testerr += loctesterr; +} + +void stestListString(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + cout << endl << "Begin of List Test:" << endl; + try { + lasd::List lst; + Empty(loctestnum, loctesterr, lst, true); + Size(loctestnum, loctesterr, lst, true, 0); + + InsertAtFront(loctestnum, loctesterr, lst, true, string("A")); + InsertAtBack(loctestnum, loctesterr, lst, true, string("B")); + + GetFront(loctestnum, loctesterr, lst, true, string("A")); + GetBack(loctestnum, loctesterr, lst, true, string("B")); + + Exists(loctestnum, loctesterr, lst, true, string("B")); + + MapPreOrder(loctestnum, loctesterr, lst, true, &MapStringAppend, string(" ")); + MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); + FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldStringConcatenate, string(""), string("X"), string("XA B ")); + FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldStringConcatenate, string(""), string("X"), string("XB A ")); + + Exists(loctestnum, loctesterr, lst, false, string("B")); + + lasd::List coplst(lst); + EqualList(loctestnum, loctesterr, lst, coplst, true); + RemoveFromFront(loctestnum, loctesterr, coplst, true); + NonEqualList(loctestnum, loctesterr, lst, coplst, true); + + lst = coplst; + EqualList(loctestnum, loctesterr, lst, coplst, true); + InsertAtBack(loctestnum, loctesterr, lst, true, string("A")); + InsertAtFront(loctestnum, loctesterr, lst, true, string("C")); + NonEqualList(loctestnum, loctesterr, lst, coplst, true); + + coplst = std::move(lst); + FoldPreOrder(loctestnum, loctesterr, coplst, true, &FoldStringConcatenate, string(""), string("?"), string("?CB A")); + } catch(...) { + loctestnum++; loctesterr++; + cout << endl << "Unmanaged error! " << endl; + } + cout << "End of List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; + testnum += loctestnum; + testerr += loctesterr; +} + +void stestList(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + stestListInt(loctestnum, loctesterr); + stestListDouble(loctestnum, loctesterr); + stestListString(loctestnum, loctesterr); + testnum += loctestnum; + testerr += loctesterr; + cout << endl << "Exercise 1 - List (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; +} + +/* ************************************************************************** */ + +void stestVectorListInt(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + cout << endl << "Begin of Vector/List Test:" << endl; + try { + lasd::Vector vec(3); + SetAt(loctestnum, loctesterr, vec, true, 0, -1); + SetAt(loctestnum, loctesterr, vec, true, 1, 0); + SetAt(loctestnum, loctesterr, vec, true, 2, 1); + + lasd::List lst; + InsertAtFront(loctestnum, loctesterr, lst, true, 1); + InsertAtFront(loctestnum, loctesterr, lst, true, 0); + InsertAtFront(loctestnum, loctesterr, lst, true, -1); + + lasd::Vector copvec(lst); + EqualVector(loctestnum, loctesterr, vec, copvec, true); + lasd::Vector copvecx(vec); + EqualVector(loctestnum, loctesterr, copvecx, copvec, true); + + lasd::List coplst(vec); + EqualList(loctestnum, loctesterr, lst, coplst, true); + lasd::List coplstx(lst); + EqualList(loctestnum, loctesterr, coplstx, coplst, true); + } catch(...) { + loctestnum++; loctesterr++; + cout << endl << "Unmanaged error! " << endl; + } + cout << "End of Vector/List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; + testnum += loctestnum; + testerr += loctesterr; +} + +void stestVectorListDouble(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + cout << endl << "Begin of Vector/List Test:" << endl; + try { + lasd::Vector vec(3); + SetAt(loctestnum, loctesterr, vec, true, 0, -0.5); + SetAt(loctestnum, loctesterr, vec, true, 1, 0.0); + SetAt(loctestnum, loctesterr, vec, true, 2, 0.5); + + lasd::List lst; + InsertAtBack(loctestnum, loctesterr, lst, true, -0.5); + InsertAtBack(loctestnum, loctesterr, lst, true, 0.0); + InsertAtBack(loctestnum, loctesterr, lst, true, 0.5); + + lasd::Vector copvec(lst); + EqualVector(loctestnum, loctesterr, vec, copvec, true); + lasd::Vector copvecx(vec); + EqualVector(loctestnum, loctesterr, copvecx, copvec, true); + + lasd::List coplst(vec); + EqualList(loctestnum, loctesterr, lst, coplst, true); + lasd::List coplstx(lst); + EqualList(loctestnum, loctesterr, coplstx, coplst, true); + } catch(...) { + loctestnum++; loctesterr++; + cout << endl << "Unmanaged error! " << endl; + } + cout << "End of Vector/List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; + testnum += loctestnum; + testerr += loctesterr; +} + +void stestVectorListString(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + cout << endl << "Begin of Vector/List Test:" << endl; + try { + lasd::Vector vec(3); + SetAt(loctestnum, loctesterr, vec, true, 0, string("A")); + SetAt(loctestnum, loctesterr, vec, true, 1, string("B")); + SetAt(loctestnum, loctesterr, vec, true, 2, string("C")); + + lasd::List lst; + InsertAtFront(loctestnum, loctesterr, lst, true, string("B")); + InsertAtBack(loctestnum, loctesterr, lst, true, string("C")); + InsertAtFront(loctestnum, loctesterr, lst, true, string("A")); + + lasd::Vector copvec(lst); + EqualVector(loctestnum, loctesterr, vec, copvec, true); + lasd::Vector copvecx(vec); + EqualVector(loctestnum, loctesterr, copvecx, copvec, true); + + lasd::List coplst(vec); + EqualList(loctestnum, loctesterr, lst, coplst, true); + lasd::List coplstx(lst); + EqualList(loctestnum, loctesterr, coplstx, coplst, true); + } catch(...) { + loctestnum++; loctesterr++; + cout << endl << "Unmanaged error! " << endl; + } + cout << "End of Vector/List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; + testnum += loctestnum; + testerr += loctesterr; +} + +void stestVectorList(uint& testnum, uint& testerr) { + uint loctestnum = 0, loctesterr = 0; + stestVectorListInt(loctestnum, loctesterr); + stestVectorListDouble(loctestnum, loctesterr); + stestVectorListString(loctestnum, loctesterr); + testnum += loctestnum; + testerr += loctesterr; + cout << endl << "Exercise 1 - Vector/List (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; +} + +/* ************************************************************************** */ + +void testSimpleExercise1() { + uint testnum = 0, testerr = 0; + stestVector(testnum, testerr); + stestList(testnum, testerr); + stestVectorList(testnum, testerr); + cout << endl << "Exercise 1 (Simple Test) (Errors/Tests: " << testerr << "/" << testnum << ")" << endl; +} diff --git a/librerie/exercise1old/zlasdtest/exercise1/test.hpp b/librerie/exercise1old/zlasdtest/exercise1/test.hpp new file mode 100644 index 0000000..c151dcf --- /dev/null +++ b/librerie/exercise1old/zlasdtest/exercise1/test.hpp @@ -0,0 +1,13 @@ + +#ifndef EX1TEST_HPP +#define EX1TEST_HPP + +/* ************************************************************************** */ + +void testSimpleExercise1(); + +void testFullExercise1(); + +/* ************************************************************************** */ + +#endif diff --git a/librerie/exercise1old/zlasdtest/list/list.hpp b/librerie/exercise1old/zlasdtest/list/list.hpp new file mode 100644 index 0000000..94fbe48 --- /dev/null +++ b/librerie/exercise1old/zlasdtest/list/list.hpp @@ -0,0 +1,92 @@ + +#ifndef LISTTEST_HPP +#define LISTTEST_HPP + +#include "../../list/list.hpp" + +/* ************************************************************************** */ + +template +void InsertAtFront(uint& testnum, uint& testerr, lasd::List& lst, bool chk, const Data& val) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " Insert at the front of the list the value \"" << val << "\": "; + lst.InsertAtFront(val); + std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void RemoveFromFront(uint& testnum, uint& testerr, lasd::List& lst, bool chk) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " Remove from the list of \"" << lst.Front() << "\": "; + lst.RemoveFromFront(); + std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::length_error exc) { + std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void FrontNRemove(uint& testnum, uint& testerr, lasd::List& lst, bool chk, const Data& val) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " FrontNRemove from the list of \"" << lst.Front() << "\": "; + std::cout << ((tst = ((lst.FrontNRemove() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::length_error exc) { + std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void InsertAtBack(uint& testnum, uint& testerr, lasd::List& lst, bool chk, const Data& val) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " Insert at the back of the list the value \"" << val << "\": "; + lst.InsertAtBack(val); + std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void EqualList(uint& testnum, uint& testerr, const lasd::List& lst1, const lasd::List& lst2, bool chk) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " The two lists are " << ((tst = (lst1 == lst2)) ? "" : "not ") << "equal: "; + std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void NonEqualList(uint& testnum, uint& testerr, const lasd::List& lst1, const lasd::List& lst2, bool chk) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " The two lists are " << ((tst = (lst1 != lst2)) ? "not " : "") << "equal: "; + std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +/* ************************************************************************** */ + +#endif diff --git a/librerie/exercise1old/zlasdtest/test.cpp b/librerie/exercise1old/zlasdtest/test.cpp new file mode 100644 index 0000000..faa5bf0 --- /dev/null +++ b/librerie/exercise1old/zlasdtest/test.cpp @@ -0,0 +1,17 @@ + +#include "./exercise1/test.hpp" + +/* ************************************************************************** */ + +#include + +using namespace std; + +/* ************************************************************************** */ + +void lasdtest() { + cout << endl << "~*~#~*~ Welcome to the LASD Test Suite ~*~#~*~ " << endl; + testSimpleExercise1(); + testFullExercise1(); + cout << endl << "Goodbye!" << endl; +} diff --git a/librerie/exercise1old/zlasdtest/test.hpp b/librerie/exercise1old/zlasdtest/test.hpp new file mode 100644 index 0000000..a2fca61 --- /dev/null +++ b/librerie/exercise1old/zlasdtest/test.hpp @@ -0,0 +1,11 @@ + +#ifndef LASDTEST_HPP +#define LASDTEST_HPP + +/* ************************************************************************** */ + +void lasdtest(); + +/* ************************************************************************** */ + +#endif diff --git a/librerie/exercise1old/zlasdtest/vector/vector.hpp b/librerie/exercise1old/zlasdtest/vector/vector.hpp new file mode 100644 index 0000000..bb0ccf6 --- /dev/null +++ b/librerie/exercise1old/zlasdtest/vector/vector.hpp @@ -0,0 +1,37 @@ + +#ifndef VECTORTEST_HPP +#define VECTORTEST_HPP + +#include "../../vector/vector.hpp" + +/* ************************************************************************** */ + +template +void EqualVector(uint& testnum, uint& testerr, const lasd::Vector& vec1, const lasd::Vector& vec2, bool chk) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " The two vectors are " << ((tst = (vec1 == vec2)) ? "" : "not ") << "equal: "; + std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +template +void NonEqualVector(uint& testnum, uint& testerr, const lasd::Vector& vec1, const lasd::Vector& vec2, bool chk) { + bool tst; + testnum++; + try { + std::cout << " " << testnum << " The two vectors are " << ((tst = (vec1 != vec2)) ? "not " : "") << "equal: "; + std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; + } catch(std::exception exc) { + std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; + } + testerr += (1 - (uint) tst); +} + +/* ************************************************************************** */ + +#endif diff --git a/librerie/exercise1old/zmytest/test.cpp b/librerie/exercise1old/zmytest/test.cpp new file mode 100644 index 0000000..ae73e4d --- /dev/null +++ b/librerie/exercise1old/zmytest/test.cpp @@ -0,0 +1,70 @@ +void menu(){ + unsigned short int choice; + DataStructure chosenDataStructure; + DataType chosenDataType; + do{ + std::cout<<"1. Use your tests (to be used by the professor)"<>std::ws; + std::cin>>choice; + }while(choice!=1 && choice!=2); + + switch(choice){ + case 1: + lasdtest(); + break; + case 2: + chosenDataStructure = ChooseDataStructure(); + chosenDataType = ChooseDataType(); + break; + default: + std::cout<<"An error has occurred"<>std::ws; + std::cin>>choice; + }while(choice!=1 && choice!=2); + if(choice == 1) + return DataStructure::vector; + else if(choice == 2) + return DataStructure::list; +} + +DataType ChooseDataType(){ + unsigned short int choice; + do{ + std::cout<<"1. Integer"<>std::ws; + std::cin>>choice; + }while(!(choice>0 && choice<4)); + if(choice==1) + return DataType::integer; + else if(choice==2) + return DataType::ddouble; + else if(choice==3) + return DataType::sstring; +} +void UseChosenType(DataStructure chosenDataStructure, DataType chosenDataType){ + std::cout<<"\tTest on "; + if(chosenDataStructure == DataStructure::vector) + std::cout<<"vector of "; + else if(chosenDataStructure == DataStructure::list) + std::cout<<"list of "; + + if(chosenDataType == DataType::integer) + std::cout<<" integers"< GenerateRandomStructure(const ulong&); +void ViewElement(const LinearContainer&); +void PrintAllElements(const LinearContainer&); +void PrintElement(Data&, void*); // funzione richiamata dalla map +void CheckExists(const LinearContainer&); +void ChooseFoldFunction(const LinearContainer&); +void SumLessThan(const LinearContainer&, const ulong&); +void SumLessThanFold(int&, const void*, void*); +void ProductMoreThan(const LinearContainer&, const ulong&); +void ProductMoreThanFold(float&, const void*, void*); +void ConcatStringLessThan(const LinearContainer&, const ulong&); +void ConcatStringLessThanFold(string&, const void*, void*); + +//7 +void ChooseMapFunction(const LinearContainer); +void DoubleN(const LinearContainer&, const ulong&); +void DoubleNMap(int&, void*); + +void SquareN(const LinearContainer&, const ulong&); +void SquareNMap(float&, void*); + +void Uppercase(const LinearContainer&, const ulong&); +void UppercaseMap(string&, void*); + + +#endif