Initial Commit

Author: pavly-gerges

build/.build/DynamicArray.cpp

@@ -0,0 +1,107 @@
+#ifndef DYNAMIC_CLASS_DEF
+#define DYNAMIC_CLASS_DEF
+
+#include <DynamicArray.h>
+#include <stdlib.h>
+#include <iostream>
+
+using namespace Scrappers;
+
+template <class T>        
+DynamicArray<T>::DynamicArray(int length){
+   this->length = length;
+   ptr = new T[length];
+}
+template <class T>        
+DynamicArray<T>::~DynamicArray(){
+    destroyMemory();
+}
+template <class T>        
+const int DynamicArray<T>::getLength(){
+    return length;
+}
+template <class T>        
+T DynamicArray<T>::add(T object){
+        if(position < length){
+            ptr[position++] = object;
+        }else{
+            T* delegation = new T[length+1];
+            for(int pos = 0; pos < length; pos++){
+                delegation[pos] = T();
+                delegation[pos] = ptr[pos];
+            }
+            delegation[position++] = object;
+            this->length = length + 1;
+        }     
+    return object;
+}
+template <class T>        
+T DynamicArray<T>::add(int position, T object){
+        if(position < length){
+            ptr[position] = object;
+        }else{
+            T* delegation = new T[length+1];
+            for(int pos = 0; pos < length; pos++){
+                delegation[pos] = ptr[pos];
+            }
+            delegation[position] = object;
+            this->length = length + 1;
+        }     
+    return object;
+}
+template <class T>        
+DynamicArray<T>& DynamicArray<T>::operator+(T object){
+        add(object);
+    return *this;
+}
+template <class T>        
+DynamicArray<T>& DynamicArray<T>::operator-(int position){
+        ptr[position] = T();
+    return *this;
+}
+template <class T>        
+T DynamicArray<T>::get(int position){ 
+    return ptr[position];
+}
+template <class T>        
+T* DynamicArray<T>::remove(T* &object){
+       object = nullptr;
+    return object;
+}
+template <class T>        
+void DynamicArray<T>::removeAt(int position){
+    ptr[position] = T();
+}
+template <class T>        
+void DynamicArray<T>::forEach(){
+  for(int position=0; position < length; position++){
+        Scrappers::DynamicArray<T>::forEachUpdateDispatcher(ptr[position]);
+  }
+}
+template <class T>        
+void DynamicArray<T>::destroyMemory(){
+    delete ptr;
+    ptr=NULL;
+    delete &length;
+}
+template <class T>        
+void DynamicArray<T>::reConstruct(){
+    std::cout << "Reconstruct the instance back then" << std::endl;
+}
+template <class T>        
+DynamicArray<T> DynamicArray<T>::shallowCopy(DynamicArray &instance){
+    std::cout << "Shallow copy of data" << std::endl;
+    return 0;
+}
+template <class T>        
+DynamicArray<T> DynamicArray<T>::deepCopy(DynamicArray &instance){
+    std::cout << "DeepCopy of Data" << std::endl;
+      return 0;
+}
+template <class T>        
+void DynamicArray<T>::print(){
+      std::cout << "print" << std::endl;
+}
+#else
+#endif
+       

build/.build/app.cpp

@@ -0,0 +1,85 @@
+#include <iostream>
+#include <string>
+#include <stdlib.h>
+#include "DynamicArray.cpp"
+#include <app.h>
+
+
+/**
+* Redefining the Templated/Generic classes in the form of concrete dataTypes using typedef & enclosing them in a utils struct(short-*  hand-class-utils).
+* <br>
+* Using length pointer variable to keep track of the length of the DynamicArray as an example of pointers
+* <br>
+* utils : is a de-referenced pointer instance of the Class Utils, so can be used to access non-static members : *length value
+*/
+struct Utils{
+  public:
+        typedef Scrappers::DynamicArray<int> DynamicIntArray;
+        typedef Scrappers::DynamicArray<std::string> DynamicStringArray;
+        typedef App::Greeter Greeter;
+        int* length = new int();
+} utils;
+/**
+* Overriding the member function greeting() of class Greeter, & commands a greeting message.
+*/
+std::string App::Greeter::greeting() {
+    return std::string("Simple Language Coverage : \n")
+               .append("\n")
+               .append("1)Classes, Abstraction(virtual), Reservedkeywords, OOP\n")
+               .append("2)Basic Pointers, value References, address of memmory blocks\n")
+               .append("3)Dynamic Arrays\n")
+               .append("4)Static Arrays\n")
+               .append("5)Base memory address of arrays\n")
+               .append("6)Jumping among arrays members using pointers & subscript notations\n")
+               .append("7)Functions, Pointer, Value & Reference paramters\n")
+               .append("8)Usuage of reference parameters\n")
+               .append("9)Shallow & deep copying of variables through the assignment operator\n")
+               .append("\n");
+}
+/** 
+* Overrding the dispatcher & using it as interfaces in java
+* @param T is an object of type T, as the template provides 
+*/
+template <class T>        
+void Scrappers::DynamicArray<T>::forEachUpdateDispatcher(T object){
+    std::cout << object << std::endl;
+}
+/**
+* Commands & run a forEach call to a dynamic array instance 
+* @param Scrappers::DynamicArray<T>* pointer instance of that dynamic array
+*/
+template <class T>  
+void command(Scrappers::DynamicArray<T>* dynmArray){
+        std::cout <<"For Each Dispatcher started>>>>>>>>" << std::endl;
+        dynmArray->forEach();
+        
+}
+/**
+* My Code execution unit.
+*/
+int main () {
+        Utils::Greeter* greeter = new Utils::Greeter();
+        std::cout << (*greeter).greeting() << std::endl;
+        Utils::DynamicStringArray* stringArr = new Utils::DynamicStringArray(3);
+        stringArr->add("Welcome to Dynamic Arrays Example Usuage.....>>>>");
+        stringArr->add("Cpp codingBootcamp by Scrappers Team >>>>>>");
+        stringArr->add("\n");
+        command(stringArr);
+        
+        std::cin >> *(utils.length);
+        
+        Utils::DynamicIntArray* dynmArray = new Utils::DynamicIntArray(*(utils.length));
+        std::cout <<"Length : "<< dynmArray->getLength() << std::endl;
+        dynmArray->add(220);
+        (*dynmArray) + 500 + 300 + 200;
+        command(dynmArray);
+ 
+        (*dynmArray) + 100 - 1;
+        command(dynmArray);
+        //delete the pointer after program execution, assign the memory address to zero
+        delete utils.length;
+        utils.length = nullptr;
+        //print out concatenated pointers for memory reference
+        std::cout << utils.length << "\n" << &utils << "\n" << std::endl;
+    return 0;
+}

build/compile.sh

@@ -0,0 +1,56 @@
+#**
+#* Ccoffee Build tool, manual build, alpha-v1.
+#* Custom Includsions for GTKmm cpp wrapper
+#* dependencies '-I"/usr/include/glibmm-2.9.1/glib" -I"/usr/include/sigc++-2.0/sigc++" -I"/usr/include/giomm-2.4" -I"/usr/include/gtkmm-4.2.0/gtk"'
+#*
+#* @author pavl_g.
+#*#
+echo "Compiling the project"
+
+#1) define work directory
+workDir='/home/twisted/GradleProjects/CppCodingBootcamp'
+
+#2) delete old build
+oldbuild=(${workDir}'/build/.build/*')
+for ((idx=0; idx < ${#oldbuild[@]}; idx++)); do
+rm ${oldbuild[$idx]}
+done
+
+##remove the dir
+rmdir ${workDir}'/build/.build/'
+
+#3) recreate a clean one to gather cpp files for compiling & linking
+mkdir ${workDir}'/build/.build'
+
+##attrs : dir to compile & sharedLib name
+libs=('/home/twisted/GradleProjects/CppCodingBootcamp/src/libs/*')
+main=('/home/twisted/GradleProjects/CppCodingBootcamp/src/main/*')
+
+merge[0]=${libs}
+merge[1]=${main}
+
+#4) copy cpp files to a gather directory
+for ((idx=0; idx < ${#merge[@]}; idx++)); do
+##act on ${merge[$idx]}
+cp ${merge[$idx]} ${workDir}'/build/.build'
+done
+
+# 5) get the final String
+final=${workDir}'/build/.build/*'
+
+# 6) execute using g++ compiler against cpp code
+##prepare exec names
+sharedlib='shared'
+executable='CppCodeCamp.exec'
+# 7) compile files with inclusions
+g++ -x c++ -I'/home/twisted/GradleProjects/CppCodingBootcamp/src/includes' -o ${sharedlib} ${final}
+clang++ -x c++ -I'/home/twisted/GradleProjects/CppCodingBootcamp/src/includes' -o ${executable} ${final}
+# 7) move files to output dir
+##prepare dirs
+builddir=${workDir}'/build/'
+outputdir=${workDir}'/output/'
+##moving files
+mv ${builddir}${sharedlib} ${outputdir}${sharedlib}
+mv ${builddir}${executable} ${outputdir}${executable}
+
+echo "Successfully Compiled"

output/CppCodeCamp.exec

@@ -0,0 +1,35 @@
+/*a guard macro preprocessor command, to check in this header file only once before compile-time*/
+#ifndef DYNAMIC_CLASS_HEADER
+#define DYNAMIC_CLASS_HEADER
+/*namespace is a code enclosure*/
+namespace Scrappers{
+    /*using templates or generics for any class displacement*/
+    template <class T>        
+        class DynamicArray{
+            private:
+                T* ptr;
+                int length;
+                int position;
+                virtual void destroyMemory();
+            public:
+                 DynamicArray(int length = 0);
+                ~DynamicArray();
+                 T add(T object);
+                 T add(int position, T object);
+                 T get(int position);
+                 T* remove(T* &object);
+                 void removeAt(int position);
+                 virtual void forEach();
+                 void forEachUpdateDispatcher(T currentObj);
+                 virtual void reConstruct();
+                 DynamicArray shallowCopy(DynamicArray &instance);
+                 DynamicArray deepCopy(DynamicArray &instance);
+                 DynamicArray& operator+(T object);
+                 DynamicArray& operator-(int position);
+                 const int getLength();
+                 void print();
+        };
+};
+
+
+#endif

output/shared

@@ -0,0 +1,16 @@
+/*
+ * This C++ source file was generated by the Gradle 'init' task.
+ */
+#ifndef APP_H
+#define APP_H
+
+#include <string>
+
+namespace App {
+    class Greeter {
+        public:
+             std::string greeting();
+    };
+}
+
+#endif