merged

Author: loyc12

exFOO/.brew_install.sh

@@ -0,0 +1,67 @@
+
+      #########.
+     ########",#:
+   #########',##".
+  ##'##'## .##',##.
+   ## ## ## # ##",#.
+    ## ## ## ## ##'
+     ## ## ## :##
+      ## ## ##."
+
+# Delete and reinstall Homebrew from Github repo
+rm -rf $HOME/.brew
+git clone --depth=1 https://github.com/Homebrew/brew $HOME/.brew
+echo ""
+echo "This next step may take a while, please be patient..."
+echo ""
+
+# Create .brewconfig script in home directory
+cat > $HOME/.brewconfig.zsh <<EOL
+# HOMEBREW CONFIG
+
+# Add brew to path
+export PATH=\$HOME/.brew/bin:\$PATH
+
+# Set Homebrew temporary folders
+export HOMEBREW_CACHE=/tmp/\$USER/Homebrew/Caches
+export HOMEBREW_TEMP=/tmp/\$USER/Homebrew/Temp
+
+mkdir -p \$HOMEBREW_CACHE
+mkdir -p \$HOMEBREW_TEMP
+
+# If NFS session
+# Symlink Locks folder in /tmp
+if df -T autofs,nfs \$HOME 1>/dev/null
+then
+  HOMEBREW_LOCKS_TARGET=/tmp/\$USER/Homebrew/Locks
+  HOMEBREW_LOCKS_FOLDER=\$HOME/.brew/var/homebrew
+
+  mkdir -p \$HOMEBREW_LOCKS_TARGET
+  mkdir -p \$HOMEBREW_LOCKS_FOLDER
+
+  # Symlink to Locks target folders
+  # If not already a symlink
+  if ! [[ -L \$HOMEBREW_LOCKS_FOLDER && -d \$HOMEBREW_LOCKS_FOLDER ]]
+  then
+     echo "Creating symlink for Locks folder"
+     rm -rf \$HOMEBREW_LOCKS_FOLDER
+     ln -s \$HOMEBREW_LOCKS_TARGET \$HOMEBREW_LOCKS_FOLDER
+  fi
+fi
+EOL
+
+# Add .brewconfig sourcing in your .zshrc if not already present
+if ! grep -q "# Load Homebrew config script" $HOME/.zshrc
+then
+cat >> $HOME/.zshrc <<EOL
+
+# Load Homebrew config script
+source \$HOME/.brewconfig.zsh
+EOL
+fi
+
+# Sources the .zshrc
+source $HOME/.zshrc > /dev/null 2>&1
+
+hash -r
+brew update

exFOO/Colours.mk

@@ -0,0 +1,35 @@
+#------------------------------------------------------------------------------#
+#                                   COLOURS                                    #
+#------------------------------------------------------------------------------#
+
+# Dark colours (Becomes light if bold)
+DMAGENTA	=\033[0;35m
+DRED		=\033[0;31m
+DYELLOW		=\033[0;33m
+DGREEN		=\033[0;32m
+DCYAN		=\033[0;36m
+DBLUE		=\033[0;34m
+
+# Light and bold colours
+MAGENTA		=\033[1;95m
+RED			=\033[1;91m
+YELLOW		=\033[1;93m
+GREEN		=\033[1;92m
+CYAN		=\033[1;96m
+BLUE		=\033[1;94m
+
+# Grayscale colours
+DEFCOL		=\033[0m
+BLACK		=\033[1;30m
+GRAY		=\033[1;90m
+LGRAY		=\033[1;37m
+WHITE		=\033[1;97m
+
+# RED		: Deletion done (major)
+# MAGENTA	: Deletion done (minor)
+
+# YELLOW	: Task started
+# GREEN		: Task done
+
+# CYAN		: Creation done
+# BLUE		: Installation done

exFOO/Foo.cpp

@@ -0,0 +1,66 @@
+#include "Foo.hpp"
+
+
+// Constructors - Destructor
+
+Foo::Foo()
+{
+	std::cout << "[ Called def. constr. for a FOO instance ]\n";
+	this->name = "UNINITIALIZED";
+}
+Foo::Foo( const std::string _name )
+{
+	std::cout << "[ Called param. constr. for a FOO instance ]\n";
+	this->name = _name;
+}
+Foo::Foo( const Foo &other )
+{
+	std::cout << "[ Called copy constr. for a FOO instance ]\n";
+	this->name = other.getName();
+}
+Foo::~Foo() { std::cout << "[ Destroying a FOO instance ]\n"; }
+
+// Operators
+
+Foo &Foo::operator= ( const Foo &other )
+{
+	std::cout << "[ Called assign. op. for a FOO instance ]\n";
+	this->name = other.getName();
+
+	return *this;
+}
+
+// Checkers
+
+void	Foo::checkName( const std::string _name ) const
+{
+	if ( _name.empty() )
+		throw BadName();
+}
+
+
+// Setters - Getters
+
+void	Foo::setName( const std::string _name )
+{
+	checkName( _name );
+	this->name = _name;
+}
+const std::string	Foo::getName( void ) const
+{
+	return ( this->name );
+}
+
+
+// Others
+
+void	Foo::printName( void ) const
+{
+	std::cout << this->getName();
+}
+
+std::ostream &operator<< (std::ostream &out, const Foo &rhs)
+{
+	out << rhs.getName();
+	return ( out );
+}

exFOO/Foo.hpp

@@ -0,0 +1,88 @@
+#ifndef FOO_HPP
+# define FOO_HPP
+
+# define XCPT public: const char *what() const throw()
+
+// basic libs
+# include <exception>
+# include <iostream>
+# include <iomanip>
+# include <sstream>
+# include <string>
+
+
+// CLASS FOO ( implemented in .cpp file )
+class Foo
+{
+	private:
+		// Attributes
+		std::string	name;
+
+	protected:
+		// Checkers
+		void checkName( const std::string _name ) const;
+
+		// Nested Classes
+		class BadName : public std::exception { XCPT { return "Foo error : invalid name, idiot!"; } };
+
+	public:
+		// Constructors - Destructor
+		Foo();
+		Foo( const std::string _name );
+		Foo( const Foo &other );
+		~Foo();
+
+		// Operators
+		Foo &operator= ( const Foo &other );
+
+		// Setters - Getters
+		void				setName( const std::string _name );
+		const std::string	getName( void ) const;
+
+		// Others
+		void	printName( void ) const;
+
+};
+
+std::ostream &operator<< (std::ostream &out, const Foo &rhs);
+
+
+// TEMPLATE CLASS FOO_T ( implemented in .tpp file )
+template <class T>
+class Foo_T
+{
+	private:
+		// Attributes
+		T	value;
+
+	protected:
+		// Checkers
+		void	checkValue( const T _value ) const;
+
+		// Nested Classes
+		class BadValue : public std::exception { XCPT { return "Foo_T error : invalid value, dumbass!"; } };
+
+	public:
+		// Constructors - Destructor
+		Foo_T();
+		Foo_T( const T _value );
+		Foo_T( const Foo_T<T> &other );
+		~Foo_T();
+
+		// Operators
+		Foo_T<T> &operator= ( const Foo_T<T> &other );
+
+		// Setters - Getters
+		void	setValue( const T _value );
+		const T	getValue( void ) const;
+
+		// Others
+		void	printValue( void ) const;
+
+};
+template < typename T >
+std::ostream &operator<< (std::ostream &out, const Foo_T<T> &rhs);
+
+# include "Foo.tpp"
+
+#endif // FOO_HPP

exFOO/Foo.tpp

@@ -0,0 +1,77 @@
+#include "Foo.hpp"
+
+
+// Constructors - Destructor
+
+template < typename T >
+Foo_T<T>::Foo_T()
+{
+	std::cout << "[ Called def. constr. for a FOO_T instance ]\n";
+	this->value = 0;
+}
+template < typename T >
+Foo_T<T>::Foo_T( const T _value )
+{
+	std::cout << "[ Called param. constr. for a FOO_T instance ]\n";
+	this->value = _value;
+}
+template < typename T >
+Foo_T<T>::Foo_T( const Foo_T &other )
+{
+	std::cout << "[ Called copy constr. for a FOO_T instance ]\n";
+	this->value = other.getValue();
+}
+template < typename T >
+Foo_T<T>::~Foo_T() { std::cout << "[ Destroying a FOO_T instance ]\n"; }
+
+// Operators
+
+template < typename T >
+Foo_T<T> &Foo_T<T>::operator= ( const Foo_T &other )
+{
+	std::cout << "[ Called assign. op. for a FOO_T instance ]\n";
+	this->value = other.getValue();
+
+	return *this;
+}
+
+// Checkers
+
+template < typename T >
+void	Foo_T<T>::checkValue( const T _value ) const
+{
+	if ( _value < 0 )
+		throw BadValue();
+}
+
+
+// Setters - Getters
+
+template < typename T >
+void	Foo_T<T>::setValue( const T _value )
+{
+	checkValue( _value );
+	this->value = _value;
+}
+
+template < typename T >
+const T	Foo_T<T>::getValue( void ) const
+{
+	return ( this->value );
+}
+
+
+// Others
+
+template < typename T >
+void	Foo_T<T>::printValue( void ) const
+{
+	std::cout << this->getValue();
+}
+
+template < typename T >
+std::ostream &operator<< (std::ostream &out, const Foo_T<T> &rhs)
+{
+	out << rhs.getValue();
+	return ( out );
+}