Library 2

librerie/exercise2/queue/lst/queuelst.cpp

@@ -2,8 +2,82 @@
 namespace lasd {
 
 /* ************************************************************************** */
+template <typename Data>
+QueueLst(const LinearContainer<Data>& linear){
+  for(ulong i=0; i<linear.Size() ; ++i){
+    Enqueue(linear[i]);
+  }
+}
 
-// ...
+template <typename Data>
+QueueLst(const QueueLst& copyFrom){
+  for(ulong i=0; i<copyFrom.Size() ; ++i){
+    Enqueue(copyFrom[i]);
+  }
+}
+
+template <typename Data>
+QueueLst(QueueLst&& moveFrom) noexcept{
+    std::swap(head,moveFrom.head);
+    std::swap(tail,moveFrom.tail);
+    std::swap(size,moveFrom.size);
+}
+
+~QueueLst(){
+  Clear();
+}
+
+template <typename Data>
+QueueLst<Data>& operator=(const QueueLst& toCopy){
+  QueueLst<Data>* tmp = new QueueLst<Data>(toCopy);
+  std::swap(*this, *tmp);
+  delete tmp;
+  return *this;
+  /*
+    List<Data>::operator=(copyFrom);
+  */
+}
+
+QueueLst& operator=(QueueLst&& toMove) noexcept{
+  if(*this != toMove){
+    std::swap(head, toMove.head);
+    std::swap(head, toMove.tail);
+    std::swap(size, toMove.size);
+    return *this;
+  }
+
+  bool operator==(const QueueLst& queuelist) const noexcept{
+    return List<Data>::operator==(queuelist);
+  }
+
+  bool operator==(const QueueLst& queuelist) const noexcept{
+    return List<Data>::operator!=(queuelist);
+  }
+
+template <typename Data>
+  void Enqueue(const Data& data){
+    List<Data>::InsertAtBack(data);
+  }
+
+template <typename Data>
+  void Enqueue(Data&& data){
+    List<Data>::InsertAtBack(data);
+  }
+
+template <typename Data>
+  Data& Head() const{
+    return List<Data>::Front();
+  }
+
+template <typename Data>
+  void Dequeue(){
+    List<Data>::RemoveFromFront();
+  }
+}
+template <typename Data>
+Data HeadNDequeue(){
+  return List<Data>::FrontNRemove();
+}
 
 /* ************************************************************************** */
 

librerie/exercise2/queue/lst/queuelst.hpp

@@ -14,70 +14,70 @@ namespace lasd {
 /* ************************************************************************** */
 
 template <typename Data>
-class QueueLst { // Must extend Queue<Data> and List<Data>
+class QueueLst :  virtual public Queue<Data>,
+                  virtual protected List<Data>{ // Must extend Queue<Data> and List<Data>
 
 private:
 
-  // ...
-
 protected:
 
-  // using List<Data>::???;
-
-  // ...
+  using List<Data>::head;
+  using List<Data>::tail;
+  using List<Data>::size;
+  using typename List<Data>::Node;
 
 public:
 
   // Default constructor
-  // QueueLst() specifier;
+  QueueLst() = default;
 
   /* ************************************************************************ */
 
   // Specific constructor
-  // QueueLst(argument) specifiers; // A queue obtained from a LinearContainer
+  QueueLst(const LinearContainer<Data>&); // A queue obtained from a LinearContainer
 
   /* ************************************************************************ */
 
   // Copy constructor
-  // QueueLst(argument);
+  QueueLst(const QueueLst&);
 
   // Move constructor
-  // QueueLst(argument);
+  QueueLst(QueueLst&&) noexcept;
 
   /* ************************************************************************ */
 
   // Destructor
-  // ~QueueLst() specifier;
+  ~QueueLst();
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument);
+  QueueLst& operator=(const QueueLst&);
 
   // Move assignment
-  // type operator=(argument);
+  QueueLst& operator=(QueueLst&&) noexcept;
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers;
-  // type operator!=(argument) specifiers;
+  bool operator==(const QueueLst&) const noexcept;
+  bool operator!=(const QueueLst&) const noexcept;
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Queue)
 
-  // type Enqueue(argument) specifiers; // Override Queue member (copy of the value)
-  // type Enqueue(argument) specifiers; // Override Queue member (move of the value)
-  // type Head() specifiers; // Override Queue member (must throw std::length_error when empty)
-  // type Dequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
-  // type HeadNDequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
+  void Enqueue(const Data&) override; // Override Queue member (copy of the value)
+  void Enqueue(Data&&) override; // Override Queue member (move of the value)
+  Data& Head() const override; // Override Queue member (must throw std::length_error when empty)
+  void Dequeue() override; // Override Queue member (must throw std::length_error when empty)
+  Data HeadNDequeue() override; // Override Queue member (must throw std::length_error when empty)
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Container)
 
-  // type Clear() specifiers; // Override Container member
+  void Clear() override; // Override Container member
 
 };