/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

/*
* File: ElementaryMatrix.h
* Author:
*
*
*/

#ifndef ELEMENTARYMATRIX_H
#define ELEMENTARYMATRIX_H

#include "squarematrix.h"
#include "element.h"
#include <iostream>
#include <vector>
#include <memory>
#include <string>

template <class T>
class ElementarySquareMatrix: public SquareMatrix
{
private:
int n;
std::vector<std::vector<T> > elements;
public:
ElementarySquareMatrix()
{
   n = 0;
};
ElementarySquareMatrix(const std::string& s)
{
   int pos, endpos;
   n = -1;
   std::shared_ptr<TElement<T> > el;
   std::string s1;
   // Calculate number of rows by counting '['s
   for (unsigned int i = 0; i < s.size(); i++)
   {
         if (s[i] == '[')
         {
            n++;
         }
   }
   // If input is wrong, set n to 0
   if (n == -1)
   {
         n = 0;
   }
   pos = 1;
   // Parse string to get matrix elements
   elements.resize(n);
   for (int i = 0; i < n; i++)
   {
         // Look for '[' start of row
         pos = s.find('[', pos) + 1;
         for (int j = 0; j < n - 1; j++)
         {
            // Look for ',' where number ends
            endpos = s.find(',', pos);
            try
            {
               // Convert to Element
               s1 = s.substr(pos, endpos - pos);
               if (((s1[0] >= '0') && (s1[0] <= '9')) || (s1[0] == '-'))
               {
                     std::shared_ptr<T> ie(new IntElement);
                     ie->setVal(atoi(s1.c_str()));
                     el = std::dynamic_pointer_cast<T>(ie);
               }
               else
               {
                     std::shared_ptr<T> ve(new VariableElement(s1[0]));
                     el = std::dynamic_pointer_cast<T>(ve);
               }
               // Add to row
               elements[i].push_back(el);
               pos = endpos + 1;
            }
            catch (std::exception& e)
            {
               throw e.what();
            }
         }
         endpos = s.find(']', pos);
         try
         {
            // Convert to Element
            s1 = s.substr(pos, endpos - pos);
            if (((s1[0] >= '0') && (s1[0] <= '9')) || (s1[0] == '-'))
            {
               std::shared_ptr<TElement<T> > ie(new IntElement);
               ie->setVal(atoi(s1.c_str()));
               el = std::dynamic_pointer_cast<TElement<T> >(ie);
            }
            else
            {
               std::shared_ptr<TElement<T> > ve(new VariableElement(s1[0]));
               el = std::dynamic_pointer_cast<TElement<T> >(ve);
            }
            // Add to row
            elements[i].push_back(el);
         }
         catch (std::exception& e)
         {
            throw e.what();
         }
   }
};

ElementarySquareMatrix(const ElementarySquareMatrix<T>& m)
{
   try
   {
         *this = m;
   }
   catch (std::exception& e)
   {
         throw e.what();
   }
};

ElementarySquareMatrix(std::shared_ptr<ElementarySquareMatrix<T> >& m)
{
   try
   {
         *this = m;
   }
   catch (std::exception& e)
   {
         throw e.what();
   }
};

ElementarySquareMatrix<T>& operator = (ElementarySquareMatrix<T>& m)
{
   std::vector<std::shared_ptr<T> > row;
   // Clear matrix
   try
   {
         for (int i = 0; i < this->elements.size(); i++)
         {
            this->elements[i].clear();
         }
         this->elements.clear();
         this->n = m.n;
         this->elements.resize(n);
         // Loop and copy elements
         for (int i = 0; i < n; i++)
         {
            for (int j = 0; j < n; j++)
            {
               std::shared_ptr<T> ie(new T);
               ie->setVal(m.elements[i][j]->getVal());
               this->elements[i].push_back(ie);
            }
         }
   }
   catch (std::exception& e)
   {
         throw e.what();
   }
   return *this;
};
ElementarySquareMatrix<T>& operator = (std::shared_ptr<ElementarySquareMatrix<T> >& m)

Overview Magnetic stripe cards, like credit cards, have up to thre...