C++

                            // Comment to end of line
                            /* Multi-line comment */
                            // .hpp denotes for C++ header files, and .h for C header files
#include <iostream>         // Insert C++ standard header file or library file; without .hpp
#include <stdio.h>          // Insert C standard header file or library file; with h
#include "myfile.h"         // Insert file in current directory
#define X some_text         // Replace X with some text
#define F(a,b) a+b          // Replace F(1,2) with 1+2
#define X \
 some text                  // Multiline definition
#undef X                    // Remove definition
#if defined(X)              // Conditional compilation (#ifdef X)
#else                       // Optional (#ifndef X or #if !defined(X))
#endif                      // Required after #if, #ifdef

255, 0377, 0xff             // Integers (decimal, octal, hex)
2147483647L, 0x7fffffffl    // Long (32-bit) integers
123.0, 1.23e2               // double (real) numbers
'a', '\141', '\x61'         // Character (literal, octal, hex)
'\n', '\\', '\'', '\"'      // Newline, backslash, single quote, double quote
"string\n"                  // Array of characters ending with newline and \0
"hello" " world"            // Concatenated strings
true, false                 // bool constants 1 and 0
nullptr                     // Pointer type with the address of 0

int x;                                    // Declare x to be an integer (value undefined)
int x=255;                                // Declare and initialize x to 255
short s; long l;                          // Usually 16 or 32 bit integer (int may be either)
char c='a';                               // Usually 8 bit character
unsigned char u=255;
signed char s=-1;                         // char might be either
unsigned long x = 0xffffffffL;            // short, int, long are signed
float f; double d;                        // Single or double precision real (never unsigned)
bool b=true;                              // true or false, may also use int (1 or 0)
int a, b, c;                              // Multiple declarations
int a[10];                                // Array of 10 ints (a[0] through a[9])
int a[]={0,1,2};                          // Initialized array (or a[3]={0,1,2}; )
int a[2][2]={{1,2},{4,5}};                // Array of array of ints
char s[]="hello";                         // String (6 elements including '\0')
std::string s = "Hello"                   // Creates string object with value "Hello"
std::string s = R"(Hello World)";         // Creates string object with value "Hello\nWorld"
int* p;                                   // p is a pointer to (address of) int
char* s="hello";                          // s points to unnamed array containing "hello"
void* p=nullptr;                          // Address of untyped memory (nullptr is 0)
int& r=x;                                 // r is a reference to (alias of) int x
enum weekend {SAT,SUN};                   // weekend is a type with values SAT and SUN
enum weekend day;                         // day is a variable of type weekend
enum weekend{SAT=0,SUN=1};                // Explicit representation as int
enum {SAT,SUN} day;                       // Anonymous enum
enum class Color {Red,Blue};              // Color is a strict type with values Red and Blue
Color x = Color::Red;                     // Assign Color x to red
typedef String char*;                     // String s; means char* s;
const int c=3;                            // Constants must be initialized, cannot assign to
const int* p=a;                           // Contents of p (elements of a) are constant
int* const p=a;                           // p (but not contents) are constant
const int* const p=a;                     // Both p and its contents are constant
const int& cr=x;                          // cr cannot be assigned to change x
int8_t,uint8_t,int16_t,
uint16_t,int32_t,uint32_t,
int64_t,uint64_t                          // Fixed length standard types
auto it = m.begin();                      // Declares it to the result of m.begin()
auto const param = config["param"];       // Declares it to the const result
auto& s = singleton::instance();          // Declares it to a reference of the result

int x;                      // Auto (memory exists only while in scope)
static int x;               // Global lifetime even if local scope
extern int x;               // Information only, declared elsewhere

x=y;                        // Every expression is a statement
int x;                      // Declarations are statements
;                           // Empty statement
{                           // A block is a single statement
    int x;                  // Scope of x is from declaration to end of block
}
if (x) a;                   // If x is true (not 0), evaluate a
else if (y) b;              // If not x and y (optional, may be repeated)
else c;                     // If not x and not y (optional)

while (x) a;                // Repeat 0 or more times while x is true

for (x; y; z) a;            // Equivalent to: x; while(y) {a; z;}

for (x : y) a;              // Range-based for loop e.g.
                            // for (auto& x in someList) x.y();

do a; while (x);            // Equivalent to: a; while(x) a; main difference with while loop is that loop is executed once before the condition is checked

switch (x) {                // x must be int
    case X1: a;             // If x == X1 (must be a const), jump here
    case X2: b;             // Else if x == X2, jump here
    default: c;             // Else jump here (optional)
}
break;                      // Jump out of while, do, or for loop, or switch
continue;                   // Jump to bottom of while, do, or for loop
return x;                   // Return x from function to caller
try { a; }
catch (T t) { b; }          // If a throws a T, then jump here
catch (...) { c; }          // If a throws something else, jump here

int f(int x, int y);        // f is a function taking 2 ints and returning int
void f();                   // f is a procedure taking no arguments
void f(int a=0);            // f() is equivalent to f(0)
f();                        // Default return type is int
inline f();                 // Optimize for speed
f() { statements; }         // Function definition (must be global)

T operator+(T x, T y);      // a+b (if type T) calls operator+(a, b); is called "operator overloading"
T operator-(T x);           // -a calls function operator-(a)
T operator++(int);          // postfix ++ or -- (parameter ignored)

extern "C" {void f();}      // f() was compiled in C

int function(int &m) {
  m = 2*m;
  if(m < 20) {
    function(m);
  }
  return m;
}
int main() {
  int a = 2;  // initially
  std::cout << "Now a = " << function(a);
}
// Output: Now a = 32

int main()  { statements... }     // OR
int main(int argc, char* argv[]) { statements... }

T::X                        // Name X defined in class T
N::X                        // Name X defined in namespace N
::X                         // Global name X

t.x                         // Member x of struct or class t
p-> x                       // Member x of struct or class pointed to by p
a[i]                        // i'th element of array a
f(x,y)                      // Call to function f with arguments x and y
T(x,y)                      // Object of class T initialized with x and y
x++                         // Add 1 to x, evaluates to original x (postfix)
x--                         // Subtract 1 from x, evaluates to original x
typeid(x)                   // Type of x
typeid(T)                   // Equals typeid(x) if x is a T
dynamic_cast< T>(x)         // Converts x to a T, checked at run time.
static_cast< T>(x)          // Converts x to a T, not checked
reinterpret_cast< T>(x)     // Interpret bits of x as a T
const_cast< T>(x)           // Converts x to same type T but not const

sizeof x                    // Number of bytes used to represent object x
sizeof(T)                   // Number of bytes to represent type T
++x                         // Add 1 to x, evaluates to new value (prefix)
--x                         // Subtract 1 from x, evaluates to new value
~x                          // Bitwise complement of x
!x                          // true if x is 0, else false (1 or 0 in C)
-x                          // Unary minus
+x                          // Unary plus (default)
&x                          // Address of x
*p                          // Contents of address p (*&x equals x)
new T                       // Address of newly allocated T object
new T(x, y)                 // Address of a T initialized with x, y
new T[x]                    // Address of allocated n-element array of T
delete p                    // Destroy and free object at address p
delete[] p                  // Destroy and free array of objects at p
(T) x                       // Convert x to T (obsolete, use .._cast<T>(x))

x * y                       // Multiply
x / y                       // Divide (integers round toward 0, to avoid round-of to 0; for eg do 1.0/2)
x % y                       // Modulo (result has sign of x)

x + y                       // Add, or \&x[y]
x - y                       // Subtract, or number of elements from *x to *y
x << y                      // x shifted y bits to left (x * pow(2, y))
x >> y                      // x shifted y bits to right (x / pow(2, y))

x < y                       // Less than
x <= y                      // Less than or equal to
x > y                       // Greater than
x >= y                      // Greater than or equal to

x & y                       // Bitwise and (3 & 6 is 2)
x ^ y                       // Bitwise exclusive or (3 ^ 6 is 5)
x | y                       // Bitwise or (3 | 6 is 7)
x && y                      // x and then y (evaluates y only if x (not 0))
x || y                      // x or else y (evaluates y only if x is false (0))
x = y                       // Assign y to x, returns new value of x
x += y                      // x = x + y, also -= *= /= <<= >>= &= |= ^=
x ? y : z                   // y if x is true (nonzero), else z
throw x                     // Throw exception, aborts if not caught
x , y                       // evaluates x and y, returns y (seldom used)

namespace N {class T {};}   // Hide name T
N::T t;                     // Use name T in namespace N
using namespace N;          // Make T visible without N::

class T {                                               // A new type
private:                                                // Section accessible only to T's member functions
  int p = 2                                             // Defining private variable p
protected:                                              // Also accessible to classes derived from T
public:                                                 // Accessible to all
    int x;                                              // Member data
    void f();                                           // Member function
    void g() {return;}                                  // Inline member function
    void h() const;                                     // Does not modify any data members
    int operator+(int y);                               // t+y means t.operator+(y)
    int operator-();                                    // -t means t.operator-()
    T(): x(1) {}                                        // Constructor with initialization list
    T(const T& t): x(t.x) {}                            // Copy constructor
    T& operator=(const T& t) { x=t.x; return *this;}    // Assignment operator
    int& getp() { return p; }                           // a good way to give access to private variable
    ~T();                                               // Destructor (automatic cleanup routine)
    virtual ~T();                                       // virtual destructor is always a good practice
    explicit T(int a);                                  // Allow t=T(3) but not t=3
    T(float x): T((int)x) {}                            // Delegate constructor to T(int)
    operator int() const { return x; }                  // Allows int(t)
    friend void i();                                    // Global function i() has private access
    friend class U;                                     // Members of class U have private access
    static int y;                                       // Data shared by all T objects
    static void l();                                    // Shared code.  May access y but not x
    class Z {};                                         // Nested class T::Z
    typedef int V;                                      // T::V means int
};

void T::f() {                                           // Code for member function f of class T
    this->x = x;}                                       // this is address of self (means x=x;)
int T::y = 2;                                           // Initialization of static member (required)
T::l();                                                 // Call to static member
T t;                                                    // Create object t implicit call constructor
t.f();                                                  // Call method f on object t

struct T {                                              // Equivalent to: class T { public:
  virtual void i();                                     // May be overridden at run time by derived class
  virtual void g()=0; };                                // Must be overridden (pure virtual)
class U: public T {                                     // Derived class U inherits all members of base T
  public:
  void g(int) override; };                              // Override method g
class V: private T {};                                  // Inherited members of T become private
class W: public T, public U {};                         // Multiple inheritance
class X: public virtual T {};                           // Classes derived from X have base T directly

template <class T> T f(T t);                 // Overload f for all types
template <class T> class X {                 // Class with type parameter T
  X(T t); };                                 // A constructor
template <class T> X<T>::X(T t) {}           // Definition of constructor
X<int> x(3);                                 // An object of type "X of int"
template <class T, class U=T, int n=0>       // Template with default parameters

#include <memory>                            // Include memory (std namespace)
shared_ptr<int> x;                           // Empty shared_ptr to a integer on heap. Uses reference counting for cleaning up objects.
x = make_shared<int>(12);                    // Allocate value 12 on heap
shared_ptr<int> y = x;                       // Copy shared_ptr, implicit changes reference count to 2.
cout << *y;                                  // Dereference y to print '12'
if (y.get() == x.get()) {                    // Raw pointers (here x == y)
    cout << "Same";
}
y.reset();                                   // Eliminate one owner of object
if (y.get() != x.get()) {
    cout << "Different";
}
if (y == nullptr) {                          // Can compare against nullptr (here returns true)
    cout << "Empty";
}
y = make_shared<int>(15);                    // Assign new value
cout << *y;                                  // Dereference x to print '15'
cout << *x;                                  // Dereference x to print '12'
weak_ptr<int> w;                             // Create empty weak pointer
w = y;                                       // w has weak reference to y.
if (shared_ptr<int> s = w.lock()) {          // Has to be copied into a shared_ptr before usage
    cout << *s;
}
unique_ptr<int> z;                           // Create empty unique pointers
unique_ptr<int> q;
z = make_unique<int>(16);                    // Allocate int (16) on heap. Only one reference allowed.
q = move(z);                                 // Move reference from z to q.
if (z == nullptr){
    cout << "Z null";
}
cout << *q;
shared_ptr<B> r;
r = dynamic_pointer_cast<B>(t);             // Converts t to a shared_ptr<B>

#include <cmath>                    // Include cmath (std namespace)
sin(x); cos(x); tan(x);             // Trig functions, x (double) is in radians
asin(x); acos(x); atan(x);          // Inverses
atan2(y, x);                        // atan(y/x)
sinh(x); cosh(x); tanh(x);          // Hyperbolic sin, cos, tan functions
exp(x); log(x); log10(x);           // e to the x, log base e, log base 10
pow(x, y); sqrt(x);                 // x to the y, square root
ceil(x); floor(x);                  // Round up or down (as a double)
abs(x), fabs(y); fmod(y, z);        // Absolute value for float, y mod z

#include <cassert>        // Include iostream (std namespace)
assert(e);                // If e is false, print message and abort
#define NDEBUG            // To turn off assertion, add before #include <assert.h>

#include <iostream>         // Include iostream (std namespace)
cin >> x >> y;              // Read words x and y (any type) from stdin
cout << "x=" << 3 << endl;  // Write line to stdout
cerr << x << y << flush;    // Write to stderr and flush
c = cin.get();              // c = getchar();
cin.get(c);                 // Read char
cin.getline(s, n, '\n');    // Read line into char s[n] to '\n' (default)
if (cin)                    // Good state (not EOF)?
                            // To read/write any type T:

istream& operator>>(istream& i, T& x) {i >> ...; x=...; return i;}
ostream& operator<<(ostream& o, const T& x) {return o << ...;}

#include <fstream>          // Include filestream (std namespace)
ifstream f1("filename");    // Open text file for reading
if (f1)                     // Test if open and input available
    f1 >> x;                // Read object from file
f1.get(s);                  // Read char or line
f1.getline(s, n);           // Read line into string s[n]
ofstream f2("filename");    // Open file for writing
if (f2) f2 << x;            // Write to file

#include <string>           // Include string (std namespace)
string s1, s2="hello";      // Create strings
s1.size(), s2.size();       // Number of characters: 0, 5
s1 += s2 + ' ' + "world";   // Concatenation
s1 == "hello world"         // Comparison, also <, >, !=, etc.
s1[0];                      // 'h'
s1.substr(m, n);            // Substring of size n starting at s1[m]
s1.c_str();                 // Convert to const char*
s1 = to_string(12.05);      // Converts number to string
getline(cin, s);            // Read line ending in '\n'

#include <utility>                  // Include utility (std namespace)
pair<string, int> a("hello", 3);    // A 2-element struct
a.first;                            // "hello"
a.second;                           // 3

#include <algorithm>            // Include algorithm (std namespace)
min(x, y); max(x, y);           // Smaller/larger of x, y (any type defining <)
swap(x, y);                     // Exchange values of variables x and y
sort(a, a+n);                   // Sort array a[0]..a[n-1] by <
sort(a.begin(), a.end());       // Sort vector or deque
reverse(a.begin(), a.end());    // Reverse vector or deque

#include <chrono>                                         // Include chrono
using namespace std::chrono;                              // Use namespace
auto from =                                               // Get current time_point
  high_resolution_clock::now();
// ... do some work
auto to = high_resolution_clock::now();                   // Get current time_point
using ms = duration<float, milliseconds::period>;         // Define ms as floating point duration

cout << duration_cast<ms>(to - from).count() << "ms";     // Compute duration in milliseconds

#include <thread>                                          // Include thread
unsigned c = hardware_concurrency();                       // Hardware threads (or 0 for unknown)
auto lambdaFn = [](){cout << "Hello multithreading";};     // Lambda function used for thread body
thread t(lambdaFn);                                        // Create and run thread with lambda
t.join();                                                  // Wait for t finishes

// --- shared resource example ---
mutex mut;                                                 // Mutex for synchronization
condition_variable cond;                                   // Shared condition variable
const char* sharedMes = nullptr;                           // Shared resource

auto pingPongFn =                                          // thread body (lambda). Print someone else's message
  [&](const char* mes){
    while (true){
      unique_lock<mutex> lock(mut);                        // locks the mutex
      do {
        cond.wait(lock, [&](){                             // wait for condition to be true (unlocks while waiting which allows other threads to modify)
          return sharedMes != mes;                         // statement for when to continue
        });
      } while (sharedMes == mes);                          // prevents spurious wakeup
      cout << sharedMes << endl;
      sharedMes = mes;
      lock.unlock();                                       // no need to have lock on notify
      cond.notify_all();                                   // notify all condition has changed
    }
  };
sharedMes = "ping";
thread t1(pingPongFn, sharedMes);                         // start example with 3 concurrent threads
thread t2(pingPongFn, "pong");
thread t3(pingPongFn, "boing");

#include <future>                    // Include future
function<int(int)> fib =             // Create lambda function
  [&](int i){
    if (i <= 1){
      return 1;
    }
    return fib(i-1)
         + fib(i-2);
  };
future<int> fut =                    // result of async function
  async(launch::async, fib, 4);      // start async function in other thread
// do some other work
cout << fut.get();                   // get result of async function. Wait if needed.

#include <numeric>                                        // Include numeric
// For std::accumulate function
#include <vector>                                         // To use a vector
vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};        // Create a vector
int sum = accumulate(v.begin(), v.end(), 0);         // Sum all the vector, we set 0 to start from 0. i.e. init = 0
int sum1 = accumulate(v.begin(), v.end(), 2);        // similar to sum1 = sum + 2
float sum2 = accumulate(v.begin(), v.end(), 2.0);    // Note, to have float, put 2.0 instead of 2. So whole operation is float

#include <vector>                                                          // Include vector (std namespace)
vector<int> a(10);                                                         // a[0]..a[9] are int (default size is 0)
vector<int> b{1,2,3};                                                      // Create vector with values 1,2,3
a.size();                                                                  // Number of elements (10)
a.push_back(3);                                                            // Increase size to 11, a[10]=3
a.back()=4;                                                                // a[10]=4;
a.pop_back();                                                              // Decrease size by 1
a.front();                                                                 // a[0];
a[20]=1;                                                                   // Crash: not bounds checked
a.at(20)=1;                                                                // Like a[20] but throws out_of_range()
for (int& p : a)
  p=0;                                                                     // C++11: Set all elements of a to 0
for (vector<int>::iterator p=a.begin(); p!=a.end(); ++p) {*p=0;}           // C++03: Set all elements of a to 0
vector<int> b(a.begin(), a.end());                                         // b is copy of a
vector<T> c(n, x);                                                         // c[0]..c[n-1] init to x
T d[10]; vector<T> e(d, d+10);                                             // e is initialized from d

#include <queue>
queue <int> qsam;       // declare queue object
qsam.push(1);           // inserts element at the end
qsam.push(2);
qsam.size();            // returns the number of elements
qsam.front();           // access the first element
qsam.back();            // access the last element
qsam.pop();             // removes the first element

#include <deque>          // Include deque (std namespace)
a.push_front(x);          // Puts x at a[0], shifts elements toward back
a.pop_front();            // Removes a[0], shifts toward front

#include <map>                           // Include map (std namespace)
map<string, int> a;                      // Map from string to int
a["hello"] = 3;                          // Add or replace element a["hello"]
for (auto& p:a)
    cout << p.first << p.second;         // Prints hello, 3
a.size();                                // Output: 1

#include <unordered_map>            // Include map (std namespace)
unordered_map<string, int> a;       // Map from string to int
a["hello"] = 3;                     // Add or replace element a["hello"]
for (auto& p:a)
    cout << p.first << p.second;    // Prints hello, 3
a.size();                           // Output: 1

#include <functional>              // To use hash
struct hashFunction {
    size_t operator()(const string& s) const {
        return hash<string>()(s);
    }
};

unordered_map<string, int, hashFunction> a;

// But, this is equivalent to the following:
unordered_map<string, int> a; // So, this is just a trivial example.

template<class T, size_t N>
struct hashFunction {
  size_t operator()(const array<T, N>& a) const {
    size_t h = 0;
    for (auto e : a) {
      // See 2003 - Timothy C. Hoad, Justing Zobel - Methods for identifying versioned and plagiarized documents, section Fingerprint Generation, eq. 1.
      // 0x9e3779b9 is a 32-bit fractional part of golden ratio. See https://softwareengineering.stackexchange.com/a/402543/425163
      h ^= hash<int>{}(e)  + 0x9e3779b9 + (h << 6) + (h >> 2);  // is used in boost::hash_combine. But it's not a good hash function. See https://stackoverflow.com/a/50978188/20915376
    }
    return h;
  }
};

unordered_map<array<int, 2>, int, hashFunction<int, 2>> b;

#include <set>                   // Include set (std namespace)
set<int> s;                      // Set of integers
s.insert(123);                   // Add element to set
if (s.find(123) != s.end())      // Search for an element
    s.erase(123);
cout << s.size();                // Number of elements in set

#include <unordered_set>          // Include set (std namespace)
unordered_set<int> s;             // Set of integers
s.insert(123);                    // Add element to set
if (s.find(123) != s.end())       // Search for an element
    s.erase(123);
cout << s.size();                 // Number of elements in set

#include <pair>                      // Include pair
std::pair<int, int> p1;              // one way i.e. default constructor
p1 = std::make_pair(2, 1);           // using std::make_pair
std::pair<float, int> p2(2.5, 1);    // another way i.e. value init
std::pair<float, int> p3(p2);        // another way i.e. copy constructor
p2.first = 4.5;                      // another way of initialization of value
p2.second = 1;                       // We can overwrite the previous value
std::cout << p1.first;               // You can call first element of p1 to print

#include <tuple>                                     // std::get already in std::tuple
#include <iostream>
std::tuple <char, int, float> mytuple;               // Declaring tuple
mytuple = make_tuple('d', 10, 17.89);                // Assigning values to tuple using make_tuple()
std::cout << std::get<0>(mytuple) << std::endl;      // using std::get() to print values. Output: 'd'
std::get<0>(mytuple) = 'r';                          // using std::get() to change values of tuple

std::set<int> s({1,2,3,4});                          // Let's define a set
std::vector new_s(s.begin(), s.end());               // Convert the set to vector container
int first_element = *s.begin();                      // To access the first element of a set "s"
int last_element = new_s.back();                     // Get last element from a vector "new_s"

(unsigned)v;                                         // If v is a non-negative value then, it is safe to cast to unsigned

std::vector<std::tuple<int, int, int>> vec;          // Define a vector of tuple
vec.emplace_back(0, 1, 2);                           // Add element of tuple type in vector

std::ofstream file;                                  // This data type represents the output file stream and is used to create files and to write information to files.
bool writeToAFile = true;
file(writeToAFile ? "filename.txt" : NULL);          // If writeToAFile is true, write to file, else do nothing
                                                     // Instead of NULL, in Linux system, one may like to use "/dev/null" which is a special file that does nothing but it not a good practice because the file size can be increased.

unsigned int x = 2;                                  // x is a non-negative value
std::min(x, 3);                                      // min(x, 3) gives error in compile time
std::min<unsigned int>(x, 3);                        // So, the solution is to explicitly mention the template argument. Then, it will return an unsigned int i.e. 2 in this case.
std::min(x, static_cast<unsigned int>(3));           // Another alternative solution: pass function arguments of same type by casting 3 (default: int) to unsigned int type.


// Extract the file name from a given path
std::string filepath = "spacetimes/conf-4.00-0.02-4-10k-1-torus.dat";   // Let's define a filepath
std::string filename = filepath.substr(filepath.find_last_of("/")+1, filepath.find_last_of(".") - filepath.find_last_of("/") - 1);  // Extract filename from filepath (i.e. conf-4.00-0.02-4-10k-1-torus)

# To add OPENMP support
# ---------------------

find_package(OpenMP)
if (OPENMP_FOUND)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
endif()

# To check if your compiler supports OpenMP, use the following command in the terminal:
# echo |cpp -fopenmp -dM |grep -i open

# Turning off assert(). Just in-case, you're worried; add this in CMakeLists.txt
if (NOT CMAKE_BUILD_TYPE MATCHES Debug)
    add_definitions(-DNDEBUG)
endif()

## Or you can use a more convenient and human-readable way
set(release 1)  # Release (production) build
if (release)
    add_definitions(-DNDEBUG)
endif ()

# Good practice to confirm that the external packages are installed. For example:
find_package(Eigen3 CONFIG REQUIRED)
message(STATUS "Found Eigen3 Version: ${Eigen3_VERSION} | Path: ${Eigen3_DIR}")
include_directories(${EIGEN3_INCLUDE_DIR})
#-> Replace Eigen3 by the package name. For example: Spectra_VERSION, Spectra_DIR.

#----------------------------------------------------------------------------------------------------------------------------------------

# For DOXYGEN documentation
#--------------------------

# Build the documentation only in Release mode.
if (CMAKE_BUILD_TYPE MATCHES "^[Rr]elease")

# check if Doxygen is installed
find_package(Doxygen)
if (DOXYGEN_FOUND)
    # set input and output files
    set(DOXYGEN_IN ${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile) # Doxyfile config file is in the /docs folder, change the path accordingly
    set(DOXYGEN_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)

    # request to configure the file
    configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT} @ONLY)
    message("Doxygen build started!")

    # note the option ALL which allows to build the docs together with the application
    add_custom_target( doc_doxygen ALL
        COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
        COMMENT "Generating API documentation using Doxygen at ${CMAKE_CURRENT_BINARY_DIR}/doc_doxygen"
        VERBATIM )
else (DOXYGEN_FOUND)
  message("Doxygen need to be installed to generate the Doxygen documentation")
endif (DOXYGEN_FOUND)

endif()

# Note in the /docs/Doxyfile file, find the following parameter and add like this:
# OUTPUT_DIRECTORY = @CMAKE_CURRENT_BINARY_DIR@/doc_doxygen/
# INPUT = @CMAKE_CURRENT_SOURCE_DIR@/src/ @CMAKE_CURRENT_SOURCE_DIR@/docs
#----------------------------------------------------------------------------------------------------------------------------------------