Atividade de treinamento 08/11

Makefile

@@ -61,5 +61,3 @@ clean:
 	rm -Rf $(OBJ_DIR)
 	rm -Rf $(DIST_DIR)
 	rm -Rf $(COVERAGE_DIR)
-
-

README.md

@@ -45,13 +45,3 @@ Nosso caso de uso é: O usuário entra no diretório do nosso aplicativo e execu
 - ExpectCallFunc: O mesmo que ExpectCall mas para funções estáticas.
 - OnCall: Falsifica uma chamada independente dela ser utilizada durante o ciclo de vida do teste.
 - OnCallFunc: O mesmo que OnCall mas para funções estáticas.
-
-
-
-
-
-
-
-
-
-

src/Calculo.cpp

@@ -36,6 +36,11 @@ int Calculo::resultado(unsigned int indice){
     return 0;
 }
 
+bool Calculo::resultado(unsigned int id, std::string& value){
+    return false;
+   // TODO: Implementar
+}
+
 string Calculo::toString(char sep){
     // TODO: Implementar
     return "";

src/Calculo.h

@@ -18,71 +18,79 @@ using namespace std;
  */
 class Calculo {
 public:
-    
+
     /**
      * Construtor
      * @param inicio Início do cálculo
      */
     Calculo(int inicio = 0, unsigned int tamanho = 0, Interceptador *interceptador = 0);
-    
+
     /**
      * Calcula Fibonacci
      */
     virtual void calcula();
-    
+
     /**
      * Limpa calculo
      */
     virtual void limpaCalculo();
-    
+
     /**
      * Resultados
      * @return 
      */
     virtual unsigned int numeroResultados();
-    
+
     /**
      * Retorna o resultado em uma determinada posição
      * @param indice
      * @return 
      */
     virtual int resultado(unsigned int indice);
-
+
+    /**
+     * Retorna o resultado em uma determinada posição
+     * @param id
+     * @param value
+     * @return 
+     */
+    virtual bool resultado(unsigned int id, std::string& value);
+
     /**
      * Nome do cálculo
      * @return 
      */
     virtual string nome() const;
-    
+
     /**
      * Transforma o resultado em string.
      * @param sep Separador
      * @return 
      */
     virtual string toString(char sep);
-    
+
     /**
      * Destrutor
      */
     virtual ~Calculo();
-    
+
 protected:
-    
+
     /**
      * Início
      */
     int inicio;
-    
+
     /**
      * Tamanho do cálculo que será realizado
      */
     unsigned int tamanho;
-    
+
     /**
      * Interceptador
      */
     Interceptador *interceptador;
-    
+
 };
 
 #endif /* CALCULO_H */

src/Fibonacci.h

@@ -17,62 +17,62 @@ using namespace std;
  * Implementa o calculo de Fibonacci.
  */
 class Fibonacci: public Calculo {
-    
+
 public:
     /**
      * Constructor
      * @param inicio Inicio do calculo
      * @params tamanho Numero de resultados para calcular
      */
     Fibonacci(int inicio = 0, unsigned int tamanho = 10, Interceptador *interceptador = 0);
-    
+
     /**
      * Calcula
      */
     void calcula();
-    
+
     /**
      * Resultados
      * @return 
      */
     virtual unsigned int numeroResultados();
-    
+
     /**
      * Limpa o calculo
      */
     virtual void limpaCalculo();
-    
+
     /**
      * Retorna o resultado em uma determinada posição
      * @param indice
      * @return 
      */
     virtual int resultado(unsigned int indice);
-    
+
     /**
      * Retorna o nome do calculo
      * @return 
      */
     virtual string nome() const;
-    
+
     /**
      * Transforma o resultado em string.
      * @param sep Separador
      * @return 
      */
     virtual string toString(char sep);
-    
+
     /**
      * Destructor
      */
     virtual ~Fibonacci();
 private:
-    
+
     /**
      * Lista de resultados
      */
     vector<int> resultados;
-    
+
 };
 
 #endif /* FIBONACCI_H */

src/Golomb.cpp

@@ -0,0 +1,109 @@
+#include <Golomb.h>
+#include <vector>
+#include <sstream>
+
+Golomb::Golomb(int inicio, unsigned int tamanho, Interceptador *interceptador) :
+    Calculo(inicio, tamanho, interceptador)
+{
+    this->resultados.reserve(tamanho);
+}
+
+
+void Golomb::calcula()
+{
+    std::stringstream ss;
+    unsigned int gV;
+    for (int i = inicio; i < (int)(inicio + tamanho); ++i) {
+        gV = this->golombValue(i);
+
+        for (unsigned int j = 0; j < gV; ++j) {
+            ss << i;
+        }
+        this->resultados.push_back(ss.str());
+        ss.str("");
+    }
+}
+
+unsigned int Golomb::golombValue(const unsigned int n)
+{
+    if (n < 1) return 0;
+
+    std::vector<unsigned int> g;
+    g.push_back(0);
+    for (unsigned int i = 1; i <= n; ++i) {
+        if (i == 1) {
+            g.push_back(1);
+            continue;
+        }
+        g.push_back(1 + g[(i - 1) + 1 - g[g[i-1]]]);
+    }
+    return g[n];
+}
+
+void Golomb::limpaCalculo()
+{
+    this->resultados.clear();
+}
+
+unsigned int Golomb::numeroResultados()
+{
+    return this->resultados.size();
+}
+
+int Golomb::resultado(unsigned int indice)
+{
+    int rtn;
+    std::stringstream ss;
+
+    if (indice >= this->resultados.size()) {
+        return 0; //?
+    }
+    ss << this->resultados[indice];
+    ss >> rtn;
+
+    return this->interceptador->intercepta(rtn);
+}
+
+bool Golomb::resultado(unsigned int id, std::string& value)
+{
+    int rtn;
+    std::stringstream ss;
+
+    if (id >= this->resultados.size()) {
+        return false;
+    }
+    value = this->resultados[id];
+    ss << value;
+    ss >> rtn;
+
+    this->interceptador->intercepta(rtn);
+    return true;
+}
+
+
+string Golomb::toString(char sep)
+{
+    std::stringstream ss;
+    unsigned int i = 0;
+    for(vector<std::string>::iterator it = this->resultados.begin(); it != this->resultados.end(); it++){
+        ss << *it;
+        if(i < (this->resultados.size() - 1)){
+            ss << sep;
+        }
+        i++;
+    }
+    return ss.str();
+}
+
+string Golomb::nome() const
+{
+    return "Golomb";
+}
+
+Golomb::~Golomb() {
+    this->inicio = 0;
+    if (interceptador != 0){
+        delete interceptador;
+        interceptador = 0;
+    }
+}

src/Golomb.h

@@ -0,0 +1,88 @@
+#ifndef GOLOMB_H
+#define GOLOMB_H
+
+#include <vector>
+#include <Calculo.h>
+
+using namespace std;
+
+/**
+ * Implementa o calculo da serie de Golomb
+ */
+class Golomb: public Calculo {
+
+public:
+    /**
+     * Constructor
+     * @param inicio Inicio do calculo
+     * @params tamanho Numero de resultados para calcular
+     */
+    Golomb(int inicio = 0, unsigned int tamanho = 10, Interceptador *interceptador = 0);
+
+    /**
+     * Calcula
+     */
+    void calcula();
+
+    /**
+     * Resultados
+     * @return 
+     */
+    virtual unsigned int numeroResultados();
+
+    /**
+     * Limpa o calculo
+     */
+    virtual void limpaCalculo();
+
+    /**
+     * Retorna o resultado em uma determinada posição
+     * @param indice
+     * @param valor
+     * @return 
+     */
+    virtual bool resultado(unsigned int id, std::string& value);
+
+    /**
+     * Retorna o resultado em uma determinada posição
+     * @param indice
+     * @return 
+     */
+    virtual int resultado(unsigned int indice);
+
+    /**
+     * Retorna o nome do calculo
+     * @return 
+     */
+    virtual std::string nome() const;
+
+    /**
+     * Transforma o resultado em string.
+     * @param sep Separador
+     * @return 
+     */
+    virtual std::string toString(char sep);
+
+    /**
+     * Destructor
+     */
+    virtual ~Golomb();
+
+    /**
+     * @brief Dummy implementation of Golomb sequence. For each input
+     * all precedessor values are computed again.
+     * @param [in] n Input for Golomb sequence
+     * @return Golomb value
+     */
+    unsigned int golombValue(const unsigned int n);
+private:
+
+    /**
+     * Lista de resultados
+     */
+    std::vector<std::string> resultados;
+
+};
+
+#endif /* GOLOMB_H */
+