Go back to Richel Bilderbeek's homepage.

Go back to Richel Bilderbeek's C++ page.

 

 

 

 

 

(C++) CodeToHtml

 

STLQt CreatorLubuntu

 

CodeToHtml contains classes used especially by the tool CodeToHtml

Technical facts

 

 

 

 

 

 

./CppCodeToHtml/CppCodeToHtml.pri

 

INCLUDEPATH += \
    ../../Classes/CppCodeToHtml

SOURCES += \
    ../../Classes/CppCodeToHtml/codetohtml.cpp \
    ../../Classes/CppCodeToHtml/codetohtmldialog.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlfooter.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlheader.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlinfo.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlreplacements.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlreplacementscpp.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlreplacementspro.cpp \
    ../../Classes/CppCodeToHtml/codetohtmltechinfo.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlversion.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlfile.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlreplacer.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlfiletypes.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlsnippettypes.cpp \
    ../../Classes/CppCodeToHtml/codetohtmlfoldertypes.cpp

HEADERS  += \
    ../../Classes/CppCodeToHtml/codetohtml.h \
    ../../Classes/CppCodeToHtml/codetohtmldialog.h \
    ../../Classes/CppCodeToHtml/codetohtmlfooter.h \
    ../../Classes/CppCodeToHtml/codetohtmlheader.h \
    ../../Classes/CppCodeToHtml/codetohtmlinfo.h \
    ../../Classes/CppCodeToHtml/codetohtmlreplacements.h \
    ../../Classes/CppCodeToHtml/codetohtmltechinfo.h \
    ../../Classes/CppCodeToHtml/codetohtmlversion.h \
    ../../Classes/CppCodeToHtml/codetohtmlfoldertype.h \
    ../../Classes/CppCodeToHtml/codetohtmlsnippettype.h \
    ../../Classes/CppCodeToHtml/codetohtmlfiletype.h \
    ../../Classes/CppCodeToHtml/codetohtmlfootertype.h \
    ../../Classes/CppCodeToHtml/codetohtmlheadertype.h \
    ../../Classes/CppCodeToHtml/codetohtmlfile.h \
    ../../Classes/CppCodeToHtml/codetohtmlreplacer.h \
    ../../Classes/CppCodeToHtml/codetohtmlfwd.h \
    ../../Classes/CppCodeToHtml/codetohtmlfiletypes.h \
    ../../Classes/CppCodeToHtml/codetohtmlsnippettypes.h \
    ../../Classes/CppCodeToHtml/codetohtmlfoldertypes.h

OTHER_FILES += \
    ../../Classes/CppCodeToHtml/Licence.txt

 

 

 

 

 

./CppCodeToHtml/codetohtml.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef RIBI_CODETOHTML_H
#define RIBI_CODETOHTML_H

#include <string>
#include <vector>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#include <boost/shared_ptr.hpp>
#include "codetohtmlfiletype.h"
#include "codetohtmlsnippettype.h"
#include "codetohtmlfoldertype.h"
#pragma GCC diagnostic pop

namespace ribi {
namespace c2h {

  #ifndef NDEBUG
  ///Test these functions
  void Test();
  #endif

  ///Convert a code snippet
  std::vector<std::string> ConvertCodeSnippet(
    const std::vector<std::string>& code,
    const SnippetType snippet_type
  ) noexcept;

  ///Convert a file
  std::vector<std::string> ConvertFile(
    const std::string& filename,
    const FileType file_type
  ) noexcept;

  ///Filter files: only let .pro, .h, .hpp, . cpp, .c and .sh files pass
  std::vector<std::string> FilterFiles(const std::vector<std::string>& files) noexcept;

  #ifndef _WIN32
  ///Tests if the HTML is clean, this will be checked by the tool 'tidy'
  bool IsCleanHtml(const std::vector<std::string>& html);
  #endif

  #ifndef _WIN32
  ///Check if the tool 'tidy' is installed
  ///If not, user should 'sudo-apt get install tidy'
  ///Or go to http://tidy.sourceforge.net
  bool IsTidyInstalled();
  #endif

  ///Sort files: .pro files first, then X.h, X.cpp, then .sh files
  std::vector<std::string> SortFiles(std::vector<std::string> files) noexcept;

  ///Obtain the sorted files in a folder
  std::vector<std::string> GetSortedFilesInFolder(const std::string& folder) noexcept;

} //~namespace c2h
} //~namespace ribi

#endif // RIBI_CODETOHTML_H

 

 

 

 

 

./CppCodeToHtml/codetohtml.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
#include "codetohtml.h"

#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <iostream>

#include <boost/scoped_ptr.hpp>
#include <boost/xpressive/xpressive.hpp>

#include <QDir>
#include <QFile>

#include "codetohtmlfile.h"
#include "codetohtmlfooter.h"
#include "codetohtmlheader.h"
#include "codetohtmlreplacer.h"
#include "testtimer.h"
#include "codetohtmlsnippettype.h"
#include "codetohtmltechinfo.h"
#include "fileio.h"
#include "qtcreatorprofile.h"
#include "qtcreatorprofilezipscript.h"
#include "trace.h"

#pragma GCC diagnostic pop

#ifndef _WIN32
bool ribi::c2h::IsCleanHtml(const std::vector<std::string>& html)
{
  assert(IsTidyInstalled());

  const std::string temp_filename { fileio::FileIo().GetTempFileName(".htm") };
  const std::string temp_filename_tidy { fileio::FileIo().GetTempFileName("_tidy.txt") };
  assert(!ribi::fileio::FileIo().IsRegularFile(temp_filename));
  //Write HTML to file
  {
    std::ofstream f(temp_filename.c_str());
    std::copy(html.begin(),html.end(),std::ostream_iterator<std::string>(f,"\n"));
  }
  //Start tidy, creates output file
  {
    assert(ribi::fileio::FileIo().IsRegularFile(temp_filename));
    const std::string command = "tidy -q -e -f " + temp_filename_tidy + " " + temp_filename;
    const int error = std::system(command.c_str());
    /*
    if (error && html[5] != " <title>XXX</title>")
    {
      TRACE("Dear assert, check tmp.htm, as this is the HTML tidy failed on");
      TRACE(command);
      TRACE(error);
      #ifndef NDEBUG
      for (const std::string& s: FileToVector(temp_filename_tidy))
      {
        TRACE(s);
      }
      #endif
      assert(!error || html[5] != " <title>XXX</title>");
      return false;
    }
    assert(!error);
    assert(IsRegularFile(temp_filename_tidy));
    */
    if (error) return false;
  }
  const auto v = ribi::fileio::FileIo().FileToVector(temp_filename_tidy);


  if (v.size() > 1)
  {
    TRACE("Errors found by Tidy, check the following files:");
    TRACE(temp_filename);
    TRACE(temp_filename_tidy);
    return false;
  }
  fileio::FileIo().DeleteFile(temp_filename.c_str());
  fileio::FileIo().DeleteFile(temp_filename_tidy.c_str());
  return true;
}
#endif

#ifndef _WIN32
bool ribi::c2h::IsTidyInstalled()
{
  const std::string temp_filename_tidy { fileio::FileIo().GetTempFileName() };

  assert(!ribi::fileio::FileIo().IsRegularFile(temp_filename_tidy));

  //'2>' denotes -AFAIK- 'Write to file only, no screen output'
  const std::string command = "tidy -v 2> ./" + temp_filename_tidy;
  const int error = std::system(command.c_str());
  //assert(ok == 0 && "While I know I have tidy installed");
  //assert(IsRegularFile(temp_filename_tidy) && "While I know I have tidy installed");
  if (!ribi::fileio::FileIo().IsRegularFile(temp_filename_tidy)) return false;

  fileio::FileIo().DeleteFile(temp_filename_tidy.c_str());
  assert(!ribi::fileio::FileIo().IsRegularFile(temp_filename_tidy));

  return !error;
}
#endif


#ifndef NDEBUG
void ribi::c2h::Test()
{
  {
    static bool is_tested{false};
    if (is_tested) return;
    is_tested = true;
  }
  const TestTimer test_timer(__func__,__FILE__,1.0);
  //Test SortedFiles
  {
    const std::vector<std::string> result
      =
      {
        "a.pro",
        "b.pro",
        "c.pro",
        "d.pro",
        "e.pro",
        "a.pri",
        "b.pri",
        "a.h",
        "a.cpp",
        "b.h",
        "b.cpp",
        "c.h",
        "c.cpp",
        "d.h",
        "d.cpp",
        "e.h",
        "e.cpp",
        "a.sh",
        "b.sh",
        "c.sh",
        "d.sh",
        "e.sh"
      };
    std::vector<std::string> v = result;
    v.push_back("x.txt"); //Text files should be filtered away
    v.push_back("y.txt"); //Text files should be filtered away
    std::random_shuffle(std::begin(v),std::end(v));
    v = SortFiles(FilterFiles(v));
    assert(v == result);
  }

}
#endif

std::vector<std::string> ribi::c2h::GetSortedFilesInFolder(const std::string& folder) noexcept
{
  std::vector<std::string> files {
    FilterFiles(
      ribi::fileio::FileIo().GetFilesInFolder(folder)
    )
  };
  files = SortFiles(files);
  return files;
}

std::vector<std::string> ribi::c2h::FilterFiles(const std::vector<std::string>& files) noexcept
{
  std::vector<std::string> v;
  std::copy_if(files.begin(), files.end(),std::back_inserter(v),
    [](const std::string& file)
    {
      if (file.size() >= 3)
      {
        if (file.substr(0,3) == "ui_") return false;
      }
      if (file.size() >= 4)
      {
        if (file.substr(0,4) == "qrc_") return false;
        if (file.substr(0,4) == "moc_") return false;
      }
      if (file.size() >= 18)
      {
        if (file.substr(file.size() - 18, 18) ==  "_plugin_import.cpp") return false;
      }
      const std::string ext = ribi::fileio::FileIo().GetExtensionNoDot(file);
      return
           ext == "c"
        || ext == "cpp"
        || ext == "h"
        || ext == "hpp"
        || ext == "pri"
        || ext == "pro"
        || ext == "py"
        || ext == "sh";
    }
  );
  return v;
}


std::vector<std::string> ribi::c2h::SortFiles(std::vector<std::string> files) noexcept
{
  std::sort(files.begin(), files.end(),
    [](const std::string& lhs,const std::string& rhs)
    {
      const std::string lhs_base = ribi::fileio::FileIo().GetFileBasename(lhs);
      const std::string rhs_base = ribi::fileio::FileIo().GetFileBasename(rhs);
      const std::string lhs_ext = ribi::fileio::FileIo().GetExtension(lhs);
      const std::string rhs_ext = ribi::fileio::FileIo().GetExtension(rhs);
      static std::string pro(".pro");
      static std::string pri(".pri");
      static std::string sh(".sh");
      static std::string h(".h");
      static std::string cpp(".cpp");
      static std::string py(".py");
      if (lhs_ext == pro)
      {
        //.pro files first
        if (rhs_ext != pro)
        {
          return true;
        }
        if (rhs_ext == pro)
        {
          return lhs_base < rhs_base;
        }
      }

      //.pri files then
      if (lhs_ext == pri)
      {
        if (rhs_ext == pro) //.pro first
        {
          return false;
        }
        if (rhs_ext == pri) //sort .pri files
        {
          return lhs_base < rhs_base;
        }
        if (rhs_ext != pri) //else .pri is second
        {
          return true;
        }
      }

      //Headers then
      if (lhs_ext == h && rhs_ext == cpp && lhs_base == rhs_base)
      {
        return true;
      }
      //Pri before unit files
      if ( (lhs_ext == h || lhs_ext == cpp) && rhs_ext == pri)
      {
        return false;
      }

      //Unit files before script files
      if ( (lhs_ext == h || lhs_ext == cpp) && rhs_ext == sh)
      {
        return true;
      }
      //Sort unit files alphabeticaly
      if ( (lhs_ext == h || lhs_ext == cpp) && (rhs_ext == h || rhs_ext == cpp) )
      {
        return lhs_base < rhs_base;
      }

      //.py one-but-last
      if (lhs_ext == py)
      {
        if (rhs_ext == sh)
        {
          return true;
        }
        if (rhs_ext != py)
        {
          return false;
        }
        if (rhs_ext == py)
        {
          return lhs_base < rhs_base;
        }
      }


      //.sh last
      if (lhs_ext == sh)
      {
        if (rhs_ext != sh)
        {
          return false;
        }
        if (rhs_ext == sh)
        {
          return lhs_base < rhs_base;
        }
      }
      return false;
    }
  );
  return files;
}

 

 

 

 

 

./CppCodeToHtml/codetohtmldialog.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef RIBI_CODETOHTMLDIALOG_H
#define RIBI_CODETOHTMLDIALOG_H

#include <string>
#include <vector>

#include <boost/scoped_ptr.hpp>

#include "codetohtmlfiletype.h"
#include "codetohtmlsnippettype.h"
#include "codetohtmlfoldertype.h"

namespace ribi {
namespace c2h {

struct Info;

///c2h::Dialog is the GUI independent UI of CodeToHtml
///It provides a higher-level interface than Replacer:
///where Replacer can convert text, Dialog converts
///- code snippets
///- files
///- folders
struct Dialog
{
  Dialog() noexcept;
  ~Dialog() noexcept;

  ///Convert a file to an HTML page
  ///The file type will be deduced from the file name
  std::vector<std::string> FileToHtml(
    const std::string& file_name) const noexcept;

  ///Convert a folder to an HTML page
  ///The project type will be deduced from the folder its content
  std::vector<std::string> FolderToHtml(
    const std::string& folder_name
    ) const noexcept;

  ///Convert a snippet to an HTML page
  std::vector<std::string> SnippetToHtml(
    const std::vector<std::string>& code,
    const SnippetType snippet_type
  ) const noexcept;

  private:
  friend void boost::checked_delete<>(Dialog*);
  friend void boost::checked_delete<>(const Dialog*);

  ///Extract the page name, from, for example
  /// '/home/richel/ProjectRichelBilderbeek/Tools/ToolCodeToHtml'
  /// to 'ToolCodeToHtml'
  std::string ExtractPageName(const std::string& s) const noexcept;

  std::vector<std::string> FoamFolderToHtml(
    const std::string& folder_name
    ) const noexcept;

  std::vector<std::string> GetProFilesInFolder(
    const std::string& folder) const noexcept;

  std::vector<std::string> ProFolderToHtml(
    const std::string& folder_name
    ) const noexcept;

  std::vector<std::string> TextFolderToHtml(
    const std::string& folder_name
    ) const noexcept;

  #ifndef NDEBUG
  static void Test() noexcept;
  #endif

};

} //~namespace c2h
} //~namespace ribi

#endif // RIBI_CODETOHTMLDIALOG_H

 

 

 

 

 

./CppCodeToHtml/codetohtmldialog.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmldialog.h"

#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <iterator>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#include <boost/make_shared.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/xpressive/xpressive.hpp>
#include <boost/algorithm/string.hpp>

#include "container.h"
#include "codetohtmlfile.h"
#include "codetohtmlfiletypes.h"
#include "codetohtmldialog.h"
#include "codetohtmlfooter.h"
#include "codetohtmlheader.h"
#include "codetohtmlfoldertypes.h"
#include "codetohtmlinfo.h"
#include "codetohtmltechinfo.h"
#include "codetohtmlreplacer.h"
#include "codetohtmlversion.h"
#include "fileio.h"
#include "testtimer.h"
#include "trace.h"
#pragma GCC diagnostic pop

ribi::c2h::Dialog::Dialog() noexcept
{
  #ifndef NDEBUG
  Test();
  #endif
}

ribi::c2h::Dialog::~Dialog() noexcept
{
  //OK
}

std::vector<std::string> ribi::c2h::Dialog::SnippetToHtml(
  const std::vector<std::string>& code,
  const SnippetType snippet_type) const noexcept
{
  FileType file_type = FileType::txt;
  switch (snippet_type)
  {
    case SnippetType::cpp : file_type = FileType::cpp; break;
    case SnippetType::text: file_type = FileType::txt; break;
    case SnippetType::n_snippets:
      assert("Never use SnippetType::n_snippets");
      throw std::logic_error("Never use SnippetType::n_snippets");
  }
  //Convert to HTML, no <code> nor <br/> added yet
  const auto v = Replacer().ToHtml(code,file_type);

  std::vector<std::string> w;
  w.push_back("<p>&nbsp;</p>");
  w.push_back("<!-- start of code -->");
  w.push_back("<table summary=\"snippet\" border = \"1\"><tr><td><code>");
  std::transform(v.begin(),v.end(),std::back_inserter(w),
    [](const std::string& s)
    {
      return s + "<br/>";
    }
  );

  w.push_back("</code></td></tr></table>");
  w.push_back("<!-- end of the code -->");
  w.push_back("<p>&nbsp;</p>");
  w.push_back("<p>&nbsp;</p>");
  w.push_back("<p>&nbsp;</p>");
  w.push_back("<p>&nbsp;</p>");
  w.push_back("<p>&nbsp;</p>");
  return w;
}

std::string ribi::c2h::Dialog::ExtractPageName(const std::string& s) const noexcept
{
  // /home/richel/ProjectRichelBilderbeek/Tools/ToolCodeToHtml
  // /home/richel/ProjectRichelBilderbeek/Tools/ToolCodeToHtml/
  // should become
  // ToolCodeToHtml'

  static const boost::xpressive::sregex r
    = boost::xpressive::sregex::compile("[A-Za-z0-9_\\.]*");

  std::vector<std::string> v;
  boost::xpressive::sregex_iterator i(s.begin(),s.end(),r);
  while (i != boost::xpressive::sregex_iterator())
  {
    v.push_back(i->str());
    ++i;
  }
  //Clean up the vector: remove filenames and empty strings
  while (1)
  {
    if (v.empty()) break;
    const std::string t = boost::algorithm::trim_copy( v[ v.size() - 1] );
    if (t.find('.') != std::string::npos || t.empty())
    {
      v.pop_back();
    }
    else break;
  }

  #ifdef REALLY_TRACE_THIS_20130929_28764723047972338294764627389
  const std::size_t sz = v.size();
  TRACE(sz);
  for (std::size_t i=0; i!=sz; ++i)
  {
    std::stringstream s;
    s << i << '/' << sz << ": '" << v[i] << "'";
    TRACE(s.str());
  }
  #endif
  const std::string t = v.empty() ? std::string() : v[v.size() - 1];


  #ifdef USE_BOOST_XPRESSIVE_78263785634856349
  static const boost::xpressive::sregex rex
    = boost::xpressive::sregex::compile(
      "(.*)?"          //Optional super folders
      "(/|\\\\)?"      //(back)slash
      "([A-Za-z0-9]*)" //Here is the booty
      "(/|\\\\)?"      //(back)slash
      "(([A-Za-z0-9]*)(\\.)([A-Za-z0-9]*))?" //An optional filename
      "(/|\\\\)?"    //Perhaps possible trailing (back)slash
      "\\>");

  boost::xpressive::smatch what;

  std::string t;
  if( boost::xpressive::regex_match(s, what, rex ) )
  {
    const std::size_t sz = what.size();
    for (std::size_t i=0; i!=sz; ++i)
    {
      std::stringstream s;
      s << i << "/" << sz << ": '" << what[i] << "'";
      TRACE(s.str());
    }
    t = what[1];
  }
  #endif //USE_BOOST_XPRESSIVE_78263785634856349

  assert(t.find('/') == std::string::npos
    && "A c2h::Info page must not contain a slash");
  assert(t.find('\\') == std::string::npos
    && "A c2h::Info page must not contain a backslash");

  return t;
}

std::vector<std::string> ribi::c2h::Dialog::FileToHtml(
  const std::string& filename) const noexcept
{
  const auto v = ribi::fileio::FileIo().FileToVector(filename);
  const FileType file_type = FileTypes().DeduceFileType(filename);
  return Replacer().ToHtml(v,file_type);
}

std::vector<std::string> ribi::c2h::Dialog::FolderToHtml(
  const std::string& foldername) const noexcept
{
  assert(fileio::FileIo().IsFolder(foldername));
  const FolderType folder_type = FolderTypes::DeduceFolderType(foldername);
  switch(folder_type)
  {
    case FolderType::foam:
      return FoamFolderToHtml(foldername);
    case FolderType::pro:
      return ProFolderToHtml(foldername);
    case FolderType::txt:
      return TextFolderToHtml(foldername);
  }
  assert(!"Should not get here");
  throw std::logic_error("ribi::c2h::Dialog::FolderToHtml");
}

std::vector<std::string> ribi::c2h::Dialog::FoamFolderToHtml(
  const std::string& foldername) const noexcept
{
  assert(fileio::FileIo().IsFolder(foldername));
  assert(foldername.back() != '\\');
  assert(foldername.back() != '/');

  std::vector<std::string> v;
  //Header
  {
    HeaderType header_type = HeaderType::foam;
    const std::vector<std::string> w {
      Header::ToHtml(header_type,foldername)
    };
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  //Info
  {
    const boost::shared_ptr<const Info> info(new Info);
    const std::vector<std::string> w {
      info->ToHtml(ExtractPageName(foldername))
    };

    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  //Body
  {
    const std::vector<std::string> files_no_path {
      fileio::FileIo().GetFilesInFolderRecursive(foldername)
    };
    std::vector<std::string> files;
    std::transform(
      files_no_path.begin(),
      files_no_path.end(),
      std::back_inserter(files),
      [foldername](const std::string& s)
      {
        //If the path is already complete, return it
        if (ribi::fileio::FileIo().IsRegularFile(s))
        {
          return s;
        }
        //Prepend the folder name
        const std::string t {
          foldername
          + ribi::fileio::FileIo().GetPathSeperator()
          + s
        };
        #ifndef NDEBUG
        if(!ribi::fileio::FileIo().IsRegularFile(t))
        {
          TRACE("ERROR");
          TRACE(foldername); TRACE(s); TRACE(t);
        }
        #endif
        assert(ribi::fileio::FileIo().IsRegularFile(t));
        return t;
      }
    );

    #ifndef NDEBUG
    for (const std::string& file: files)
    {
      if (!ribi::fileio::FileIo().IsRegularFile(file)) { TRACE(file); }
      assert(ribi::fileio::FileIo().IsRegularFile(file));
    }
    #endif

    std::for_each(files.begin(),files.end(),
      [&v](const std::string& filename)
      {
        assert(ribi::fileio::FileIo().IsRegularFile(filename));
        const boost::shared_ptr<File> content {
          new File(filename,FileType::foam)
        };
        const std::vector<std::string> w = content->GetHtml();
        std::copy(w.begin(),w.end(),std::back_inserter(v));
      }
    );
  }
  //Footer
  {
    const std::vector<std::string> w { Footer::ToHtml(FooterType::foam) };
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  return v;
}

std::vector<std::string> ribi::c2h::Dialog::GetProFilesInFolder(
  const std::string& folder) const noexcept
{
  return ribi::fileio::FileIo().GetFilesInFolderByRegex(folder,".*\\.(pro)\\>");
}


std::vector<std::string> ribi::c2h::Dialog::ProFolderToHtml(
  const std::string& foldername) const noexcept
{
  std::vector<std::string> v;
  //Header
  {
    HeaderType header_type = HeaderType::cpp;
    const std::vector<std::string> w {
      Header::ToHtml(header_type,foldername)
    };
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  //Collect files
  {
    const std::vector<std::string> pro_files_no_path {
      GetProFilesInFolder(foldername)
    };
    std::vector<std::string> pro_files;
    std::transform(
      pro_files_no_path.begin(),
      pro_files_no_path.end(),
      std::back_inserter(pro_files),
      [foldername](const std::string& s)
      {
        const std::string t {
          foldername
          + ribi::fileio::FileIo().GetPathSeperator()
          + s
        };
        return t;
      }
    );

    #ifndef NDEBUG
    for (const std::string& pro_file: pro_files)
    {
      if (!ribi::fileio::FileIo().IsRegularFile(pro_file)) { TRACE(pro_file); }
      assert(ribi::fileio::FileIo().IsRegularFile(pro_file));
    }
    #endif
    //Info
    {
      const boost::shared_ptr<const Info> info(new Info);
      const std::vector<std::string> w {
        info->ToHtml(ExtractPageName(foldername))
      };
      std::copy(w.begin(),w.end(),std::back_inserter(v));
    }

    //TechInfo
    const boost::shared_ptr<const TechInfo> techInfo(new TechInfo(pro_files));
    const std::vector<std::string> w = techInfo->ToHtml();
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  {
    const std::vector<std::string> files_no_path {
      GetSortedFilesInFolder(foldername)
    };
    std::vector<std::string> files;
    std::transform(files_no_path.begin(),files_no_path.end(),std::back_inserter(files),
      [foldername](const std::string& s)
      {
        const std::string t {
          foldername + fileio::FileIo().GetPathSeperator() + s
        };
        if (!ribi::fileio::FileIo().IsRegularFile(t))
        {
          TRACE("ERROR"); TRACE(s); TRACE(foldername); TRACE(t);
        }
        assert(ribi::fileio::FileIo().IsRegularFile(t));
        return t;
      }
    );

    std::for_each(files.begin(),files.end(),
      [&v](const std::string& filename)
      {
        assert(ribi::fileio::FileIo().IsRegularFile(filename));
        const boost::shared_ptr<File> content {
          new File(filename)
        };
        const std::vector<std::string> w = content->GetHtml();
        std::copy(w.begin(),w.end(),std::back_inserter(v));
      }
    );
  }
  {
    const std::vector<std::string> w { Footer::ToHtml(FooterType::cpp) };
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  return v;
}

std::vector<std::string> ribi::c2h::Dialog::TextFolderToHtml(
  const std::string& foldername ) const noexcept
{
  assert(fileio::FileIo().IsFolder(foldername));
  assert(foldername.back() != '\\');
  assert(foldername.back() != '/');

  std::vector<std::string> v;
  //Header
  {
    HeaderType header_type = HeaderType::cpp;
    const std::vector<std::string> w {
      Header::ToHtml(header_type,foldername)
    };
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  //Body
  {
    const std::vector<std::string> files_no_path {
      fileio::FileIo().GetFilesInFolderRecursive(foldername)
    };
    std::vector<std::string> files;
    std::transform(
      files_no_path.begin(),
      files_no_path.end(),
      std::back_inserter(files),
      [foldername](const std::string& s)
      {
        //If the path is already complete, return it
        if (ribi::fileio::FileIo().IsRegularFile(s))
        {
          return s;
        }
        //Prepend the folder name
        const std::string t {
          foldername
          + ribi::fileio::FileIo().GetPathSeperator()
          + s
        };
        #ifndef NDEBUG
        if(!ribi::fileio::FileIo().IsRegularFile(t))
        {
          TRACE("ERROR");
          TRACE(foldername); TRACE(s); TRACE(t);
        }
        #endif
        assert(ribi::fileio::FileIo().IsRegularFile(t));
        return t;
      }
    );
    files = FilterFiles(files); //Fix #196
    #ifndef NDEBUG
    for (const std::string& file: files)
    {
      if (!ribi::fileio::FileIo().IsRegularFile(file)) { TRACE(file); }
      assert(ribi::fileio::FileIo().IsRegularFile(file));
    }
    #endif

    std::for_each(files.begin(),files.end(),
      [&v](const std::string& filename)
      {
        assert(ribi::fileio::FileIo().IsRegularFile(filename));
        const boost::shared_ptr<File> content {
          new File(filename,FileType::txt)
        };
        const std::vector<std::string> w = content->GetHtml();
        std::copy(w.begin(),w.end(),std::back_inserter(v));
      }
    );
  }
  //Footer
  {
    const std::vector<std::string> w { Footer::ToHtml(FooterType::cpp) };
    std::copy(w.begin(),w.end(),std::back_inserter(v));
  }
  return v;
}

#ifndef NDEBUG
void ribi::c2h::Dialog::Test() noexcept
{
  {
    static bool is_tested{false};
    if (is_tested) return;
    is_tested = true;
  }
  Container();
  Replacer();
  FileTypes();
  fileio::FileIo();
  {
    const std::string tmp{fileio::FileIo().GetTempFileName(".png")};
    {std::ofstream f(tmp.c_str());}
    const auto file = boost::make_shared<File>(tmp);
    fileio::FileIo().DeleteFile(tmp);
  }
  const TestTimer test_timer(__func__,__FILE__,2.0);
  const Dialog d;

  assert(d.ExtractPageName("X") == "X");
  assert(d.ExtractPageName("/X") == "X");
  assert(d.ExtractPageName("/A/X") == "X");
  assert(d.ExtractPageName("/A/B/X") == "X");
  assert(d.ExtractPageName("/A/B/C/X") == "X");
  assert(d.ExtractPageName("/X/") == "X");
  assert(d.ExtractPageName("/A/X/") == "X");
  assert(d.ExtractPageName("/A/B/X/") == "X");
  assert(d.ExtractPageName("/A/B/C/X/") == "X");

  assert(d.ExtractPageName("\\X") == "X");
  assert(d.ExtractPageName("\\A\\X") == "X");
  assert(d.ExtractPageName("\\A\\B\\X") == "X");
  assert(d.ExtractPageName("\\A\\B\\C\\X") == "X");
  assert(d.ExtractPageName("\\X\\") == "X");
  assert(d.ExtractPageName("\\A\\X\\") == "X");
  assert(d.ExtractPageName("\\A\\B\\X\\") == "X");
  assert(d.ExtractPageName("\\A\\B\\C\\X\\") == "X");

  assert(d.ExtractPageName("/X") == "X");
  assert(d.ExtractPageName("/A\\X") == "X");
  assert(d.ExtractPageName("/A\\B/X") == "X");
  assert(d.ExtractPageName("\\A\\B/C/X") == "X");
  assert(d.ExtractPageName("\\X/") == "X");
  assert(d.ExtractPageName("/A\\X/") == "X");
  assert(d.ExtractPageName("/A/B\\X/") == "X");
  assert(d.ExtractPageName("/A/B\\C/X/") == "X");

  assert(d.ExtractPageName("main.cpp") == "");
  assert(d.ExtractPageName("/X/main.cpp") == "X");
  assert(d.ExtractPageName("/A/X/main.cpp") == "X");
  assert(d.ExtractPageName("/A/B/X/main.cpp") == "X");
  assert(d.ExtractPageName("/A/B/C/X/main.cpp") == "X");
  assert(d.ExtractPageName("/X/main.cpp/") == "X");
  assert(d.ExtractPageName("/A/X/main.cpp/") == "X");
  assert(d.ExtractPageName("/A/B/X/main.cpp/") == "X");
  assert(d.ExtractPageName("/A/B/C/X/main.cpp/") == "X");

  assert(d.ExtractPageName("/home/richel/ProjectRichelBilderbeek/Tools/ToolCodeToHtml")
    == "ToolCodeToHtml");

  //GetProFiles
  {
    //Always first remove the temp file
    const std::string filename = fileio::FileIo().GetTempFileName() + ".pro";
    if (ribi::fileio::FileIo().IsRegularFile(filename)) { ribi::fileio::FileIo().DeleteFile(filename); }
    assert(!ribi::fileio::FileIo().IsRegularFile(filename));

    const std::size_t n = d.GetProFilesInFolder("").size();
    {
      std::ofstream f(filename.c_str());
      f << "tmp";
      f.close();
    }
    const std::size_t p = d.GetProFilesInFolder("").size();
    assert(n == p - 1);
    ribi::fileio::FileIo().DeleteFile(filename);
    assert(!ribi::fileio::FileIo().IsRegularFile(filename));
    const std::size_t q = d.GetProFilesInFolder("").size();
    assert(n == q);
  }
  //Check that .PNG files are
  {
    const std::string tmp_filename{fileio::FileIo().GetTempFileName(".png")};
    { std::ofstream f(tmp_filename); }
    assert(fileio::FileIo().IsRegularFile(tmp_filename));
    const boost::shared_ptr<File> content { new File(tmp_filename) };
    const std::vector<std::string> w = content->GetHtml();
    assert(w.size() == 8);
    assert(w[0].substr(0,4) == "<h2>");
    assert(w[1] == "<p>&nbsp;</p>");
    assert(w[2].substr(0,11) == "<p><img src");
    assert(w[3] == "<p>&nbsp;</p>");
    fileio::FileIo().DeleteFile(tmp_filename);
  }
  //DeduceFolderType

  //Check if Info is added

  //Check if CodeToHtml creates a clean HTML file when it converts itself
  #ifndef _WIN32
  assert(IsTidyInstalled() && "While I know I have tidy installed");
  if (IsTidyInstalled())
  {
    const std::string filename = "../ToolCodeToHtml/qtmain.cpp";
    if (ribi::fileio::FileIo().IsRegularFile(filename))
    {
      std::vector<std::string> v;
      {
        const auto w = Header::ToHtml(HeaderType::cpp,filename);
        std::copy(std::begin(w),std::end(w),std::back_inserter(v));
      }
      {
        const auto w = d.FileToHtml(filename);
        std::copy(std::begin(w),std::end(w),std::back_inserter(v));
      }
      {
        const auto w = Footer::ToHtml(FooterType::cpp);
        std::copy(std::begin(w),std::end(w),std::back_inserter(v));
      }
      if (!IsCleanHtml(v))
      {
        std::ofstream f("tmp_to_check.htm");
        f << Container().Concatenate(v,"\n");
      }
      assert(IsCleanHtml(v) && "Assume tidy HTML, inspect tmp_to_check.htm");
    }
    else
    {
      TRACE("Warning: ToolCodeToHtml has not tested itself on its own code upon construction");
    }
  }
  else
  {
    TRACE("WARNING: 'tidy' not found, check if CodeToHtml generates clean HTML code is skipped");
  }
  if (IsTidyInstalled())
  {
    const std::string path = "../ToolCodeToHtml";
    if (ribi::fileio::FileIo().IsFolder(path))
    {
      std::vector<std::string> v;
      {
        //const auto w = Header::ToHtml(HeaderType::cpp,path);
        //std::copy(std::begin(w),std::end(w),std::back_inserter(v));
      }
      {
        const auto w = d.FolderToHtml(path);
        std::copy(std::begin(w),std::end(w),std::back_inserter(v));
      }
      {
        //const auto w = Footer::ToHtml(FooterType::cpp);
        //std::copy(std::begin(w),std::end(w),std::back_inserter(v));
      }
      if (!IsCleanHtml(v))
      {
        std::ofstream f("tmp_to_check.htm");
        f << Container().Concatenate(v,"\n");
      }
      assert(IsCleanHtml(v) && "Assume tidy HTML, inspect tmp_to_check.htm");
    }
    else
    {
      TRACE("Warning: ToolCodeToHtml has not tested itself on its own code upon construction");
    }
  }
  else
  {
    TRACE("WARNING: 'tidy' not found, check if CodeToHtml generates clean HTML code is skipped");
  }
  #endif
}
#endif

 

 

 

 

 

./CppCodeToHtml/codetohtmlfile.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef RIBI_CODETOHTMLCONTENT_H
#define RIBI_CODETOHTMLCONTENT_H

#include <string>
#include <vector>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#include <boost/checked_delete.hpp>
#include <boost/make_shared.hpp>

#include "codetohtml.h"
#include "codetohtmlfiletype.h"
#include "codetohtmlreplacements.h"
#pragma GCC diagnostic pop

namespace ribi {
namespace c2h {

///File (previous name: Content) contains a piece of content like
///C++ source code, a text file, a .pro file, a .sh file
struct File
{
  ///Convert a file to its HTML equivalent
  ///Deduce the content type from the filename
  File(const std::string& filename);

  ///Convert a file to its HTML equivalent
  ///The content type is given manually
  File(
    const std::string& filename,
    const FileType content_type
  );

  ///Get the HTML version of the file.
  ///The content is created by CreateHtml
  const std::vector<std::string>& GetHtml() const noexcept { return m_html; }

  private:
  ~File() noexcept {}
  friend void boost::checked_delete<>(File*);
  friend void boost::checked_delete<>(const File*);
  friend class boost::detail::sp_ms_deleter<      File>;
  friend class boost::detail::sp_ms_deleter<const File>;

  const std::vector<std::string> m_html;

  ///Create the HTML of the file
  static std::vector<std::string> CreateHtml(
    const std::string& filename,
    const FileType content_type) noexcept;

  #ifndef NDEBUG
  static void Test() noexcept;
  #endif
};

} //~namespace c2h
} //~namespace ribi

#endif // RIBI_CODETOHTMLCONTENT_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlfile.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#include "codetohtmlfile.h"

#include <algorithm>
#include <cassert>
#include <iostream>

#include "codetohtmlfiletypes.h"
#include "codetohtmlfooter.h"
#include "codetohtml.h"
#include "codetohtmlheader.h"
#include "codetohtmlreplacements.h"
#include "codetohtmlreplacer.h"
#include "fileio.h"
#include "testtimer.h"
#include "trace.h"
#pragma GCC diagnostic pop

#define PROGRAM_HANGS


ribi::c2h::File::File(const std::string& filename)
  : m_html(CreateHtml(filename,FileTypes().DeduceFileType(filename)))
{
  #ifndef NDEBUG
  Test();
  #endif
}

ribi::c2h::File::File(
  const std::string& filename,
  const FileType content_type)
    : m_html(CreateHtml(filename,content_type))
{
  #ifndef NDEBUG
  Test();
  #endif
}

std::vector<std::string> ribi::c2h::File::CreateHtml(
  const std::string& filename,
  const FileType file_type
  ) noexcept
{
  assert(fileio::FileIo().IsRegularFile(filename));

  std::vector<std::string> v;
  if (filename == "Licence.txt" || filename == "License.txt") return v;

  //Add heading
  switch(file_type)
  {
    case FileType::cpp:
    case FileType::png:
      v.push_back("<h2>" + filename + "</h2>");
    break;
    case FileType::pro:
      v.push_back(
        "<h2><a href=\"CppQtProjectFile.htm\">Qt project file</a>: "
        + filename + "</h2>");
    break;
    case FileType::foam:
    case FileType::pri:
    case FileType::py:
    case FileType::sh:
    case FileType::txt:
      v.push_back("<h2>" + filename + "</h2>");
    break;
    case FileType::license_txt:
      assert(!"Should not HTML-ify FileType::license_txt");
      throw std::logic_error("Should not HTML-ify FileType::license_txt");
    case FileType::n_types:
      assert(!"Should never use FileType::n_types");
      throw std::logic_error("Should never use FileType::n_types");
  }

  //Add end of heading
  v.push_back("<p>&nbsp;</p>");

  //Start of code
  if (file_type == FileType::png)
  {
    v.push_back("<p><img src=\"" + filename + "\" alt=\"" + filename + "\"/></p>");
  }
  else
  {
    v.push_back("<!-- start of code -->");
    v.push_back("<table summary=\"" + filename + "\" border = \"1\"><tr><td><code>");

    //Add the HTMLified content
    {
      assert(fileio::FileIo().IsRegularFile(filename));
      auto lines_text = fileio::FileIo().FileToVector(filename);
      if (file_type == FileType::foam)
      {
        //Keep lines 0-100 and last-50,last
        const int n_lines_begin = 100;
        const int n_lines_end = 50;
        if (static_cast<int>(lines_text.size() > n_lines_begin + n_lines_end))
        {
          std::vector<std::string> lines_shorter;
          std::copy(lines_text.begin(),lines_text.begin() + n_lines_begin,std::back_inserter(lines_shorter));
          lines_shorter.push_back("[...]");
          std::copy(lines_text.end() - n_lines_end,lines_text.end(),std::back_inserter(lines_shorter));
          std::swap(lines_shorter,lines_text);
        }
      }
      const auto lines_html = Replacer().ToHtml(lines_text,file_type);
      std::transform(lines_html.begin(),lines_html.end(),std::back_inserter(v),
        [](const std::string& s)
        {
          return s + "<br/>";
        }
      );
    }

    //Remove empty lines
    while (v.back() == "<br/>") v.pop_back();
    assert(v.back()!="<br/>");

    //Add end of code and and end of page
    v.push_back("</code></td></tr></table>");
    v.push_back("<!-- end of the code -->");
  }
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  return v;
}

#ifndef NDEBUG
void ribi::c2h::File::Test() noexcept
{
  {
    static bool is_tested{false};
    if (is_tested) return;
    is_tested = true;
  }
  ribi::fileio::FileIo();
  Replacer();
  const TestTimer test_timer(__func__,__FILE__,1.0);
}
#endif

 

 

 

 

 

./CppCodeToHtml/codetohtmlfiletype.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLFILETYPE_H
#define CODETOHTMLFILETYPE_H

namespace ribi {
namespace c2h {

///The type of file
enum class FileType
{
  cpp,          //.cpp file
  foam,         //OpenFOAM file, extensionless file
  license_txt,  //license.txt file
  png,          //.png image file
  pri,          //.pri file
  pro,          //.pro file
  py,           //.py file
  sh,           //.sh file
  txt,          //.txt file, to be renamed to txt
  n_types       //Used for debugging
};

} //~namespace c2h
} //~namespace ribi

#endif // CODETOHTMLFILETYPE_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlfiletypes.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLFILETYPES_H
#define CODETOHTMLFILETYPES_H

#include <string>
#include <vector>

#include "codetohtmlfwd.h"

namespace ribi {
namespace c2h {

///Manages all FileType instances and conversion to std::string
struct FileTypes
{
  FileTypes();
  bool CanStrToFileType(const std::string& s) const noexcept;

  ///Deduce the content type from a filename
  FileType DeduceFileType(const std::string& filename) const noexcept;

  std::string FileTypeToStr(const FileType t) const noexcept;
  std::vector<FileType> GetAllFileTypes() const noexcept;
  FileType StrToFileType(const std::string& s) const noexcept;

  private:
  #ifndef NDEBUG
  static void Test() noexcept;
  #endif
};

} //~namespace ribi
} //~namespace c2h

#endif // CODETOHTMLFILETYPES_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlfiletypes.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#include "codetohtmlfiletypes.h"

#include <cassert>
#include <stdexcept>

#include <boost/xpressive/xpressive.hpp>

#include "codetohtmlfiletype.h"
#include "testtimer.h"
#include "trace.h"
#pragma GCC diagnostic pop

ribi::c2h::FileTypes::FileTypes()
{
  #ifndef NDEBUG
  Test();
  #endif
}

bool ribi::c2h::FileTypes::CanStrToFileType(const std::string& s) const noexcept
{
  try
  {
    StrToFileType(s);
    return true;
  }
  catch (std::logic_error&)
  {
    return false;
  }
}

ribi::c2h::FileType ribi::c2h::FileTypes::DeduceFileType(const std::string& filename) const noexcept
{
  boost::xpressive::smatch what;

  if( boost::xpressive::regex_match( filename, what,
    boost::xpressive::sregex::compile( ".*\\.(png)\\>") ) )
  {
    return FileType::png;
  }
  if( boost::xpressive::regex_match( filename, what,
    boost::xpressive::sregex::compile( ".*\\.(pri)\\>") ) )
  {
    return FileType::pri;
  }
  if( boost::xpressive::regex_match( filename, what,
    boost::xpressive::sregex::compile( ".*\\.(pro)\\>") ) )
  {
    return FileType::pro;
  }
  else if( boost::xpressive::regex_match( filename, what,
    boost::xpressive::sregex::compile( ".*\\.(c|cpp|h|hpp)\\>") ) )
  {
    return FileType::cpp;
  }
  else if( boost::xpressive::regex_match( filename, what,
    boost::xpressive::sregex::compile( ".*\\.(sh)\\>") ) )
  {
    return FileType::sh;
  }
  else if(filename == "Licence.txt" || filename == "License.txt")
  {
    return FileType::license_txt;
  }
  else if( boost::xpressive::regex_match( filename, what,
    boost::xpressive::sregex::compile( ".*\\.(txt)\\>") ) )
  {
    return FileType::txt;
  }
  else if( boost::xpressive::regex_match( filename, what,
    boost::xpressive::sregex::compile( ".*\\.(py)\\>") ) )
  {
    return FileType::py;
  }
  //return FileType::other;
  return FileType::txt;
}

std::string ribi::c2h::FileTypes::FileTypeToStr(const FileType t) const noexcept
{
  switch (t)
  {
    case FileType::cpp: return "cpp";
    case FileType::foam: return "foam";
    case FileType::license_txt: return "license_txt";
    case FileType::png: return "png";
    case FileType::pri: return "pri";
    case FileType::pro: return "pro";
    case FileType::py: return "py";
    case FileType::sh: return "sh";
    case FileType::txt: return "txt";
    case FileType::n_types:
      assert(!"Should never use FileType::n_types");
      throw std::logic_error("Must never use FileType::n_types");
  }
  assert(!"Should not get here");
  throw std::logic_error("c2h::FileTypeToStr");
}

std::vector<ribi::c2h::FileType> ribi::c2h::FileTypes::GetAllFileTypes() const noexcept
{
  const std::vector<FileType> v {
    FileType::cpp,
    FileType::foam,
    FileType::license_txt,
    FileType::png,
    FileType::pri,
    FileType::pro,
    FileType::py,
    FileType::sh,
    FileType::txt
  };
  assert(static_cast<int>(v.size()) == static_cast<int>(FileType::n_types));
  return v;
}

ribi::c2h::FileType ribi::c2h::FileTypes::StrToFileType(const std::string& s) const noexcept
{
  if (s == "cpp") return FileType::cpp;
  if (s == "foam") return FileType::foam;
  if (s == "license_txt") return FileType::license_txt;
  if (s == "png") return FileType::png;
  if (s == "pri") return FileType::pri;
  if (s == "pro") return FileType::pro;
  if (s == "py") return FileType::py;
  if (s == "sh") return FileType::sh;
  if (s == "txt") return FileType::txt;
  if (s == "n_types")
  {
    assert(!"Should not use FileType::n_types");
    throw std::logic_error("Must not use FileType::n_types");
  }
  assert(!"StrToFileType: should not get here");
  throw std::logic_error("Invalid string in StrToFileType");
}

#ifndef NDEBUG
void ribi::c2h::FileTypes::Test() noexcept
{
  {
    static bool is_tested{false};
    if (is_tested) return;
    is_tested = true;
  }
  const TestTimer test_timer(__func__,__FILE__,1.0);
  FileTypes f;
  //Test conversion between
  {
    const auto v = f.GetAllFileTypes();
    for (const auto& t:v)
    {
      assert(f.StrToFileType(f.FileTypeToStr(t)) == t);
    }
  }
  //Be gentle
  assert(f.DeduceFileType("tmp.png") == FileType::png);
  assert(f.DeduceFileType("tmp.pro") == FileType::pro);
  assert(f.DeduceFileType("tmp.c"  ) == FileType::cpp);
  assert(f.DeduceFileType("tmp.cpp") == FileType::cpp);
  assert(f.DeduceFileType("tmp.h"  ) == FileType::cpp);
  assert(f.DeduceFileType("tmp.hpp") == FileType::cpp);
  assert(f.DeduceFileType("tmp.sh" ) == FileType::sh);
  assert(f.DeduceFileType("tmp.txt") == FileType::txt);
  assert(f.DeduceFileType("tmp.py" ) == FileType::py);
  assert(f.DeduceFileType("tmp.xyz") == FileType::txt);
  //Be nasty
  assert(f.DeduceFileType("cpp.pro") == FileType::pro);
  assert(f.DeduceFileType("h.c"    ) == FileType::cpp);
  assert(f.DeduceFileType("hpp.cpp") == FileType::cpp);
  assert(f.DeduceFileType("sh.h"   ) == FileType::cpp);
  assert(f.DeduceFileType("txt.hpp") == FileType::cpp);
  assert(f.DeduceFileType("py.sh"  ) == FileType::sh);
  assert(f.DeduceFileType("xyz.txt") == FileType::txt);
  assert(f.DeduceFileType("pro.py" ) == FileType::py);
  assert(f.DeduceFileType("c.xyz"  ) == FileType::txt);
}
#endif

 

 

 

 

 

./CppCodeToHtml/codetohtmlfoldertype.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLFOLDERTYPE_H
#define CODETOHTMLFOLDERTYPE_H

namespace ribi {
namespace c2h {

///The type of folder content
enum class FolderType
{
  foam, ///an OpenFOAM project
  pro,  ///a Qt Creator project
  txt   ///a collection of text files
};

} //~namespace ribi
} //~namespace c2h

#endif // CODETOHTMLFOLDERTYPE_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlfoldertypes.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLFOLDERTYPES_H
#define CODETOHTMLFOLDERTYPES_H

#include <string>
#include "codetohtmlfwd.h"

namespace ribi {
namespace c2h {


struct FolderTypes
{
  static FolderType DeduceFolderType(const std::string& folder_name);
};

} //~namespace ribi
} //~namespace c2h

#endif // CODETOHTMLFOLDERTYPES_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlfoldertypes.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmlfoldertypes.h"

#include <cassert>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#include <boost/xpressive/xpressive.hpp>

#include "fileio.h"
#include "trace.h"
#include "codetohtmlfoldertype.h"
#pragma GCC diagnostic pop

ribi::c2h::FolderType ribi::c2h::FolderTypes::DeduceFolderType(const std::string& folder_name)
{
  assert(fileio::FileIo().IsFolder(folder_name));

  const std::vector<std::string> files {
    fileio::FileIo().GetFilesInFolder(folder_name)
  };

  //Search for pro or cppfiles
  {
    //Copy all filenames matching the regex in the resulting std::vector
    const int n_pro_files {
      std::count_if(files.begin(),files.end(),
        [](const std::string& s)
        {
          static const boost::xpressive::sregex pro_file_regex {
            boost::xpressive::sregex::compile(".*\\.(pro)\\>")
          };
          boost::xpressive::smatch what;
          return boost::xpressive::regex_match(s, what, pro_file_regex);
        }
      )
    };
    const int n_cpp_files {
      std::count_if(files.begin(),files.end(),
        [](const std::string& s)
        {
          static const boost::xpressive::sregex cpp_file_regex {
            boost::xpressive::sregex::compile(".*\\.(cpp)\\>")
          };
          boost::xpressive::smatch what;
          return boost::xpressive::regex_match(s, what, cpp_file_regex);
        }
      )
    };
    if (n_pro_files + n_cpp_files > 0) return FolderType::pro;
  }

  //Search for foam files
  {
    //Copy all filenames matching the regex in the resulting std::vector
    const int n_foam_files {
      std::count_if(files.begin(),files.end(),
        [](const std::string& s)
        {
          static const boost::xpressive::sregex foam_file_regex {
            boost::xpressive::sregex::compile(".*\\.(foam)\\>")
          };
          boost::xpressive::smatch what;
          return boost::xpressive::regex_match(s, what, foam_file_regex);
        }
      )
    };
    if (n_foam_files > 0) return FolderType::foam;
  }
  return FolderType::txt;
}

 

 

 

 

 

./CppCodeToHtml/codetohtmlfooter.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLFOOTER_H
#define CODETOHTMLFOOTER_H

#include <string>
#include <vector>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#include "codetohtmlfootertype.h"
#pragma GCC diagnostic pop

namespace ribi {
namespace c2h {

///Defines the header of the resulting HTML page
struct Footer
{
  static std::vector<std::string> ToHtml(const FooterType page_type) noexcept;
  static std::vector<std::string> ToMarkdown(const FooterType page_type) noexcept;

  //private:
  //~Footer() noexcept {}
  //friend void boost::checked_delete<>(Footer*);
  //friend void boost::checked_delete<>(const Footer*);
};

} //~namespace c2h
} //~namespace ribi

#endif // CODETOHTMLFOOTER_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlfooter.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmlfooter.h"

#include <cassert>

std::vector<std::string> ribi::c2h::Footer::ToHtml(const FooterType page_type) noexcept
{
  #ifndef NDEBUG
  //Test();
  #endif
  std::vector<std::string> v;
  switch (page_type)
  {
    case FooterType::cpp:
      v.push_back("<p><a href=\"Cpp.htm\">Go back to Richel Bilderbeek's C++ page</a>.</p>");
      break;
    case FooterType::foam:
      v.push_back("<p><a href=\"ToolOpenFoam.htm\">Go back to Richel Bilderbeek's OpenFOAM page</a>.</p>");
      break;
  }
  v.push_back("<p><a href=\"index.htm\">Go back to Richel Bilderbeek's homepage</a>.</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p><a href=\"http://validator.w3.org/check?uri=referer\"><img src=\"valid-xhtml10.png\" alt=\"Valid XHTML 1.0 Strict\" height=\"31\" width=\"88\" /></a></p>");
  v.push_back("<p>This page has been created by the <a href=\"Tools.htm\">tool</a> <a href=\"ToolCodeToHtml.htm\">CodeToHtml</a></p>");
  v.push_back("</body>");
  v.push_back("</html>");
  return v;
}

std::vector<std::string> ribi::c2h::Footer::ToMarkdown(const FooterType /*page_type*/) noexcept
{
  #ifndef NDEBUG
  //Test();
  #endif
  std::vector<std::string> v;
  return v;
}

 

 

 

 

 

./CppCodeToHtml/codetohtmlfootertype.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLFOOTERTYPE_H
#define CODETOHTMLFOOTERTYPE_H

namespace ribi {
namespace c2h {

enum class FooterType
{
  cpp, //C++
  foam //OpenFOAM
};

} //~namespace c2h
} //~namespace ribi

#endif // CODETOHTMLFOOTERTYPE_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlfwd.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLFWD_H
#define CODETOHTMLFWD_H

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#pragma GCC diagnostic pop

namespace ribi {
namespace c2h {

struct Dialog;
struct File;
enum class FileType;
enum class FolderType;
enum class SnippetType;
struct Replacements;
struct Replacer;


} //~namespace ribi
} //~namespace c2h

#endif // CODETOHTMLFWD_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlheader.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLHEADER_H
#define CODETOHTMLHEADER_H

#include <string>
#include <vector>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
//#include <boost/checked_delete.hpp>

#include "codetohtmlheadertype.h"
#pragma GCC diagnostic pop

namespace ribi {
namespace c2h {

///Defines the header of the resulting HTML page
struct Header
{
  ///Convert this header to HTML
  static std::vector<std::string> ToHtml(
    const HeaderType header_type,
    const std::string& filename
    ) noexcept;

  static std::vector<std::string> ToMarkdown(
    const HeaderType header_type,
    const std::string& filename
    ) noexcept;

  ///Obtain the HTML page its filename
  //const std::string& GetFilename() const { return m_filename; }

  ///Obtain the HTML page its filename
  //HeaderType GetHeaderType() const { return m_header_type; }

  private:
  Header() = delete;
  //~Header() noexcept {}
  //friend void boost::checked_delete<>(Header*);
  //friend void boost::checked_delete<>(const Header*);

  static std::string CreateFilename(
    const HeaderType page_type,
    const std::string& filename);

  static std::string CreateTitle(
    const HeaderType page_type,
    const std::string& filename);
};

} //~namespace c2h
} //~namespace ribi

#endif // CODETOHTMLHEADER_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlheader.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#include "codetohtmlheader.h"

#include <cassert>
#include <stdexcept>

#include "codetohtml.h"
#include "fileio.h"

std::string ribi::c2h::Header::CreateFilename(
  const HeaderType page_type,
  const std::string& filename_original)
{
  if (filename_original.empty())
  {
    switch (page_type)
    {
      case HeaderType::cpp:   return "Cpp.htm";
      //case HeaderType::music: return "SongXXX.htm";
      //case HeaderType::text:  return "CppXXX.htm";
      case HeaderType::foam:  return "ToolOpenFoam.htm";
    }
    assert(!"Should not get here");
    throw std::logic_error("ribi::c2h::Header::CreateFilename");
  }
  else
  {
    assert(!filename_original.empty());
    return ribi::fileio::FileIo().GetFileBasename(filename_original) + ".htm";
  }
}

std::string ribi::c2h::Header::CreateTitle(
  const HeaderType page_type,
  const std::string& filename)
{
  if (filename.empty())
  {
    switch (page_type)
    {
      case HeaderType::cpp:
      case HeaderType::foam:
        return filename;
    }
    assert(!"Should not get here");
    throw std::logic_error("ribi::c2h::Header::CreateTitle");
  }
  else
  {
    assert(!filename.empty());
    std::string s = ribi::fileio::FileIo().GetFileBasename(filename);
    int chars_to_strip = 0;
    if (s.size() > 3 && s.substr(0,3) == "Cpp") chars_to_strip = 3;
    else if (s.size() > 4 && s.substr(0,4) == "Song") chars_to_strip = 4;
    else if (s.size() > 4 && s.substr(0,4) == "Tool") chars_to_strip = 4;
    else if (s.size() > 7 && s.substr(0,7) == "Project") chars_to_strip = 7;
    return s.substr(chars_to_strip,s.size() - chars_to_strip);
  }
}

std::vector<std::string> ribi::c2h::Header::ToHtml(
  const HeaderType header_type,
  const std::string& filename
  ) noexcept
{
  const std::string m_filename { CreateFilename(header_type,filename) };
  const std::string m_title { CreateTitle(header_type,filename) };

  std::vector<std::string> v;
  v.push_back("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"");
  v.push_back("\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">");
  v.push_back("<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"en\" xml:lang=\"en\">");
  v.push_back("<head>");
  v.push_back("  <meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\"/>");
  switch (header_type)
  {
    //case HeaderType::text:
    case HeaderType::cpp:
      v.push_back("  <title>" + m_title + "</title>");
      v.push_back("  <meta name=\"description\" content=\"C++ " + m_title + "\"/>");
      v.push_back("  <meta name=\"keywords\" content=\"C++ " + m_title + " \"/>");
    break;
    case HeaderType::foam:
      v.push_back("  <title>" + m_title + "</title>");
      v.push_back("  <meta name=\"description\" content=\"OpenFOAM " + m_title + "\"/>");
      v.push_back("  <meta name=\"keywords\" content=\"OpenFOAM " + m_title + " \"/>");
    break;
  }
  v.push_back("  <link rel=\"stylesheet\" href=\"Richelbilderbeek.css\" type=\"text/css\"/>");
  v.push_back("</head>");
  v.push_back("<!-- End of head, start of body -->");
  v.push_back("<body>");
  v.push_back("<p><a href=\"index.htm\">Go back to Richel Bilderbeek's homepage</a>.</p>");
  switch (header_type)
  {
    case HeaderType::cpp:
      v.push_back("<p><a href=\"Cpp.htm\">Go back to Richel Bilderbeek's C++ page</a>.</p>");
      break;
    case HeaderType::foam:
      v.push_back("<p><a href=\"ToolOpenFoam.htm\">Go back to Richel Bilderbeek's OpenFOAM page</a>.</p>");
      break;
  }
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<p>&nbsp;</p>");
  v.push_back("<!-- Page header -->");

  switch (header_type)
  {
    case HeaderType::cpp:
      v.push_back("<h1>(<a href=\"Cpp.htm\">C++</a>) <a href=\"" + m_filename + "\">" + m_title + "</a></h1>");
      break;
    case HeaderType::foam:
      v.push_back("<h1>(<a href=\"ToolOpenFoam.htm\">OpenFOAM</a>) <a href=\"" + m_filename + "\">" + m_title + "</a></h1>");
      break;
  }
  v.push_back("<p>&nbsp;</p>");
  return v;
}

std::vector<std::string> ribi::c2h::Header::ToMarkdown(
  const HeaderType header_type,
  const std::string& filename
  ) noexcept
{
  const std::string m_filename { CreateFilename(header_type,filename) };
  const std::string m_title { CreateTitle(header_type,filename) };

  std::vector<std::string> v;
  switch (header_type)
  {
    //case HeaderType::text:
    case HeaderType::cpp:
    case HeaderType::foam:
      v.push_back(m_title);
      v.push_back(std::string(m_title.size(),'='));
    break;
  }
  /*
  switch (header_type)
  {
    case HeaderType::cpp:
      v.push_back("<h1>(<a href=\"Cpp.htm\">C++</a>) <a href=\"" + m_filename + "\">" + m_title + "</a></h1>");
      break;
    case HeaderType::foam:
      v.push_back("<h1>(<a href=\"ToolOpenFoam.htm\">OpenFOAM</a>) <a href=\"" + m_filename + "\">" + m_title + "</a></h1>");
      break;
  }
  v.push_back("<p>&nbsp;</p>");
  */
  return v;
}

 

 

 

 

 

./CppCodeToHtml/codetohtmlheadertype.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLHEADERTYPE_H
#define CODETOHTMLHEADERTYPE_H

namespace ribi {
namespace c2h {

enum class HeaderType
{
  cpp,
  foam
};

} //~namespace c2h
} //~namespace ribi

#endif // CODETOHTMLHEADERTYPE_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlinfo.h

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#ifndef CODETOHTMLINFO_H
#define CODETOHTMLINFO_H

#include <map>
#include <string>
#include <vector>
#include <boost/checked_delete.hpp>
#include <boost/scoped_ptr.hpp>

#include "codetohtml.h"

namespace ribi {
namespace c2h {

///Defines the info of the resulting HTML page
///Info is a heavy class due to the map connecting a page name and its info
struct Info
{
  explicit Info();
  Info(const Info&) = delete;
  Info& operator=(const Info&) = delete;

  static std::string GetVersion() noexcept;
  static std::vector<std::string> GetVersionHistory() noexcept;

  static void TestIfAllCreatedPagesAreValid() noexcept;

  std::vector<std::string> ToHtml(const std::string page_name) const;

  private:
  ~Info() noexcept {}
  friend void boost::checked_delete<>(Info*);
  friend void boost::checked_delete<>(const Info*);

  ///For every page name (the key), contains the HTML info (the value)
  const std::map<std::string,std::vector<std::string> > m_page_info;

  ///Create, for every page name (the key), the HTML info (the value)
  ///The purpose of this is to be able to check every HTML info
  ///for validity
  static std::map<std::string,std::vector<std::string> > CreatePageInfo();

  //From http://www.richelbilderbeek.nl/CppGetTime.htm
  static std::string GetTime() noexcept;

  #ifndef NDEBUG
  static void Test() noexcept;
  #endif


};

} //~namespace c2h
} //~namespace ribi

#endif // CODETOHTMLINFO_H

 

 

 

 

 

./CppCodeToHtml/codetohtmlinfo.cpp

 

//---------------------------------------------------------------------------
/*
CodeToHtml, converts C++ code to HTML
Copyright (C) 2010-2015 Richel Bilderbeek

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/ToolCodeToHtml.htm
//---------------------------------------------------------------------------
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
#include "codetohtmlinfo.h"

#include <cassert>
#include <ctime>

#include <boost/lexical_cast.hpp>

#include "codetohtmlheader.h"
#include "codetohtmlfooter.h"
#include "testtimer.h"
#include "trace.h"
#pragma GCC diagnostic pop

ribi::c2h::Info::Info()
  : m_page_info(CreatePageInfo())
{
  #ifndef NDEBUG
  Test();
  #endif
  //{
  //  const std::string s = "CodeToHtml info pages: "
  //  + boost::lexical_cast<std::string>(m_page_info.size());
  //  TRACE(s);
  //}
}

std::map<std::string,std::vector<std::string> > ribi::c2h::Info::CreatePageInfo()
{
  //Do not create this map from a single huge initializer list: the compiler will choke on it after about 5000 lines
  typedef std::string Key;
  typedef std::vector<std::string> Value;
  typedef std::pair<Key,Value> Pair;
  std::vector<Pair> m;

  // sed -i "s/^.*$/       R\"\(&\)\"\,/g" tmp.txt



/*

CppCfileExample1
CppChess
CppChessResources
CppClnExample1
CppClnExample2
CppCodeBreaker
CppCodeToHtml
CppCompileErrorParseErrorAtBOOST_JOIN
CppConceptExample1
CppConceptMap
CppConioExample1
CppConioExample2
CppConnectThree
CppConnectThreeWidget
CppConstExample1
CppConstExample2
CppConstExample3
CppConstExample4
CppConstexprExample1
CppContainer
CppCoordinat
CppCopyFile
CppCopy_if
CppCopyUnique
CppCounter
CppCreateArgv
CppCreateHistogram
CppCreateRandomString
CppDecltypeExample1
CppDecltypeExample2
CppDeleteExample1
CppDestructorExample1
CppDestructorExample2
CppDial
CppDialWidget
CppDnaR
CppDnaSequence
CppDotMatrix
CppDrawCanvas
CppDynamic_castExample1
CppDynamic_castExample2
CppEncranger
CppEnumClassExample1
CppEuclideanVector
CppExercise
CppExerciseAddOneAnswerGprof
CppExerciseAddOneAnswerShiny
CppExerciseAddOneToArray
CppExerciseDivideAnswer
CppFastaFile
CppFileIo
CppFilesAreIdentical
CppFinalExample1
CppFinalExample2
CppFisherWrightSimulationExample1
CppFisherWrightSimulationExample2
CppForExample1
CppFuzzy_equal_to
CppFwdppExample1
CppGaborFilter
CppGaborFilterWidget
CppGcovExample1
CppGeometry
CppGetCombinations
CppGetDateIso8601
CppGetDecimalSeperator
CppGetExtension
CppGetFileBasename
CppGetFilesInFolder
CppGetFilesInFolderRecursive
CppGetFoldersInFolder
CppGetKeyWithMaxValue
CppGetMaxDouble
CppGetMaxFloat
CppGetMaxInt
CppGetPath
CppGetPermutations
CppGetRandomNormal
CppGetRandomNormalBoost
CppGetRandomUniform
CppGetRandomUniform98
CppGetRegexMatches
CppGetSmallestDouble
CppGetSmallestFloat
CppGetTime
CppGetToday
CppGetTxtFilesInFolder
CppGmockExample1
CppGmtlExample1
CppGnuplotInterface
CppGprofQtCreatorExample1
CppGprofQtCreatorExample2
CppGrabber
CppGslExample1
CppHeaderFileExample1
CppHelloBoostLexical_CastQt5QtCreatorLubuntuToWindows
CppHelloBoostLexical_CastQtCreatorLubuntu
CppHelloBoostLexical_CastQtCreatorLubuntuToWindows
CppHelloBoostLexical_CastQtCreatorSliTaz
CppHelloBoostRegexQt5QtCreatorLubuntuToWindows
CppHelloBoostRegexQtCreatorCygwin
CppHelloBoostRegexQtCreatorLubuntu
CppHelloBoostRegexQtCreatorLubuntuToWindows
CppHelloBoostRegexQtCreatorSliTaz
CppHelloBoostRegexQtCreatorUbuntu
CppHelloBoostRegexQtCreatorWindows
CppHelloBoostSignals2QtCreatorLubuntu
CppHelloBoostSignalsQtCreatorLubuntu
CppHelloBoostUblasQtCreatorLubuntu
CppHelloBoostUblasQtCreatorSliTaz
CppHelloBoostXpressiveQtCreatorCygwin
CppHelloBoostXpressiveQtCreatorLubuntu
CppHelloBoostXpressiveQtCreatorLubuntuToWindows
CppHelloBoostXpressiveQtCreatorSliTaz
CppHelloBoostXpressiveQtCreatorWindows
CppHelloBulletQtCreatorWindows
CppHelloCpp0xQtCreatorLubuntu
CppHelloCpp0xQtCreatorSliTaz
CppHelloCpp11QtCreatorCygwin
CppHelloCpp11QtCreatorLubuntu
CppHelloCpp11QtCreatorLubuntuToWindows
CppHelloCpp11QtCreatorSliTaz
CppHelloCpp11QtCreatorWindows
CppHelloIrrlichtQtCreatorWindows
CppHelloOdeQtCreatorLubuntu
CppHelloOdeWindows
CppHelloQt4QtCreatorLubuntu
CppHelloQt5QtCreatorLubuntu
CppHelloQtQtCreatorCygwin
CppHelloQtQtCreatorLubuntu
CppHelloQtQtCreatorLubuntuToWindows
CppHelloQtQtCreatorUbuntu
CppHelloQtQtCreatorWindows
CppHelloQtQuick2_0Example1
CppHelloQwtQtCreatorCygwin
CppHelloQwtQtCreatorLubuntu
CppHelloQwtQtCreatorLubuntuToWindows
CppHelloQwtQtCreatorWindows
CppHelloTokamakWindows
CppHelloTriangle
CppHelloWorld64QtCreatorLubuntu
CppHelloWorldQt5QtCreatorLubuntuToWindows
CppHelloWorldQtCreatorClangWindows
CppHelloWorldQtCreatorCygwin
CppHelloWorldQtCreatorLubuntu
CppHelloWorldQtCreatorLubuntuToWindows
CppHelloWorldQtCreatorSliTaz
CppHelloWorldQtCreatorUbuntu
CppHelloWorldQtCreatorWindows
CppHelloWtQtCreatorLubuntu
CppHelloWtQtCreatorLubuntuToWindows
CppHelloWtQtCreatorUbuntu
CppHelloWtQtCreatorWindows
CppHelp
CppHfloatExample1
CppHistogram
CppHostClassExample1
CppHostClassExample2
CppHostClassExample3
CppHtmlPage
CppIfExample1
CppImageCanvas
CppImplode
CppInheritanceExample1
CppIntegerFloatingPoint
CppIotaExample1
CppIpAddress
CppIrcBot
CppIrrlichtExample1
CppIsFolder
CppIs_pointer
CppIsPrime
CppIsPrimeMuntendam
CppIsRegularFile
CppIsSubset
CppIteratorExample1
CppKalmanFilter
CppKnokfighterResources
CppLazy_init
CppLed
CppLedWidget
CppLengthInMm
CppLengthInMm
CppLibcvautomationExample1
CppLibcvautomationExample2
CppLibcvautomationExample3
CppLibcvautomationExample4
CppLibcvautomationExample5
CppLibcvautomationExample6
CppLibcvautomationExample7
CppLibsequenceExampleBaseComp
CppLibsequenceExampleBottleneck
CppLinkErrorCannotFindLgstapp
CppLinkErrorUndefinedReferenceToWebCore
CppListExample1
CppLizardPaperRockScissorsSpock
CppLizardPaperRockScissorsSpockSimulation
CppLoopReader
CppMake_array
CppMake_tupleExample1
CppMake_unique
CppManyDigitNewick
CppMapExample1
CppMapToXml
CppMatrix
CppMemberFunctionExample1
CppMemberFunctionExample2
CppMemcheckExample1
CppMemcheckExample2
CppMemcheckExample3
CppMemcheckExample4
CppMemcheckExample5
CppMemcheckExample6
CppMenuDialog
CppMenuOfExecutables
CppMeyersSingletonExample1
CppMoveConstructorExample1
CppMultiApproximator
CppMultiCanvas
CppMultimapExample1
CppMultimapToMap
CppMultipleChoiceQuestion
CppMultipleChoiceQuestionDialog
CppMultipleInheritanceExample1
CppMultiVector
CppMusic
CppMxeExample1
CppMxeExample2
CppMxeExample3
CppMxeExample4
CppMxeExample5
CppMysteryMachine
CppMysteryMachineWidget
CppNamespaceExample1
CppNarrow_cast
CppNcursesExample1
CppNewExample1
CppNewExample2
CppNewick
CppNewickUtils
CppNewick_utilsExample1
CppNewickVector
CppNoexceptExample1
CppOpenFoam
CppOpenQuestion
CppOpenQuestionDialog
CppOperatorStreamOutExample1
CppOrnsteinUhlenbeck
CppOverrideExample1
CppPaperRockScissors
CppPaperRockScissorsSimulation
CppPaperRockScissorsWithTraitSimulation
CppPdcursesExample1
CppPdcursesExample2
CppPdcursesExample3
CppPedigree
CppPedigreeExample1
CppPhp
CppPhylogenyR
CppPimplExample1
CppPimplExample2
CppPlane
CppPolarCoordinat
CppPolyFile
CppPolyFileFromPolygons
CppPositiveNonZeroDouble
CppPredicateExample1
CppPreprocessorSwitchGccVersion
CppPrivateExample1
CppProtectedExample1
CppPtrsToXml
CppPublicExample1
CppPylos
CppQFileDialogExample1
CppQFileDialogExample2
CppQFileDialogExample3
CppQFileDialogExample4
CppQFileExample1
CppQGLWidgetExample1
CppQGLWidgetExample2
CppQGraphicsItemExample1
CppQGraphicsItemExample2
CppQGraphicsObjectDebugging1
CppQGraphicsObjectExample1
CppQGraphicsObjectExample2
CppQGraphicsObjectExample3
CppQGraphicsPixmapItemExample1
CppQGraphicsPixmapItemExample2
CppQGraphicsPixmapItemExample3
CppQGraphicsPixmapItemExample4
CppQGraphicsPixmapItemExample5
CppQGraphicsPixmapItemExample6
CppQGraphicsPixmapItemExample7
CppQGraphicsPolygonItemExample1
CppQGraphicsPolygonItemExample2
CppQGraphicsRectItemExample1
CppQGraphicsRectItemExample2
CppQGraphicsRectItemExample3
CppQGraphicsRectItemExample4
CppQGraphicsRectItemExample5
CppQGraphicsRectItemExample6
CppQGraphicsSceneExample1
CppQGraphicsSceneExample2
CppQGraphicsSimpleTextItemExample1
CppQGraphicsSimpleTextItemExample2
CppQGraphicsSimpleTextItemExample3
CppQGraphicsSimpleTextItemExample4
CppQGraphicsSimpleTextItemExample5
CppQGraphicsSimpleTextItemExample6
CppQGraphicsSimpleTextItemExample7
CppQGraphicsSimpleTextItemExample8
CppQGraphicsSvgItemExample1
CppQGraphicsSvgItemExample2
CppQGraphicsSvgItemExample3
CppQGraphicsSvgItemExample4
CppQGraphicsViewExample1
CppQGraphicsViewExample2
CppQGraphicsViewExample3
CppQGraphicsWebViewExample1
CppQImageExample1
CppQImageExample2
CppQImageExample3
CppQListWidgetExample1
CppQListWidgetExample2
CppQListWidgetExample3
CppQListWidgetExample4
CppQmakeDefinesExample1
CppQmakeErrorUnknownModulesInQtLocationSensors
CppQmakeExample1
CppQMenuExample1
CppQmlClaudioExample
CppQmlExample
CppQmlExample1
CppQmlExample2
CppQmlExample3
CppQPainterExample1
CppQPixmapExample1
CppQPrintDialogExample1
CppQPrinterExample1
CppQPrinterExample2
CppQrcFile
CppQSerialPortExample1
CppQSerialPortExample1Cpp98
CppQSerialPortExample2
CppQSerialPortExample2Cpp98
CppQSqlTableModelExample1
CppQSqlTableModelExample2
CppQSqlTableModelExample3
CppQSvgWidgetExample1
CppQTableViewExample1
CppQTableViewExample10
CppQTableViewExample2
CppQTableViewExample3
CppQTableViewExample4
CppQTableViewExample5
CppQTableViewExample6
CppQTableViewExample7
CppQTableViewExample8
CppQTableViewExample9
CppQTableWidgetExample1
CppQTableWidgetExample2
CppQTableWidgetExample3
CppQtAboutDialog
CppQtArrowItem
CppQtAutoResizeListWidget
CppQtBeastDisplay
CppQtBirthDeathModel
CppQtBrownianMotion
CppQtCanvas
CppQtChess
CppQtClickableImage
CppQtConceptMap
CppQtConnectThreeWidget
CppQtCreator_5_1
CppQtCreatorProFile
CppQtDialWidget
CppQtDisplayPosItem
CppQtDnaSequencesDialog
CppQtDnaSequencesDisplay
CppQtDotMatrix
CppQtExample1
CppQtExample10
CppQtExample11
CppQtExample12
CppQtExample13
CppQtExample14
CppQtExample15
CppQtExample16
CppQtExample17
CppQtExample18
CppQtExample19
CppQtExample2
CppQtExample20
CppQtExample21
CppQtExample22
CppQtExample23
CppQtExample24
CppQtExample25
CppQtExample26
CppQtExample27
CppQtExample28
CppQtExample29
CppQtExample3
CppQtExample30
CppQtExample31
CppQtExample32
CppQtExample33
CppQtExample34
CppQtExample35
CppQtExample36
CppQtExample4
CppQtExample5
CppQtExample6
CppQtExample7
CppQtExample8
CppQtExample9
CppQtExercise
CppQtGaborFilterWidget
CppQtGraphExample1
CppQtGraphExample2
CppQtGraphExample3
CppQtGraphExample4
CppQtGraphExample5
CppQtGraphExample6
CppQtGraphExample7
CppQtGraphExample8
CppQtGraphics
CppQtHideAndShowDialog
CppQtImage
CppQtKeyboardFriendlyGraphicsView
CppQtLabeledQuadBezierArrowItem
CppQtLed
CppQtLedDisplayWidget
CppQtLedWidget
CppQtLeftRightRectItem
CppQtLizardPaperRockScissorsSpockSimulation
CppQtMatrix
CppQtModel
CppQtMultipleChoiceQuestionDialog
CppQtMysteryMachineWidget
CppQtNavigationableGraphicsView
CppQtNewickDisplay
CppQToolBoxExample1
CppQToolBoxExample2
CppQtOpenQuestionDialog
CppQtOrnsteinUhlenbeck
CppQtPaperRockScissorsSimulation
CppQtPaperRockScissorsWithTraitSimulation
CppQtPathArrowItem
CppQtPylos
CppQtQuadBezierArrowItem
CppQtQuestionDialog
CppQTreeViewExample1
CppQTreeViewExample2
CppQTreeViewExample3
CppQTreeViewExample4
CppQtReversi
CppQtRichelBilderbeekGalleryDialog
CppQtRichelBilderbeekProgram
CppQtRoundedEditRectItem
CppQtRoundedRectItem
CppQtRubiksClockWidget
CppQtScaleItem
CppQtScopedDisable
CppQtShapeWidget
CppQtShinyButtonWidget
CppQtSignalExample1
CppQtSignalExample2
CppQtSignalExample3
CppQtSprites
CppQtSqlExample1
CppQtStateObserver
CppQtSurfacePlotWidget
CppQtTicTacToeWidget
CppQtToggleButtonWidget
CppQuestion
CppQtQuestionDialog
CppQVector2DExample1
CppQWebViewExample1
CppQwtExample1
CppQwtExample10
CppQwtExample11
CppQwtExample12
CppQwtExample2
CppQwtExample3
CppQwtExample4
CppQwtExample5
CppQwtExample6
CppQwtExample7
CppQwtExample8
CppQwtExample9
CppRainbow
CppRandomCode
CppRangeForExample1
CppRaspberryPi
CppRawCharacterStringExample1
CppRectangle
CppRenameFile
CppReversi
CppRibiApfloat
CppRibiRandom
CppRibiRegex
CppRibiRinside
CppRichelBilderbeekProgram
CppRinsideExample1
CppRinsideExample2
CppRinsideExample3
CppRinsideExample4
CppRpiExample1
CppRpiExample2
CppRpiExample3
CppRubiksClock
CppRubiksClockWidget
CppRuntimeErrorAssertionFailedXpressiveDetailDynamicParse_charset201
CppSeperateString
CppShape
CppShapeWidget
CppShinyButton
CppShinyButtonWidget
CppShinyExample1
CppSimpleLinearRegression
CppSimpleStrategy1
CppSmartPointerExample1
CppSmartPointerExample2
CppSortedBinaryNewickVector
CppSortExample1
CppStackQDialogs
CppStackQWidgets
CppStateObserver
CppStatic_assertExample1
CppStaticLibraryQtCreatorExample1
CppStatus.sh
CppStdAdjacent_differenceExample1
CppStdAdjacent_findExample1
CppStdAll_ofExample1
CppStdArrayExample1
CppStdArrayExample2
CppStdArrayExample3
CppStdBad_function_callExample1
CppStdBad_function_callExample2
CppStdBeginExample1
CppStdBitsetExample1
CppStdBitsetExample2
CppStdBitsetExample3
CppStdBitsetExample4
CppStdBitsetExample5
CppStdDefault_deleteExample1
CppStdDequeExample1
CppStdEnable_ifExample1
CppStdEndExample1
CppStdEqualExample1
CppStdEqualExample2
CppStdEqualExample3
CppStdExceptionExample1
CppStdExponential_distributionExample1
CppStdFgetsExample1
CppStdFgetsExample2
CppStdForward_listExample1
CppStdFunctionExample1
CppStdFunctionExample2
CppStdFunctionExample3
CppStdHigh_resolution_clockExample1
CppStdIfstreamExample1
CppStdInitializer_listExample1
CppStdInitializer_listExample2
CppStdInner_productExample1
CppStdInner_productExample2
CppStdIotaExample1
CppStdIs_compoundExample1
CppStdIs_pointerExample1
CppStdIs_scalarExample1
CppStdIs_sortedExample1
CppStdIs_sorted_untilExample1
CppStdLocaleExample1
CppStdMax_elementExample1
CppStdMemcpyExample1
CppStdMemcpyExample2
CppStdMinmax_elementExample1
CppStdMinmax_elementExample2
CppStdMinmax_elementExample3
CppStdNext_permutationExample1
CppStdNext_permutationExample2
CppStdNormal_distributionExample1
CppStdPartition_copyExample1
CppStdPartitionExample1
CppStdPrintfExample1
CppStdRandExample1
CppStdRandExample2
CppStdRandom_shuffleExample1
CppStdRatioExample1
CppStdRefExample1
CppStdRefExample2
CppStdRemoveExample1
CppStdRenameExample1
CppStdRenameExample2
CppStdSet_differenceExample1
CppStdSetExample1
CppStdSetExample2
CppStdSetExample3
CppStdSetExample4
CppStdSetExample5
CppStdSetExample6
CppStdSetPrecisionExample1
CppStdShuffleExample1
CppStdSortExample2
CppStdStrcatExample1
CppStdStrchrExample1
CppStdStrcmpExample1
CppStdStrcpyExample1
CppStdStringExample1
CppStdStrlenExample1
CppStdStrncatExample1
CppStdStrncmpExample1
CppStdStrncpyExample1
CppStdSwapExample1
CppStdSwapExample2
CppStdSystem_clockExample1
CppStdSystemExample1
CppStdSystemExample2
CppStdSystemExample3
CppStdTmpnamExample1
CppStdTo_stringExample1
CppStdTr1ArrayExample1
CppStdTupleExample1
CppStdUniform_int_distributionExample1
CppStdUniform_int_distributionExample2
CppStdUniform_real_distributionExample1
CppStdUnique_copyExample1
CppStdUniqueExample1
CppStdUniqueExample2
CppStdUniqueExample3
CppStdUnique_ptrExample1
CppStdUnique_ptrExample2
CppStdVectorExample1
CppStdVectorExample2
CppStdVectorExample3
CppStdVectorExample4
CppStkExample1
CppStkExample2
CppStopwatch
CppStringLiteralExample1
CppStrToXml
CppSwitchExample1
CppSymbolicCppExample1
CppSymbolicCppExample2
CppSymbolicCppExample3
CppTemplateClassExample1
CppTemplateClassExample2
CppTemplateClassExample3
CppTemplateClassExample4
CppTemplateClassExample5
CppTemplateClassExample6
CppTemplateClassExample7
CppTemplateClassExample8
CppTemplateFunctionExample1
CppTemplateFunctionExample2
CppTemplateFunctionExample3
CppTemplateFunctionExample4
CppTemplateFunctionExample5
CppTempLocale
CppTestTimer
CppTextCanvas
CppTicTacToe
CppTieExample1
CppToggleButton
CppToggleButtonWidget
CppToXml
CppTrace
CppTriangleFile
CppTriangleMesh
CppTribool
CppTwoDigitNewick
CppTypeidExample1
CppTypeidExample2
CppUblasMatrixExample1
CppUnits
CppUnsignedExample1
CppUrho3dExample1
CppUrho3dExample2
CppUrho3dExample3
CppUrho3dExample4
CppVectorToXml
CppVigenereCipher
CppVirtualBastard
CppVirtualExample1
CppWidget
CppWilcoxonsSignedRankTest
CppWordwrap
CppWtAboutDialog
CppWtAutoConfig
CppWtAutoRun
CppWtBroadcastServer
CppWtChess
CppWtConnectThreeWidget
CppWtDialWidget
CppWtEntrance
CppWtExercise
CppWtGetIpAddress
CppWtGetIpAddress
CppWtGroupWidget
CppWtLedDisplayWidget
CppWtLedWidget
CppWtMultipleChoiceQuestionDialog
CppWtMysteryMachineWidget
CppWtOpenQuestionDialog
CppWtQuestionDialog
CppWtRichelBilderbeekGalleryDialog
CppWtRubiksClockWidget
CppWtSafeTimer
CppWtSelectFileDialog
CppWtServerPusher
CppWtShapeGroupWidget
CppWtShapeWidget
CppWtShinyButtonWidget
CppWtTicTacToeWidget
CppWtTimedServerPusher
CppWtToggleButtonWidget
CppWtWidgetsWidget
CppXml
CppYodaConditionExample1
CygwinStatus.sh
GameBeerWanter
GameBoenken
GameConnectThree
GameDasWahreSchlagerfest
GameEverythingToPiecesShooter
GameK3OpEenRij
GameMaziak
GamePong
GamePylos
GameReversi
GameRubiksClock
GameSearchAndDestroyChess
GameTankBattalion
GameTicTacToe
GameTronCollection
GameXeNonZero
GameZero
ProjectBrainweaver
ProjectGtst
ProjectRichelBilderbeek
QmlExampleEditRectItem
QmlExampleQuadBezierLine
SliTazStatus.sh
TestLogicalOrVersusBitwiseOr
ToolApplicationVerifierExample1
ToolApplicationVerifierExample2
ToolAsciiArter
ToolCaesarCipher
ToolCellularAutomatonZero
ToolCodeToHtml
ToolCreateCoalescenceTree
ToolCreateGlossary
ToolCreateQtProjectZipFile
ToolDotMatrix
ToolDrMemoryExample1
ToolDrMemoryExample2
ToolDrMemoryExample3
ToolDrMemoryExample4
ToolEncranger
ToolFilterOperationer
ToolFisherWrighter
ToolFunctionPlotter
ToolGaborFilter
ToolGrayCoder
ToolHistogramEqualizationer
ToolHometrainer
ToolHometrainerExerciseIronCarbonDiagram
ToolHometrainerExerciseMilling
ToolHometrainer_exercises_French
ToolImageRotater
ToolKalmanFilterer
ToolKTouchLectureCreator
ToolLambdaBot
ToolLizardPaperRockScissorsSpock
ToolLogisticGrowthSimulator
ToolMazeCreator
ToolMultiEncranger
ToolMusicTheory
ToolMutualismBreakdowner
ToolOpenFoamErrorFacesNotInTriangularOrder
ToolOpenFoamErrorFacesNotInTriangularOrderRenumberMesh
ToolOpenFoamErrorOpenCellsFound
ToolOpenFoamErrorOpenCellsFoundCorrected
ToolOpenFoamErrorOpenCellsFoundFixed
ToolOpenFoamErrorRhosimplecFoamCrashAtTimestep1SimpleNoConvergenceCriteriaFound
ToolOpenFoamErrorRhosimplefoamCannotFindEquationRelaxationFactorForPeqn
ToolOpenFoamErrorRhosimplefoamCrashTimestep15squareBend
ToolOpenFoamExample1
ToolOpenFoamExample10
ToolOpenFoamExample11
ToolOpenFoamExample12
ToolOpenFoamExample13
ToolOpenFoamExample14
ToolOpenFoamExample15
ToolOpenFoamExample16
ToolOpenFoamExample17
ToolOpenFoamExample18
ToolOpenFoamExample19
ToolOpenFoamExample2
ToolOpenFoamExample20
ToolOpenFoamExample21
ToolOpenFoamExample22
ToolOpenFoamExample23
ToolOpenFoamExample24
ToolOpenFoamExample3
ToolOpenFoamExample4
ToolOpenFoamExample5
ToolOpenFoamExample6
ToolOpenFoamExample7
ToolOpenFoamExample8
ToolOpenFoamExample9
ToolPaperRockScissors
ToolPaperRockScissorsWithTrait
ToolPause
ToolPerfectElasticCollision
ToolPicToCode
ToolPixelator
ToolPreDickAdvocaTor
ToolPrimeExpert
ToolQmakeWatcher
ToolQuadraticSolver
ToolRandomCode
ToolRegexTester
ToolRichelBilderbeekGallery
ToolRichelbilderbeekNlSitemapGenerator
ToolRosindellEtAl2008
ToolSecretMessage
ToolSimMysteryMachine
ToolSimplifyNewick
ToolSimTopPredatorPrey
ToolStaircaseCardCreator
ToolStateObserver
ToolStochasticityInspector
ToolStyleSheetSetter
ToolSumBrownianMotions
ToolSurfacePlotter
ToolTestAbout
ToolTestApproximator
ToolTestBinaryNewickVector
ToolTestBouncingBallsWidget
ToolTestBouncingRectsWidget
ToolTestBroadcastServer
ToolTestChess
ToolTestConceptMap
ToolTestDial
ToolTestDrawCanvas
ToolTestEntrance
ToolTestExercise
ToolTestFunctionParser
ToolTestGnuplotInterface
ToolTestGraphicsProxyWidget
ToolTestGravityWidget
ToolTestGroupWidget
ToolTestHistogram
ToolTestHugeVector
ToolTestImageCanvas
ToolTestLazy_init
ToolTestLed
ToolTestManyDigitNewick
ToolTestMultiApproximator
ToolTestMultiCanvas
ToolTestMultipleChoiceQuestion
ToolTestMultiVector
ToolTestNeuralNet
ToolTestNewick
ToolTestNewickUtils
ToolTestNewickVector


*/

  m.push_back(
    {
      "CppAbcFile",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppAbcFile.htm\">AbcFile</a> is a",
        "<a href=\"CppClass.htm\">class</a> for an ABC music",
        "notation file.</p>"
      }
    }
  );
  m.push_back(
    { "CppAbout",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppAbout.htm\">About</a> is a",
        "<a href=\"CppClass.htm\">class</a> to display information",
        "about a program.</p>"
      }
    }
  );

  m.push_back(
    { "CppAlglibExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppAlglibExample1.htm\">ALGLIB example 1: linear fit</a> is an <a href=\"CppAlglib.htm\">ALGLIB</a> <a href=\"CppExample.htm\">example</a>.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppAlglibExample1.zip\">Download the Qt Creator project 'CppAlglibExample1' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppAlglibExample2",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppAlglibExample2.htm\">ALGLIB example 2: linear fit</a> is an <a href=\"CppAlglib.htm\">ALGLIB</a> <a href=\"CppExample.htm\">example</a>.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppAlglibExample2.zip\">Download the Qt Creator project 'CppAlglibExample2' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppAminoAcid",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppAminoAcid.htm\">AminoAcid</a> contains some <a href=\"CppClass.htm\">classes</a>"
        "  to work with amino acids.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppApfloatExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppApfloatExample1.htm\">Apfloat example 1</a> is an <a href=\"CppApfloat.htm\">apfloat</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppApfloatExample2",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppApfloatExample2.htm\">Apfloat example 2</a> is an <a href=\"CppApfloat.htm\">apfloat</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppApfloatToDouble",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppApfloatToDouble.htm\">ApfloatToDouble</a> is an <a href=\"CppApfloat.htm\">apfloat</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppApfloatToStr",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppApfloatToStr.htm\">ApfloatToStr</a> is an <a href=\"CppApfloat.htm\">apfloat</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppApproximator",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppApproximator.htm\">Approximator</a> is a",
        "  <a href=\"CppClass.htm\">class</a> to perform an interpolation",
        "  on data. For example, when the supplied data consists of the coordinats",
        "  (1,1) and (2,2), it will estimate (the x value of) 1,5 to be (the value y value of) 1,5.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppApproximator.htm\">Approximator</a> does not support multiple",
        "  identical keys (for example the coordinats (1.0,2.0) and (1.0,3.0)),",
        "  similar to a <a href=\"CppMap.htm\">std::map</a>.",
        "  <a href=\"CppMultiApproximator.htm\">MultiApproximator</a> does",
        "  allow this."
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppArduinoExample1",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicArduino.png\" alt=\"Arduino\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArduinoExample1.htm\">Arduino example 1</a> is an <a href=\"CppArduino.htm\">Arduino</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );

  m.push_back(
    { "CppArduinoExample2",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicArduino.png\" alt=\"Arduino\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArduinoExample2.htm\">Arduino example 2</a> is an <a href=\"CppArduino.htm\">Arduino</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );

  m.push_back(
    { "CppArrayExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<h1>(<a href=\"Cpp.htm\">C++</a>) <a href=\"CppArrayExample1.htm\">array/std::array/boost::array example 1: comparison</a></h1>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppArrayExample1.htm\">array/std::array/boost::array example 1: comparison</a>",
        "  is a comparison between",
        "  a plain <a href=\"CppArray.htm\">array</a>, <a href=\"CppStdArray.htm\">std::array</a>,",
        "  <a href=\"CppTr1Array.htm\">std::tr1::array</a> ",
        "  and <a href=\"CppBoostArray.htm\">boost::array</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/> <a href=\"CppArrayExample1.zip\">Download the Qt Creator project 'CppArrayExample1' (zip)</a></li>",
        "  <li><img src=\"PicWindows.png\" alt=\"Windows\"/><a href=\"CppArrayExample1Exe.zip\">Download the Windows executable of 'CppArrayExample1' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>The conclusions draws are (note that every 'Yes' is 'a good thing'):</p>",
        "<p>&nbsp;</p>",
        "<table summary=\"Comparison\" border = \"1\">",
        "  <tr>",
        "    <td>Property tested</td>",
        "    <td>Statically allocated plain array</td>",
        "    <td>Dynamically allocated plain array</td>",
        "    <td><a href=\"CppTr1Array.htm\">std::tr1::array</a></td>",
        "    <td><a href=\"CppStdArray.htm\">std::array</a></td>",
        "    <td><a href=\"CppBoostArray.htm\">boost::array</a></td>",
        "  </tr>",
        "  <tr><td>Initialization at creation</td><td>Yes</td><td>No</td><td>Yes</td><td>Yes</td><td>Yes</td></tr>",
        "  <tr><td>Initialization at creation checked against too few elements</td><td>No</td><td>N/A</td><td>No</td><td>No</td><td>No</td></tr>",
        "  <tr><td>Initialization at creation checked against too many elements</td><td>Yes</td><td>N/A</td><td>Yes</td><td>Yes</td><td>Yes</td></tr>",
        "  <tr><td>Size requestable at compile-time</td><td>Yes</td><td>No</td><td>No</td><td>Yes</td><td>No</td></tr>",
        "  <tr><td>Size requestable at run-time</td><td>Yes</td><td>No</td><td>Yes</td><td>Yes</td><td>Yes</td></tr>",
        "</table>"
      }
    }
  );


  m.push_back(
    { "CppArrayExample2",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArrayExample2.htm\">Array example 2</a> is an <a href=\"CppArray.htm\">array</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );
  m.push_back(
    { "CppArrayExample3",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArrayExample3.htm\">Array example 3</a> is an <a href=\"CppArray.htm\">array</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );

  m.push_back(
    { "CppArrayExample4",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArrayExample4.htm\">Array example 4</a> is an <a href=\"CppArray.htm\">array</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );

  m.push_back(
    { "CppArrayExample5",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArrayExample5.htm\">Array example 5</a> is an <a href=\"CppArray.htm\">array</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );

  m.push_back(
    { "CppArrayExample6",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArrayExample6.htm\">Array example 6</a> is an <a href=\"CppArray.htm\">array</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );

  m.push_back(
    { "CppArray_intersect",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArray_intersect.htm\">Array_intersect</a> is an <a href=\"CppArray.htm\">array</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );

  m.push_back(
    { "CppArray_keys",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArray_keys.htm\">Array_keys</a> is an <a href=\"CppArray.htm\">array</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );
  m.push_back(
    { "CppArray_merge",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArray_merge.htm\">Array_merge</a> is an <a href=\"CppArray.htm\">array</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );
  m.push_back(
    { "CppArray_values",
      {
        "<p>"
        "  <img src=\"PicStl.png\" alt=\"STL\"/>",
        "</p>"
        "<p>&nbsp;</p>",
        "<p><a href=\"CppArray_values.htm\">Array_values</a> is an <a href=\"CppArray.htm\">array</a> <a href=\"CppExample.htm\">example</a>.",
      }
    }
  );

  m.push_back(
    { "CppAsciiArter",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppAsciiArter.htm\">AsciiArter</a> is a",
        "  GUI-independent <a href=\"CppClass.htm\">class</a> to",
        "  <a href=\"CppConvert.htm\">convert</a> images to",
        "  <a href=\"CppAsciiArt.htm\">ASCII art</a>.",
        "</p>"
      }
    }
  );
  m.push_back(
    { "CppAssertExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppAssertExample1.htm\">assert example 1: basics</a> is an <a href=\"CppAssert.htm\">assert</a> <a href=\"CppExample.htm\">example</a>.",
        "<p>&nbsp;</p>",
        "<p>A division will only succeed if the denominator is unequal to zero. ",
        "In your code, you will have to take care that a division by zero never occurs. ",
        "Using <a href=\"CppAssert.htm\">assert</a>, as shown in the code below, will take you to the problem directly.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppAssertExample1.zip\">Download the Qt Creator project 'CppAssertExample1' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppAssertExample2",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppAssertExample2.htm\">assert example 2: basics with informative output</a> is an",
        "  <a href=\"CppAssert.htm\">assert</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppAssertExample2.zip\">Download the Qt Creator project 'CppAssertExample2' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppAssertExample3",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppAssertExample3.htm\">assert example 3: a user-defined assert</a> is an",
        "  <a href=\"CppAssert.htm\">assert</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppAssertExample3.zip\">Download the Qt Creator project 'CppAssertExample3' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppAthleticLandResources",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppAthleticLandResources.htm\">AthleticLandResources</a> contain the resources"
        "  for the game <a href=\"GameAthleticLand.htm\">AthleticLand</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppAutoExample1",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppAutoExample1.htm\">auto example 1: basics</a> is an <a href=\"CppAuto.htm\">auto</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  A division will only succeed if the denominator is unequal to zero.",
        "  In your code, you will have to take care that a division by zero never occurs. ",
        "  Using <a href=\"CppAssert.htm\">assert</a>, as shown in the code below, will take you to the problem directly.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppAssertExample1.zip\">Download the Qt Creator project 'CppAssertExample1' (zip)</a></li>",
        "</ul>"
      }
    }
  );


  m.push_back(
    { "CppBaseClassExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppBaseClassExample1.htm\">base class example 1</a> is an example"
        "  of using a <a href=\"CppBaseClass.htm\">base class</a>.",
        "</p>",
      }
    }
  );


  m.push_back(
    { "CppBeast",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppBeast.htm\">Beast</a> contain the resources"
        "  to work with the tool <a href=\"ToolBeast2.htm\">BEAST2</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBinaryNewickVector",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBinaryNewickVector.htm\">BinaryNewickVector</a> is a <a href=\"CppDataType.htm\">data type</a>",
        "  for storing phylogenies in the <a href=\"CppNewick.htm\">Newick</a> format.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  The <a href=\"Tools.htm\">tool</a> <a href=\"ToolTestBinaryNewickVector.htm\">TestBinaryNewickVector</a>",
        "  is a GUI to test and experiment with <a href=\"CppBinaryNewickVector.htm\">BinaryNewickVector</a>.",
        "</p>",
        "<p>&nbsp;</p>",
      }
    }
  );

  m.push_back(
    { "CppBiology",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppBiology.htm\">Biology</a> contains some classes"
        "  that are related to biology.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBioppExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppBioppExample1.htm\">Bio++ example 1</a> is an example"
        "  how to use the Bio++ library.",
        "</p>",
      }
    }
  );




  m.push_back(
    { "CppBirthDeathModel",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppBirthDeathModel.htm\">BirthDeathModel</a> contains some classes"
        "  that are related to the birth-death speciation model.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoolExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoolExample1.htm\">bool example1</a> is a",
        "  <a href=\"CppBool.htm\">bool</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppCppBoostAdjacency_listExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostAdjacency_listExample1.htm\">boost::adjacency_list example 1</a> is a",
        "  <a href=\"CppBoostAdjacency_list.htm\">boost::adjacency_list</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostArrayExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostArrayExample1.htm\">boost::array example 1</a> is a",
        "  <a href=\"CppBoostArray.htm\">boost::array</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostAuto_cpu_timerExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostAuto_cpu_timerExample1.htm\">boost::auto_cpu_timer example 1</a> is a",
        "  <a href=\"CppBoostAuto_cpu_timer.htm\">boost::auto_cpu_timer</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );





  m.push_back(
    { "CppBoostBimapExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostBimapExample1.htm\">boost::bimap example 1: find</a> is a",
        "  <a href=\"CppBoostBimap.htm\">boost::bimap</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );
  m.push_back(
    { "CppBoostBimapExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostBimapExample2.htm\">boost::bimap example 2: copy</a> is a",
        "  <a href=\"CppBoostBimap.htm\">boost::bimap</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostBimapExample3",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostBimapExample3.htm\">boost::bimap example 3</a> is a",
        "  <a href=\"CppBoostBimap.htm\">boost::bimap</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostBimapExample4",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostBimapExample4.htm\">boost::bimap example 4</a> is a",
        "  <a href=\"CppBoostBimap.htm\">boost::bimap</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostChecked_deleteExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostChecked_deleteExample1.htm\">boost::checked_delete example 1</a>",
        "  is a <a href=\"CppBoostChecked_delete.htm\">boost::checked_delete</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostConceptCheckExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostConceptCheckExample1.htm\">boost::concept_check example 1</a>",
        "  is a <a href=\"CppBoostConceptCheck.htm\">boost::concept_check</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppBoostConst_pointer_castExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostConst_pointer_castExample1.htm\">boost::const_pointer_cast example 1</a>",
        "  is a <a href=\"CppBoostConst_pointer_cast.htm\">boost::const_pointer_cast</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostConst_pointer_castExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostConst_pointer_castExample2.htm\">boost::const_pointer_cast example 2</a>",
        "  is a <a href=\"CppBoostConst_pointer_cast.htm\">boost::const_pointer_cast</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppBoostFormatExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostFormatExample1.htm\">Boost.Format example 1</a>"
        "  is a <a href=\"CppBoostFormat.htm\">Boost.Format</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostFormatExample1.zip\">Download the Qt Creator project 'CppBoostFormatExample1' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppBoostFormatExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostFormatExample2.htm\">Boost.Format example 2</a>",
        "  is a <a href=\"CppBoostFormat.htm\">Boost.Format</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostFormatExample2.zip\">Download the Qt Creator project 'CppBoostFormatExample2' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostFunctionExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostFunctionExample1.htm\">Boost.Function example 1</a>",
        "  is a <a href=\"CppBoostFunction.htm\">Boost.Function</a> example.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostFunctionExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostFunctionExample2.htm\">Boost.Function example 2</a>",
        "  is a <a href=\"CppBoostFunction.htm\">Boost.Function</a> example.",
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppBoostFunctionExample3",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostFunctionExample3.htm\">Boost.Function example 3: calling a member function with an argument and reading its result</a>",
        "  is a <a href=\"CppBoostFunction.htm\">Boost.Function</a> example that shows how",
        "  to call a member function with an argument and how to read its result.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample1.htm\">Boost.Geometry example 1: determine if a point is within a polygon</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample2.htm\">Boost.Geometry example 2: points to polygon and back, determine the area of a polygon</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample3",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample3.htm\">Boost.Geometry example 3: IsConvex: determine if a 2D polygon is convex or concave</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
        "<p>&nbsp;</p>",
        "<p>",
        "  IsConvex is maintained in <a href=\"CppGeometry.htm\">CppGeometry</a>.",
        "  See <a href=\"CppGeometry.htm\">CppGeometry</a>",
        "  for the heavily used, debugged and tested version of IsConvex",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample4",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample4.htm\">Boost.Geometry example 4: CalcPlane: determine the plane passing through three point</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  CalcCrossProduct and CalcPlane are maintained in <a href=\"CppGeometry.htm\">CppGeometry</a>.",
        "  See <a href=\"CppGeometry.htm\">CppGeometry</a>",
        "  for the heavily used, debugged and tested versions of CalcCrossProduct and CalcPlane.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample5",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample5.htm\">Boost.Geometry example 5: Get a box its left, right, width, height and area</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample6",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample6.htm\">Boost.Geometry example 6: See if a point is within a polygon</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample7",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample7.htm\">Boost.Geometry example 7: Bug in boost::geometry::convex_hull</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample8",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample8.htm\">Boost.Geometry example 8: Convert points to a polygon and back</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample9",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample9.htm\">Boost.Geometry example 9: Rescale and translate a polygon</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample10",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample10.htm\">Boost.Geometry example 10: Create a polygon from WKT</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample11",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample11.htm\">Boost.Geometry example 11: Create a polygon from two intersecting polygons</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample12",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample12.htm\">Boost.Geometry example 12: Create a linestring from WKT</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample13",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample13.htm\">Boost.Geometry example 13: Convert a polygon to linestring and back</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample14",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample14.htm\">Boost.Geometry example 14: Convert points to a linestring and back</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample15",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample15.htm\">Boost.Geometry example 15: Obtain the intersection of a polygon and linestring</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGeometryExample16",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGeometryExample16.htm\">Boost.Geometry example 16: Convert a polygon to WKT</a>",
        "  is a <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGetExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGetExample1.htm\">boost::get example 1</a>",
        "  is a <a href=\"CppBoostGet.htm\">boost::get</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostGraphExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGraphExample1.htm\">Boost.Graph example 1: four human names and their relationships + plotting</a>",
        "  is a <a href=\"CppBoostGraph.htm\">Boost.Graph</a> <a href=\"CppExample.htm\">example</a>.",
        "  It defines a graph of person names and their relationships. Then the graph is written to .dot file and plotted using KGraphViewer.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostGraphExample1.png\">View the graph of this example (png)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostGraphExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGraphExample2.htm\">Boost.Graph example 2: four human names and their relationships + plotting</a>",
        "  is a <a href=\"CppBoostGraph.htm\">Boost.Graph</a> <a href=\"CppExample.htm\">example</a>.",
        "  It defines a graph of person names and their relationships. Then the graph is written to .dot file and plotted using KGraphViewer.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostGraphExample2.png\">View the graph of this example (png)</a></li>",
        "</ul>"
      }
    }
  );


  m.push_back(
    { "CppBoostGraphExample3",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGraphExample3.htm\">Boost.Graph example 3: four human names and their relationships + plotting</a>",
        "  is a <a href=\"CppBoostGraph.htm\">Boost.Graph</a> <a href=\"CppExample.htm\">example</a>.",
        "  It defines a graph of person names and their relationships. Then the graph is written to .dot file and plotted using KGraphViewer.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostGraphExample3.png\">View the graph of this example (png)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostGraphExample4",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGraphExample4.htm\">Boost.Graph example 4: four human names and their relationships displayed in Qt</a>",
        "  is a <a href=\"CppBoostGraph.htm\">Boost.Graph</a> <a href=\"CppExample.htm\">example</a>.",
        "  It defines a graph of person names and their relationships. Then the graph is written to .dot file and plotted using KGraphViewer.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostGraphExample4.png\">View the graph of this example (png)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostGraphExample5",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostGraphExample5.htm\">Boost.Graph example 5</a>",
        "  is a <a href=\"CppBoostGraph.htm\">Boost.Graph</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );


  m.push_back(
    { "CppBoostMake_sharedExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostMake_sharedExample1.htm\">boost::make_shared example 1</a>",
        "  is a <a href=\"CppBoostMake_shared.htm\">boost::make_shared</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostMultiprecisionExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostMultiprecisionExample1.htm\">boost::multiple_precision example 1</a>",
        "  is a <a href=\"CppBoostMultiple_precision.htm\">boost::multiple_precision</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );
  m.push_back(
    { "CppBoostMultiprecisionExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostMultiprecisionExample2.htm\">boost::multiple_precision example 2</a>",
        "  is a <a href=\"CppBoostMultiple_precision.htm\">boost::multiple_precision</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostRefExample1",
      {
        "<p>",
        "  <a href=\"CppBoostRefExample1.htm\">Boost.Ref example 1</a> is"
        "   a <a href=\"CppBoostRef.htm\">Boost.Ref</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostRefExample2.zip\">Download the Qt Creator project 'CppBoostRefExample2' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostRefExample2",
      {
        "<p>",
        "  <a href=\"CppBoostRefExample2.htm\">Boost.Ref example 2: putting references in a vector</a> is"
        "   a <a href=\"CppBoostRef.htm\">Boost.Ref</a> example showing",
        "  how to put references in a std::vector and how the values stay in sync.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostRefExample2.zip\">Download the Qt Creator project 'CppBoostRefExample2' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostRegexExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostRegexExample1.htm\">Boost.Regex example 1</a>",
        "  is an <a href=\"CppExample.htm\">example</a> how to use the <a href=\"CppBoostRegex.htm\">Boost.Regex</a>",
        "  <a href=\"CppLibrary.htm\">library</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  The <a href=\"CppExample.htm\">example</a> below shows how to define a regular expression for a Dutch zip code,",
        "  how to check for it and how to search for it.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostRegexExample1.zip\">Download the Qt Creator project 'CppBoostRegexExample1' (zip)</a></li>",
        "  <li><img src=\"PicWindows.png\" alt=\"Windows\"/> <a href=\"CppBoostRegexExample1Exe.zip\">Download the 'CppBoostRegexExample1' Windows executable (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppBoostRegexExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostRegexExample2.htm\">Boost.Regex example 2: replace</a>",
        "  is an <a href=\"CppExample.htm\">example</a> how to use the <a href=\"CppBoostRegex.htm\">Boost.Regex</a>",
        "  <a href=\"CppLibrary.htm\">library</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>The <a href=\"CppExample.htm\">example</a> below shows how to perform a replacement within a regular expression.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostRegexExample2.zip\">Download the Qt Creator project 'CppBoostRegexExample2' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppBoostRegexExample3",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostRegexExample3.htm\">Boost.Regex example 3</a>",
        "  is an <a href=\"CppExample.htm\">example</a> how to use the <a href=\"CppBoostRegex.htm\">Boost.Regex</a>",
        "  <a href=\"CppLibrary.htm\">library</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>The <a href=\"CppExample.htm\">example</a> below shows how to iterate through a text with a regular expression.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostRegexExample3.zip\">Download the Qt Creator project 'CppBoostRegexExample3' (zip)</a></li>",
        "</ul>"
      }
    }
  );


  m.push_back(
    { "CppBoostReplace_all_copyExample1",
      {
        "<p>",
        "  <a href=\"CppBoostReplace_all_copyExample1.htm\">boost::replace_all_copy example 1</a> is"
        "   a <a href=\"CppBoostReplace_all_copy.htm\">boost::replace_all_copy</a> example.",
        "</p>",
      }
    }
  );


  m.push_back(
    { "CppBoostShared_ptrExample1",
      {
        "<p>",
        "  <a href=\"CppBoostShared_ptrExample1.htm\">boost::shared_ptr example 1</a> is"
        "   a <a href=\"CppBoostShared_ptr.htm\">boost::shared_ptr</a> example.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostShared_ptrExample2",
      {
        "<p>",
        "  <a href=\"CppBoostShared_ptrExample2.htm\">boost::shared_ptr example 2</a> is"
        "   a <a href=\"CppBoostShared_ptr.htm\">boost::shared_ptr</a> example.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostShared_ptrExample3",
      {
        "<p>",
        "  <a href=\"CppBoostShared_ptrExample3.htm\">boost::shared_ptr example 3</a> is"
        "   a <a href=\"CppBoostShared_ptr.htm\">boost::shared_ptr</a> example.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostShared_ptrExample4",
      {
        "<p>",
        "  <a href=\"CppBoostShared_ptrExample4.htm\">boost::shared_ptr example 4</a> is"
        "   a <a href=\"CppBoostShared_ptr.htm\">boost::shared_ptr</a> example.",
        "</p>",
      }
    }
  );




  m.push_back(
    { "CppBoostSignals2Example1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostSignals2Example1.htm\">Boost.Signals2 example 1: comparing Boost and Qt</a>",
        "  is a <a href=\"CppBoostSignals2.htm\">Boost.Signals2</a> example that shows",
        "  both the use of <a href=\"CppBoostSignals2.htm\">Boost.Signals2 signals</a> and",
        "  <a href=\"CppQtSignal.htm\">Qt signals</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  The <a href=\"CppArticle.htm\">article</a> <a href=\"CppFromQtSignalToBoostSignal.htm\">From Qt signal to Boost signal</a>",
        "  describes why and how to move from using <a href=\"CppQtSignal.htm\">Qt signals</a> to using",
        "  <a href=\"CppBoostSignals2.htm\">Boost.Signal2 signals</a>.",
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppBoostSignals2Example2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostSignals2Example2.htm\">Boost.Signals2 example 2: emitting this</a>",
        "  is a <a href=\"CppBoostSignals2.htm\">Boost.Signals2</a> example that shows how",
        "  to emit <a href=\"CppThis.htm\">this</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostSignals2Example3",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostSignals2Example3.htm\">Boost.Signals2 example 3</a>",
        "  is a <a href=\"CppBoostSignals2.htm\">Boost.Signals2</a> example.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostSignals2Example4",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostSignals2Example4.htm\">Boost.Signals2 example 4</a>",
        "  is a <a href=\"CppBoostSignals2.htm\">Boost.Signals2</a> example.",
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppBoostTestExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostTestExample1.htm\">Boost.Test example 1</a>",
        "  is a <a href=\"CppBoostTest.htm\">Boost.Test</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostTestExample1.zip\">Download the Qt Creator project 'CppBoostTestExample1' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostTestExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostTestExample2.htm\">Boost.Test example 2</a>",
        "  is a <a href=\"CppBoostTest.htm\">Boost.Test</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );


  m.push_back(
    { "CppBoostTimerExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostTimerExample1.htm\">boost::timer example 1</a>",
        "  is a <a href=\"CppBoostTimer.htm\">boost::timer</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostTriboolExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostTriboolExample1.htm\">boost::tribool example 1</a>",
        "  is a <a href=\"CppBoostTribool.htm\">boost::tribool</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );



  m.push_back(
    { "CppBoostTupleExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostTupleExample1.htm\">Boost.Tuple example 1</a>",
        "  is a <a href=\"CppBoostTuple.htm\">Boost.Tuple</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostTupleExample1.zip\">Download the Qt Creator project 'CppBoostTupleExample1' (zip)</a></li>",
        "</ul>"
      }
    }
  );


  m.push_back(
    { "CppBoostUblasMatrixExample1",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUblasMatrixExample1.htm\">boost::ublas::matrix example 1</a>",
        "  is a <a href=\"CppBoostUblasMatrix.htm\">boost::ublas::matrix</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );
  m.push_back(
    { "CppBoostUblasMatrixExample2",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUblasMatrixExample2.htm\">boost::ublas::matrix example 2</a>",
        "  is a <a href=\"CppBoostUblasMatrix.htm\">boost::ublas::matrix</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );
  m.push_back(
    { "CppBoostUblasMatrixExample3",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUblasMatrixExample3.htm\">boost::ublas::matrix example 3</a>",
        "  is a <a href=\"CppBoostUblasMatrix.htm\">boost::ublas::matrix</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );
  m.push_back(
    { "CppBoostUblasMatrixExample4",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUblasMatrixExample4.htm\">boost::ublas::matrix example 4</a>",
        "  is a <a href=\"CppBoostUblasMatrix.htm\">boost::ublas::matrix</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );
  m.push_back(
    { "CppBoostUblasMatrixExample5",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUblasMatrixExample5.htm\">boost::ublas::matrix example 5</a>",
        "  is a <a href=\"CppBoostUblasMatrix.htm\">boost::ublas::matrix</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );
  m.push_back(
    { "CppBoostUblasMatrixExample6",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUblasMatrixExample6.htm\">boost::ublas::matrix example 6</a>",
        "  is a <a href=\"CppBoostUblasMatrix.htm\">boost::ublas::matrix</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );
  m.push_back(
    { "CppBoostUblasMatrixExample7",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUblasMatrixExample7.htm\">boost::ublas::matrix example 7</a>",
        "  is a <a href=\"CppBoostUblasMatrix.htm\">boost::ublas::matrix</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
      }
    }
  );



  m.push_back(
    { "CppBoostUnitsBug",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsBug.htm\">Boost.Units bug</a> shows a <a href=\"CppBoostUnits.htm\">Boost.Units</a> <a href=\"CppBug.htm\">bug</a>.",
        "  Feel free, however, to call it an 'unexpected feature'.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsBug.htm\">Download the Qt Creator project 'CppUnitsBug' (zip)</a></li>",
        "</ul>"
      }
    }
  );


  m.push_back(
    { "CppBoostUnitsExample1",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample1.htm\">Boost.Units example 1: example from Boost</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample1.zip\">Download the Qt Creator project 'CppBoostUnitsExample1' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample2",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample2.htm\">Boost.Units example 2: calculate the area from two lengths</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample2.zip\">Download the Qt Creator project 'CppBoostUnitsExample2' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample3",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample3.htm\">Boost.Units example 3: creating a Length, Width and Area classes</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample3.zip\">Download the Qt Creator project 'CppBoostUnitsExample3' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample4",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample4.htm\">Boost.Units example 4: creating a Length, Width and Area classes with some typedefs</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample4.zip\">Download the Qt Creator project 'CppBoostUnitsExample4' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample5",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample5.htm\">Boost.Units example 5: averaging multiple lengths</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample5.zip\">Download the Qt Creator project 'CppBoostUnitsExample5' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample6",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample6.htm\">Boost.Units example 6: using an angle</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample6.zip\">Download the Qt Creator project 'CppBoostUnitsExample6' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample7",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample7.htm\">Boost.Units example 7: calculating a force from a mass and an acceleration</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample7.zip\">Download the Qt Creator project 'CppBoostUnitsExample7' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample8",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample8.htm\">Boost.Units example 8: calculating mass from a volume and a mass density</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample8.zip\">Download the Qt Creator project 'CppBoostUnitsExample8' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample9",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample9.htm\">Boost.Units example 9: calculating pressure from a force and an area</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample9.zip\">Download the Qt Creator project 'CppBoostUnitsExample9' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample10",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample10.htm\">Boost.Units example 10: calculating angular acceleration and torque</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample10.zip\">Download the Qt Creator project 'CppBoostUnitsExample10' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample11",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample11.htm\">Boost.Units example 11: creating the quantity volumetric flow</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample11.zip\">Download the Qt Creator project 'CppBoostUnitsExample11' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample12",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample12.htm\">Boost.Units example 12: creating the quantity volumetric flow and mass flow</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostUnitsExample12.zip\">Download the Qt Creator project 'CppBoostUnitsExample12' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample13",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample13.htm\">Boost.Units example 13</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample14",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample14.htm\">Boost.Units example 14</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample15",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample15.htm\">Boost.Units example 15</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample16",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample16.htm\">Boost.Units example 16</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppBoostUnitsExample17",
      {
        "<p>",
        "  <img src=\"PicCpp98.png\" alt=\"Cpp98\"/><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/>",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppBoostUnitsExample17.htm\">Boost.Units example 17</a>",
        "  is a <a href=\"CppBoostUnits.htm\">Boost.Units</a> example.",
        "</p>",
      }
    }
  );



  m.push_back(
    { "CppBoostWeak_ptrExample1",
      {
        "<p>",
        "  <a href=\"CppBoostWeak_ptrExample1.htm\">boost::weak_ptr example 1</a> is a",
        "  <a href=\"CppBoostWeak_ptr.htm\">boost::weak_ptr example</a>",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostWeak_ptrExample2",
      {
        "<p>",
        "  <a href=\"CppBoostWeak_ptrExample2.htm\">boost::weak_ptr example 2</a> is a",
        "  <a href=\"CppBoostWeak_ptr.htm\">boost::weak_ptr example</a>",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostWeak_ptrExample3",
      {
        "<p>",
        "  <a href=\"CppBoostWeak_ptrExample3.htm\">boost::weak_ptr example 3</a> is a",
        "  <a href=\"CppBoostWeak_ptr.htm\">boost::weak_ptr example</a>",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostXpressiveExample1",
      {
        "<p>",
        "  <a href=\"CppBoostXpressiveExample1.htm\">Boost.Xpressive example 1</a> is a",
        "  <a href=\"CppBoostXpressive.htm\">Boost.Xpressive example</a>",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostXpressiveExample2",
      {
        "<p>",
        "  <a href=\"CppBoostXpressiveExample2.htm\">Boost.Xpressive example 2</a> is a",
        "  <a href=\"CppBoostXpressive.htm\">Boost.Xpressive example</a>",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBoostXpressiveExample3",
      {
        "<p>",
        "  <a href=\"CppBoostXpressiveExample3.htm\">Boost.Xpressive example 3</a> is a",
        "  <a href=\"CppBoostXpressive.htm\">Boost.Xpressive</a> example.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBreakExample1",
      {
        "<p>",
        "  <a href=\"CppBreakExample1.htm\">break example 1</a> is a",
        "  <a href=\"CppBreak.htm\">break</a> example.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBreakExample2",
      {
        "<p>",
        "  <a href=\"CppBreakExample2.htm\">break example 2</a> is a",
        "  <a href=\"CppBreak.htm\">break</a> example.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBreakExample3",
      {
        "<p>",
        "  <a href=\"CppBreakExample3.htm\">break example 3</a> is a",
        "  <a href=\"CppBreak.htm\">break</a> example.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppBrownianMotion",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppBrownianMotion.htm\">BrownianMotion</a> contains some classes"
        "  that are related to the Brownian motion process.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppCaesarCipher",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppCaesarCipher.htm\">CaesarCipher</a> contains some classes"
        "  that are related to the Caesar cipher.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppCalculateSqrt",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppCalculateSqrt.htm\">CalculateSqrt</a> shows how"
        "  to calculate the square root of a value.",
        "</p>",
      }
    }
  );



  m.push_back(
    { "CppCallStackCounter",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppCallStackCounter.htm\">CallStackCounter</a> is a <a href=\"CppClass.htm\">class</a>",
        "  to probe the depth of the call stack, for example in a recursive function.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  The tool <a href=\"ToolTestCallStackCounter.htm\">TestCallStackCounter</a> is a <a href=\"Tools.htm\">tool</a>",
        "  to demonstrate its use.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppCanvas",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppCanvas.htm\">Canvas</a> is the <a href=\"CppAbstractBaseClass.htm\">(abstract) base class</a>",
        "  of an ASCII art canvas. <a href=\"CppDerivedClass.htm\">derived classes</a> are, among others,",
        "  <a href=\"CppDrawCanvas.htm\">DrawCanvas</a>, <a href=\"CppImageCanvas.htm\">ImageCanvas</a>",
        "  and <a href=\"CppTextCanvas.htm\">TextCanvas</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppChess",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppChess.htm\">Chess</a> has many chess <a href=\"CppClass.htm\">classes</a>",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppChessResources",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppChessResources.htm\">ChessResources</a> contains and manages",
        "  <a href=\"CppChess.htm\">chess</a> resources",
        "</p>"
      }
    }
  );



  m.push_back(
    { "CppClnExample1",
      {
        "<p><img src=\"PicCln.png\" alt=\"CLN\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppClnExample1.htm\">CLN example 1</a> is a <a href=\"CppCln.htm\">CLN</a>",
        "  example that compares the regular and <a href=\"CppCln.htm\">CLN</a>",
        "  <a href=\"CppInt.htm\">int</a> in calculating a huge factorial."
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppClnExample2",
      {
        "<p><img src=\"PicCln.png\" alt=\"CLN\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppClnExample2.htm\">CLN example 2</a> is a <a href=\"CppCln.htm\">CLN</a>",
        "  example that shows how to to <a href=\"CppConvert.htm\">convert</a> an",
        "  <a href=\"CppCl_I.htm\">cln::cl_I</a> to <a href=\"CppStdString.htm\">std::string</a>",
        "  and adding the thousands seperators.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppCodeBreaker",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/></p>",
        "<p>&nbsp;</p>",
        "<p>"
        "  <a href=\"CppCodeBreaker.htm\">CodeBreaker</a> contains some classes"
        "  to break multiple ciphers.",
        "</p>",
      }
    }
  );

  m.push_back(
    { "CppCodeToHtml",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppCodeToHtml.htm\">CodeToHtml</a> contains <a href=\"CppClass.htm\">classes</a>",
        "  used especially by the <a href=\"Tools.htm\">tool</a> <a href=\"ToolCodeToHtml.htm\">CodeToHtml</a>",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppCompileErrorParseErrorAtBOOST_JOIN",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppCompileErrorParseErrorAtBOOST_JOIN.htm\">CppCompileErrorParseErrorAtBOOST_JOIN</a> is a <a href=\"CppBoost.htm\">Boost</a> <a href=\"CppCompileError.htm\">compile error</a>.",
        "<ul>",
        "  <li><a href=\"CppCompileErrorParseErrorAtBOOST_JOIN.zip\">Download the Qt Creator project 'CppCompileErrorParseErrorAtBOOST_JOIN' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppConceptMap",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppConceptMap.htm\">ConceptMap</a> is a <a href=\"CppClass.htm\">class</a>",
        "  for a concept map.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppConceptMap.htm\">ConceptMap</a> is used in, among others,",
        "  the <a href=\"Tools.htm\">tool</a> <a href=\"ToolTestConceptMap.htm\">TestConceptMap</a>",
        "  and the <a href=\"Projects.htm\">project</a> <a href=\"ProjectBrainweaver.htm\">Brainweaver</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppConnectThree",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppConnectThree.htm\">ConnectThree</a> is a <a href=\"CppClass.htm\">class</a>",
        "  for a <a href=\"GameConnectThree.htm\">ConnectThree game</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppConnectThreeWidget",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppConnectThreeWidget.htm\">ConnectThreeWidget</a> is a <a href=\"CppWidget.htm\">widget</a>",
        "for a <a href=\"GameConnectThree.htm\">ConnectThree game</a>.</p>"
      }
    }
  );

  m.push_back(
    { "CppContainer",
      {
        "<p>A <a href=\"CppContainer.htm\">container</a> is a <a href=\"CppClassType.htm\">class type</a> for containing zero, one or multiple instances of one or more <a href=\"CppDataType.htm\">data type</a>s.</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  Every <a href=\"CppContainer.htm\">container</a> has its own advantages and disadvantages. ",
        "  For example a <a href=\"CppVector.htm\">std::vector</a> has random-access reading/writing, ",
        "  but new elements can only be added at the begin and end of the <a href=\"CppContainer.htm\">container</a>. ",
        "  For a <a href=\"CppList.htm\">std::list</a>, this is the other way around.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppStl.htm\">STL</a> <a href=\"CppContainer.htm\">container</a>s (incomplete list)</h2>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/> <a href=\"CppBitset.htm\">std::bitset</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppDeque.htm\">std::deque</a></li>",
        "  <li><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppForward_list.htm\">std::forward_list</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppList.htm\">std::list</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppMap.htm\">std::map</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppMultimap.htm\">std::multimap</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppMultiset.htm\">std::multiset</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppPair.htm\">std::pair</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppPriority_queue.htm\">std::priority_queue</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppSet.htm\">std::set</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppSlist.htm\">std::slist</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppStack.htm\">std::stack</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppStdString.htm\">std::string</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppQueue.htm\">std::queue</a></li>",
        "  <li><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppUnordered_map.htm\">std::unordered_map</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppValarray.htm\">std::valarray</a></li>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCpp11.png\" alt=\"C++11\"/><a href=\"CppVector.htm\">std::vector</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>SGI extension <a href=\"CppContainer.htm\">containers</a> (incomplete list)</h2>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li>bit_vector</li>",
        "  <li><a href=\"CppHash_set.htm\">hash_set</a></li>",
        "  <li>hash_map</li>",
        "  <li>hash_multiset</li>",
        "  <li>hash_multimap</li>",
        "  <li>hash</li>",
        "  <li>rope</li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppBoost.htm\">Boost</a> <a href=\"CppContainer.htm\">container</a>s (incomplete list)</h2>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppAny.htm\">boost::any</a></li>",
        "  <li><a href=\"CppBoostArray.htm\">boost::array</a></li>",
        "  <li>boost::compressed_pair</li>",
        "  <li>boost::dynamic_bitset</li>",
        "  <li><a href=\"CppMulti_array.htm\">boost::multi_array</a></li>",
        "  <li>boost::ptr_array</li>",
        "  <li>boost::ptr_deque</li>",
        "  <li>boost::ptr_list</li>",
        "  <li>boost::ptr_map</li>",
        "  <li>boost::ptr_multimap</li>",
        "  <li>boost::ptr_multiset</li>",
        "  <li><a href=\"CppPtr_set.htm\">boost::ptr_set</a></li>",
        "  <li>boost::ptr_vector</li>",
        "  <li>boost::shared_array</li>",
        "  <li><a href=\"CppBoostTuple.htm\">boost::tuple</a></li>",
        "  <li>boost::variant</li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppContainer.htm\">Container</a> <a href=\"CppCodeSnippets.htm\">code snippets</a></h2>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppContainerToStr.htm\">ContainerToStr, convert a container to a std::string</a></li>",
        "  <li><a href=\"CppContainerToStr.htm\">Convert a container to a std::string, ContainerToStr</a></li>",
        "  <li><a href=\"CppCopyFirst.htm\">Copy the first element of the std::pairs in a std::vector, CopyFirst</a></li>",
        "  <li><a href=\"CppCopySecond.htm\">Copy the second element of the std::pairs in a std::vector, CopySecond</a></li>",
        "  <li><a href=\"CppCopyFirst.htm\">CopyFirst, copy the first element of the std::pairs in a std::vector</a></li>",
        "  <li><a href=\"CppCopySecond.htm\">CopySecond, copy the second element of the std::pairs in a std::vector</a></li>",
        "  <li><a href=\"CppCoutContainer.htm\">CoutContainer, std::cout a container</a></li>",
        "  <li><a href=\"CppExtractIds.htm\">ExtractIds, extract the ID's for a std::vector of Persons</a></li>",
        "  <li><a href=\"CppExtractIds.htm\">Extract the ID's for a std::vector of Persons, ExtractIds</a></li>",
        "  <li><a href=\"CppGetMean.htm\">Get the mean value of all elements in a container, GetMean</a></li>",
        "  <li><a href=\"CppGetSum.htm\">Get the sum of all elements in a container, GetSum</a></li>",
        "  <li><a href=\"CppGetMinThree.htm\">Get the three lowest elements of a container, GetMinThree</a></li>",
        "  <li><a href=\"CppGetMean.htm\">GetMean, get the mean value of all elements in a container</a></li>",
        "  <li><a href=\"CppGetMinThree.htm\">GetMinThree, obtain the three lowest elements of a container</a></li>",
        "  <li><a href=\"CppGetSum.htm\">GetSum, get the sum of all elements in a container</a></li>",
        "  <li><a href=\"CppLoopReader.htm\">LoopReader, reading a container looped</a></li>",
        "  <li><a href=\"CppMatrix.htm\">Matrix</a></li>",
        "  <li><a href=\"CppLoopReader.htm\">Reading a container looped, LoopReader</a></li>",
        "  <li><a href=\"CppReciprocal.htm\">Reciprocal, replace all values in a container by their reciprocal</a></li>",
        "  <li><a href=\"CppReciprocal.htm\">Replace all values in a container by their reciprocal, Reciprocal</a></li>",
        "  <li><a href=\"CppSaveContainer.htm\">Save a container to file, SaveContainer</a></li>",
        "  <li><a href=\"CppSaveContainer.htm\">SaveContainer, save a container to file</a></li>",
        "  <li><a href=\"CppCoutContainer.htm\">std::cout a container, CoutContainer</a></li>",
        "  <li><a href=\"CppTriple.htm\">Triple all values in a container, Triple</a></li>",
        "  <li><a href=\"CppTriple.htm\">Triple, triple all values in a container</a></li>",
        "",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppAdvice.htm\">Advice</a></h2>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li>",
        "    <a href=\"CppStl.htm\">STL</a> <a href=\"CppContainer.htm\">containers</a> are resource handles [6]",
        "  </li>",
        "  <li>",
        "    If a <a href=\"CppClass.htm\">class</a> is a <a href=\"CppContainer.htm\">container</a>, give it an <a href=\"CppInitializerList.htm\">initializer-list</a> <a href=\"CppContructor.htm\">constructor</a> [1]",
        "  </li>",
        "  <li>",
        "    Use <a href=\"CppTemplate.htm\">templates</a> to express <a href=\"CppContainer.htm\">containers</a> [2]",
        "  </li>",
        "  <li>",
        "    An <a href=\"CppStl.htm\">STL</a> <a href=\"CppContainer.htm\">container</a> defines a sequence [3]",
        "  </li>",
        "  <li>",
        "    Use <a href=\"CppVector.htm\">std::vector</a> as your default <a href=\"CppContainer.htm\">container</a> [4]",
        "  </li>",
        "  <li>",
        "    Insertion operators, such as insert() and push_back() are often more efficient on a <a href=\"CppVector.htm\">std::vector</a> than on a <a href=\"CppList.htm\">std::list</a> [5]",
        "  </li>",
        "  <li>",
        "    Pass a <a href=\"CppContainer.htm\">container</a> by <a href=\"CppReference.htm\">reference</a> and <a href=\"CppReturn.htm\">return</a> a <a href=\"CppContainer.htm\">container</a> by value [7]",
        "  </li>",
        "  <li>",
        "    For a <a href=\"CppContainer.htm\">container</a>, use the ()-syntax for sizes and the <a href=\"CppListInitialization.htm\">list initialization</a> syntax for lists of elements [8]",
        "  </li>",
        "  <li>",
        "    For simple traversal of a <a href=\"CppContainer.htm\">container</a>, use a <a href=\"CppRangeFor.htm\">range-for</a>-loop or a begin/end pair of <a href=\"CppIterator.htm\">iterators</a> [9]",
        "  </li>",
        "  <li>",
        "    Use push_back() or resize() on a <a href=\"CppContainer.htm\">container</a>, rather than <a href=\"CppRealloc.htm\">std::realloc</a> on an <a href=\"CppArray.htm\">array</a> [10]",
        "  </li>",
        "  <li>",
        "    Do not assume that <a href=\"CppOperatorIndex.htm\">operator[]</a> range checks [11]",
        "  </li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppReferences.htm\">References</a></h2>",
        "<p>&nbsp;</p>",
        "<ol>",
        "  <li><!--  1 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 17.7. Advice. page 525: '[8] If a class is a container, give it an initializer-list constructor'</li>",
        "  <li><!--  2 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 23.8, page 698: '[2] Use templates to express containers'</li>",
        "  <li><!--  3 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 31.6. Advice. page 924: '[1] An STL container defines a sequence'</li>",
        "  <li><!--  4 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 31.6. Advice. page 924: '[2] Use vector as your default container'</li>",
        "  <li><!--  5 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 31.6. Advice. page 924: '[3] Insertion operators, such as insert() and push_back() are often more efficient on a vector than on a list'</li>",
        "  <li><!--  6 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 31.6. Advice. page 924: '[7] STL containers are resource handles'</li>",
        "  <li><!--  7 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 31.6. Advice. page 924: '[13] Pass a container by reference and return a container by value'</li>",
        "  <li><!--  8 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 31.6. Advice. page 924: '[14] For a container, use the ()-syntax for sizes and the {}-initializer syntax for lists of elements'</li>",
        "  <li><!--  9 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 31.6. Advice. page 924: '[15] For simple traversal of a container, use a range-for-loop or a begin/end pair of iterators'</li>",
        "  <li><!-- 10 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 31.6. Advice. page 924: '[20] Use push_back() or resize() on a container, rather than realloc() on an array'</li>",
        "  <li><!-- 11 --><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (4th edition). 2013. ISBN: 978-0-321-56384-2. Chapter 31.6. Advice. page 924: '[23] Do not assume that [] range checks'</li>",
        "</ol>"
      }
    }
  );

  m.push_back(
    { "CppCoordinat",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppCoordinat.htm\">Coordinat</a> is a <a href=\"CppClass.htm\">class</a>",
        "  for a coordinat.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppCopy_if",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppCopy_if.htm\">copy_if</a> is an <a href=\"CppAlgorithm.htm\">algorithm</a> that was dropped ",
        "from the <a href=\"Cpp98.htm\">C++98</a> <a href=\"CppStl.htm\">STL</a> by accident, but added to the",
        "<a href=\"Cpp11.htm\">C++11</a> <a href=\"CppStl.htm\">STL</a>.</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><img src=\"PicCpp98.png\" alt=\"C++98\"/> <a href=\"CppCopy_if.htm\">std::copy_if</a></h2>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppCopy_if.htm\">std::copy_if</a> is an <a href=\"CppAlgorithm.htm\">algorithm</a> that was dropped ",
        "from the <a href=\"Cpp98.htm\">C++98</a> <a href=\"CppStl.htm\">STL</a> by accident.</p>",
        "<p>&nbsp;</p>",
        "<p>Prefer <a href=\"CppAlgorithm.htm\">algorithm</a> calls over hand-written loops [1][2].</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h3><img src=\"PicCpp98.png\" alt=\"C++98\"/> Example <a href=\"CppDefinition.htm\">definition</a> of <a href=\"CppCopy_if.htm\">copy_if</a></h3>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary = \"copy_if definition\" border = \"1\"><tr><td><code>",
        "<a href=\"CppComment.htm\">//</a><a href=\"CppCopy_if.htm\">Copy_if</a> was dropped from the standard library by accident.<br/>",
        "<b><a href=\"CppTemplate.htm\">template</a></b>&lt;<b><a href=\"CppTypename.htm\">typename</a></b> In, <b><a href=\"CppTypename.htm\">typename</a></b> Out, <b><a href=\"CppTypename.htm\">typename</a></b> Pred&gt;<br/>",
        "Out <a href=\"CppCopy_if.htm\">Copy_if</a>(In first, In last, Out res, Pred Pr)<br/>",
        "{<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppWhile.htm\">while</a></b> (first <a href=\"CppOperatorNotEqual.htm\">!=</a> last)<br/>",
        "&nbsp;&nbsp;{<br/>",
        "&nbsp;&nbsp;&nbsp;&nbsp;<b><a href=\"CppIf.htm\">if</a></b> (Pr(*first))<br/>",
        "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*res<a href=\"CppOperatorIncrement.htm\">++</a> = *first;<br/>",
        "&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"CppOperatorIncrement.htm\">++</a>first;<br/>",
        "&nbsp;&nbsp;}<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppReturn.htm\">return</a></b> res;<br/>",
        "}<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><img src=\"PicCpp11.png\" alt=\"C++11\"/> <a href=\"CppCopy_if.htm\">std::copy_if</a></h2>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppCopy_if.htm\">std::copy_if</a> is an <a href=\"CppAlgorithm.htm\">algorithm</a> similar to",
        "<a href=\"CppCopy.htm\">std::copy</a>, except that a <a href=\"CppPredicate.htm\">predicate</a> can also",
        "be supplied. <a href=\"CppCopy_if.htm\">std::copy_if</a> resides in the <a href=\"Cpp11.htm\">C++11</a> ",
        "<a href=\"CppStl.htm\">STL</a> <a href=\"CppHeaderFile.htm\">header file</a> <a href=\"CppAlgorithmH.htm\">algorithm</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppCopy_if.htm\">Download the Qt Creator project 'CppCopy_if' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary = \"CppCopy_if code\" border = \"1\"><tr><td><code>",
        "<a href=\"CppInclude.htm\">#include</a> &lt;<a href=\"CppAlgorithmH.htm\">algorithm</a>&gt;<br/>",
        "<a href=\"CppInclude.htm\">#include</a> &lt;<a href=\"CppCassertH.htm\">cassert</a>&gt;<br/>",
        "<a href=\"CppInclude.htm\">#include</a> &lt;<a href=\"CppVectorH.htm\">vector</a>&gt;<br/>",
        "<br/>",
        "<b><a href=\"CppInt.htm\">int</a></b> <a href=\"CppMain.htm\">main</a>()<br/>",
        "{<br/>",
        "&nbsp;&nbsp;<a href=\"CppComment.htm\">//</a><a href=\"Cpp11.htm\">C++11</a> <a href=\"CppInitializerList.htm\">initializer list</a><br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; v <a href=\"CppOperatorAssign.htm\">=</a> { 0,1,2,3,4,5,6 };<br/>",
        "<br/>",
        "&nbsp;&nbsp;<a href=\"CppComment.htm\">//</a>Only copy the even values to w<br/>",
        "&nbsp;&nbsp;<a href=\"CppComment.htm\">//</a><b><a href=\"CppUsing.htm\">using</a></b> <a href=\"Cpp11.htm\">C++11</a> <a href=\"CppLambdaExpression.htm\">lambda expression</a><br/>",
        "&nbsp;&nbsp;<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; w;<br/>",
        "&nbsp;&nbsp;<a href=\"CppCopy_if.htm\">std::copy_if</a>(v.begin(), v.end(),<br/>",
        "&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"CppBack_inserter.htm\">std::back_inserter</a>(w),<br/>",
        "&nbsp;&nbsp;&nbsp;&nbsp;[](<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> i) { <b><a href=\"CppReturn.htm\">return</a></b> i <a href=\"CppOperatorModulus.htm\">%</a> 2 <a href=\"CppOperatorEqual.htm\">==</a> 0; } ,<br/>",
        "<br/>",
        "&nbsp;&nbsp;<a href=\"CppComment.htm\">//</a>Check all even values are indeed copied<br/>",
        "&nbsp;&nbsp;<a href=\"CppComment.htm\">//</a><b><a href=\"CppUsing.htm\">using</a></b> another <a href=\"Cpp11.htm\">C++11</a> <a href=\"CppInitializerList.htm\">initializer list</a><br/>",
        "&nbsp;&nbsp;<a href=\"CppAssert.htm\">assert</a>(w <a href=\"CppOperatorEqual.htm\">==</a> <a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt;( { 0,2,4,6 } ) ,<br/>",
        "}<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>Prefer <a href=\"CppAlgorithm.htm\">algorithm</a> calls over hand-written loops [1][2].</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppReferences.htm\">References</a></h2>",
        "<p>&nbsp;</p>",
        "<ol>",
        "  <li><a href=\"CppBjarneStroustrup.htm\">Bjarne Stroustrup</a>. The C++ Programming Language (3rd edition). 1997. ISBN: 0-201-88954-4. Chapter 18.12.1: 'Prefer algorithms to loops.</li>",
        "  <li><a href=\"CppScottMeyers.htm\">Scott Meyers</a>. Effective STL. ISBN: 0-201-74962-9. Item 43: 'Prefer algorithm calls over hand-written loops'</li>",
        "</ol>"
      }
    }
  );

  m.push_back(
    { "CppCopyFile",
      {
        "<p><a href=\"CppCopyFile.htm\">CopyFile</a> is a <a href=\"CppFileIo.htm\">file I/O</a> <a href=\"CppCodeSnippets.htm\">code snippet</a> to copy a file.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppCopyFile.zip\">Download the Qt Creator project 'CppCopyFile' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppCounter",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppCounter.htm\">Counter</a> is a <a href=\"CppClass.htm\">class</a>",
        "  for tallying.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppDial",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppDial.htm\">Dial</a> is a <a href=\"CppClass.htm\">class</a> for a dial.</p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppDial.htm\">Dial</a> is displayed by ",
        "<a href=\"CppQtDialWidget.htm\">QtDialWidget</a> and <a href=\"CppWtDialWidget.htm\">WtDialWidget</a>.</p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppDial.htm\">Dial</a> is used in (among others) the <a href=\"Tools.htm\">tool</a>",
        "<a href=\"ToolTestDial.htm\">TestDial</a>.</p>"
      }
    }
  );

  m.push_back(
    { "CppDialWidget",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppDialWidget.htm\">DialWidget</a> is a <a href=\"CppDial.htm\">Dial</a> <a href=\"CppWidget.htm\">widget</a>.</p>"
      }
    }
  );

  m.push_back(
    { "CppDotMatrix",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppDotMatrix.htm\">DotMatrix</a> is a <a href=\"CppClass.htm\">class</a>",
        "  for creating dot matrix texts.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppDrawCanvas",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppDrawCanvas.htm\">DrawCanvas</a> is a <a href=\"CppCanvas.htm\">Canvas</a>",
        "  to draw on.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppEncranger",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppEncranger.htm\">Encranger</a> is one of my own",
        "<a href=\"CppCryptography.htm\">cryptography</a> <a href=\"CppClass.htm\">classes</a>.</p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppEncranger.htm\">Encranger</a> is used in, among others:</p>",
        "<ul>",
        "  <li><a href=\"ToolEncranger.htm\">Encranger</a></li>",
        "  <li><a href=\"ProjectWtWebsite.htm\">ProjectWtWebsite</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppEuclideanVector",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppEuclideanVector.htm\">CppEuclideanVector</a> is a <a href=\"CppClass.htm\">class</a>",
        "for an Euclidean (X-Y) vector.</p>"
      }
    }
  );


  m.push_back(
    { "CppExercise",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  On this page you can find some exercises about correct programming,",
        "  inspired by <a href=\"CppHerbSutter.htm\">Herb Sutter</a>'s 'Guru Of The Week' pages.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  These <a href=\"CppExercise.htm\">exercises</a> are suitable for experienced beginners, ",
        "  that want to learn to think in the C++ way. As a side-result they will learn more ",
        "  advanced concepts in a playful way. I try to work on the same difficulty ",
        "  scale as <a href=\"CppHerbSutter.htm\">Herb Sutter</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseDivide.htm\">Exercise #0: A correct Divide function</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseFoolproofFunction.htm\">Exercise #1: A foolproof function</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseCorrectFunctionDeclarations.htm\">Exercise #2: Correct function declarations</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseDontGiveAwayYourInternals.htm\">Exercise #3: Don't give away your internals</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseReadingFromAvectorSafely.htm\">Exercise #4: Reading from a std::vector safely</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseTheManyTypesOfConst.htm\">Exercise #5: The many types of const</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseRefactoringQuadraticSolver.htm\">Exercise #6: refactoring quadratic solver</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseAddOne.htm\">Exercise #7: add one</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicCppBuilder.png\" alt=\"C++ Builder\"/>",
        "    <a href=\"CppExerciseLibraryTrouble.htm\">Exercise #8: library trouble</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseNoForLoops.htm\">Exercise #9: no for-loops</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseReadonlyPointer.htm\">Exercise #10: Obtaining a read-only (smart?) pointer</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppExerciseReadonlyVectorOfPointers.htm\">Exercise #11: Obtaining a std::vector of read-only (smart?) pointers</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQt.png\" alt=\"Qt\"/>",
        "    <a href=\"CppExerciseQtHideAndShow1.htm\">Exercise #12: Qt hide and show #1: intro</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQt.png\" alt=\"Qt\"/>",
        "    <a href=\"CppExerciseQtHideAndShow2.htm\">Exercise #13: Qt hide and show #2: the real problem</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQt.png\" alt=\"Qt\"/>",
        "    <a href=\"CppExerciseQtHideAndShow3.htm\">Exercise #14: Qt hide and show #3: refactoring</a>",
        "  </li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>External links</h2>",
        "<p>&nbsp;</p>",
        "<ol>",
        "  <li><a href=\"http://www.gotw.ca/gotw/\">Herb Sutter's Guru Of The Week archive</a></li>",
        "</ol>",
        "<p>",
        "  Additionally, <a href=\"CppExercise.htm\">Exercise</a> is a",
        "  <a href=\"CppClass.htm\">class</a> for an",
        "  exercise.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppFileIo",
      {
        "<p><a href=\"CppFileIo.htm\">File I/O</a> is working with files, like saving, reading, copying and searching.</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppFileIo.htm\">File I/O</a> <a href=\"CppStl.htm\">STL</a> <a href=\"CppFunction.htm\">functions</a> and <a href=\"CppDataType.htm\">data types</a></h2>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppFstream.htm\">std::fstream</a>: file <a href=\"CppStream.htm\">stream</a></li>",
        "  <li><a href=\"CppRemove.htm\">std::remove</a>: remove a file</li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppFileIo.htm\">File I/O</a> <a href=\"CppCodeSnippets.htm\">code snippets</a></h2>",
        "<p>&nbsp;</p>",
        "<ol>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppCopy_file.htm\">boost::filesystem::copy_file, copy a file</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppIsRegularFile.htm\">Check if a file exists, IsRegularFile</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/> ",
        "    <a href=\"CppCopy_file.htm\">Copy a file, boost::filesystem::copy_file</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicVcl.png\" alt=\"VCL\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppCopyFile.htm\">Copy a file, CopyFile</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicVcl.png\" alt=\"VCL\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppCopyFile.htm\">CopyFile, copy a file</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppDeleteFile.htm\">DeleteFile, delete a file</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppDeleteFile.htm\">Delete a file, DeleteFile</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicVcl.png\" alt=\"VCL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppFileToStringList.htm\">FileToStringList, read a file in a TStringList</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppFileToVector.htm\">FileToVector, read a file in a std::vector</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetPath.htm\">Get a file's path, GetPath</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetCppFilesInFolder.htm\">Get all C++ filenames in a folder, GetCppFilesInFolder</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetFilesInFolder.htm\">Get all filenames in a folder, GetFilesInFolder</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetExtension.htm\">Get the extension of a filename, GetExtension</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetCurrentFolder.htm\">Get the name of the folder your application runs in, GetCurrentFolder</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetCppFilesInFolder.htm\">GetCppFilesInFolder, get all C++ filenames in a folder</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetCurrentFolder.htm\">GetCurrentFolder, get the name of the folder your application runs in</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetFoldersInFolder.htm\">Get the names of the folders in a folder, GetFoldersInFolder</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetExtension.htm\">GetExtension, get the extension of a filename</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetFilesInFolder.htm\">GetFilesInFolder, get all filenames in a folder</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetFoldersInFolder.htm\">GetFoldersInFolder, get all the names of the folders in a folder</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppGetPath.htm\">GetPath, get a file's path</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppIsFolder.htm\">IsFolder, check if a path is a folder</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppIsRegularFile.htm\">IsRegularFile, check if a file is a regular file</a>",
        "  </li>",
        "",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppReadDoubleFromFile.htm\">ReadDoubleFromFile, read a double from file</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppReadDoubleFromFile.htm\">Read a double from file, ReadDoubleFromFile</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppFileToVector.htm\">Read a file in a std::vector, FileToVector</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicVcl.png\" alt=\"VCL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppFileToStringList.htm\">Read a file in a TStringList, FileToStringList</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppRemoveExtension.htm\">Remove the extension of a filename, RemoveExtension</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppRemoveExtension.htm\">RemoveExtension, remove the extension of a filename</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppRunOtherProgram.htm\">Run another program and use its output</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppSaveContainer.htm\">Save a container to file, SaveContainer</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppSaveContainer.htm\">SaveContainer, save a container to file</a>",
        "  </li>",
        "  <li>",
        "    <img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicSpacer.png\" alt=\" \"/><img src=\"PicSpacer.png\" alt=\" \"/>",
        "    <a href=\"CppSimplifyPath.htm\">SimplifyPath, simplify a path</a>",
        "  </li>",
        "</ol>"
      }
    }
  );

  m.push_back(
    { "CppFileToVector",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppFileIo.htm\">File I/O</a> is a <a href=\"CppCodeSnippets.htm\">code snippet</a> ",
        "  to <a href=\"CppConvert.htm\">convert</a> a file to a ",
        "  <a href=\"CppStdVector.htm\">std::vector</a>&lt;<a href=\"CppStdString.htm\">std::string</a>&gt;. ",
        "  <a href=\"CppFileIo.htm\">File I/O</a> you have already defined the <a href=\"CppFileExists.htm\">FileExists</a> function.",
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppFuzzy_equal_to",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppFuzzy_equal_to.htm\">fuzzy_equal_to</a> is a <a href=\"CppPredicate.htm\">predicate</a>",
        "  to test two <a href=\"CppDouble.htm\">doubles</a> for equality with a certain tolerance.",
        "  A tolerance of 0.0 denotes that an exact match is requested.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppGaborFilter",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGaborFilter.htm\">GaborFilter</a> is a",
        "  <a href=\"CppClass.htm\">class</a> for a",
        "  Gabor filter.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppGaborFilterWidget",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGaborFilterWidget.htm\">GaborFilterWidget</a> is a",
        "  <a href=\"CppClass.htm\">class</a> for a",
        "  <a href=\"CppGaborFilter.htm\">Gabor filter</a> <a href=\"CppWidget.htm\">widget</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppGeometry",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGeometry.htm\">CppGeometry</a> is a folder with my geometry",
        "  <a href=\"CppFunction.htm\">functions</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  For the <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a> <a href=\"CppLibrary.htm\">library</a>,",
        "  go to the page about <a href=\"CppBoostGeometry.htm\">Boost.Geometry</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppGeometry.htm\">CppGeometry</a> code snippets</h2>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppBoostGeometryExample4.htm\">CalcCrossProduct: determine the cross-product of two 3D points</a></li>",
        "  <li><a href=\"CppBoostGeometryExample4.htm\">CalcPlane: determine the 3D plane passing through three 3D points</a></li>",
        "  <li><a href=\"CppBoostGeometryExample3.htm\">Determine if a 2D polygon is convex or concave, IsConvex</a></li>",
        "  <li><a href=\"CppBoostGeometryExample1.htm\">Determine if a 2D point is within a polygon</a></li>",
        "  <li><a href=\"CppBoostGeometryExample3.htm\">Determine the 2D convex hull of a concave polygon</a></li>",
        "  <li><a href=\"CppBoostGeometryExample2.htm\">Determine the 3D area of a 2D polygon</a></li>",
        "  <li><a href=\"CppBoostGeometryExample4.htm\">Determine the 3D plane passing through three 3D points, CalcPlane</a></li>",
        "  <li><a href=\"CppBoostGeometryExample4.htm\">Determine the cross-product of two 3D points</a></li>",
        "  <li><a href=\"CppGetAngle.htm\">GetAngle: calculate the angle between two points</a></li>",
        "  <li><a href=\"CppGetDistance.htm\">GetDistance: calculate the distance between two points</a></li>",
        "  <li><a href=\"CppBoostGeometryExample3.htm\">IsConvex: determine if a 2D polygon is convex or concave</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>"
      }
    }
  );


  m.push_back(
    { "CppGetCombinations",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetCombinations.htm\">GetCombinations</a> is a <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to obtain all combinations of a <a href=\"CppVector.htm\">std::vector</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetPermutations.htm\">GetPermutations</a> is a <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to obtain all permutations of a <a href=\"CppVector.htm\">std::vector</a>.",
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppGetExtension",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetExtension.htm\">GetExtension</a> is a",
        "  <a href=\"CppFileIo.htm\">file I/O</a> <a href=\"CppStdString.htm\">std::string</a>",
        "  <a href=\"CppCodeSnippets.htm\">code snippet</a> to get a filename's extension.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  Thanks goes to Curtis Krauskopf, who supported me to improve the",
        "  (terrible and error-prone) STL version GetExtension.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGetExtension.zip\">Download the Qt Creator project 'CppGetExtension' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppGetFilesInFolder",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppGetFilesInFolder.htm\">GetFilesInFolder</a> is a <a href=\"CppFileIo.htm\">file I/O</a> <a href=\"CppCodeSnippets.htm\">code snippet</a> to obtain all filenames in a folder.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGetFilesInFolder.zip\">Download the Qt Creator project 'CppGetFilesInFolder' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppGetMaxDouble",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetMaxDouble.htm\">GetMaxDouble</a> is a <a href=\"CppCheck.htm\">checking</a>",
        "  <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to get the maximal value of an <a href=\"CppDouble.htm\">double</a>."
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGetMaxDouble.zip\">Download the Qt Creator project 'CppGetMaxDouble' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppGetMaxInt",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetMaxInt.htm\">GetMaxInt</a> is a <a href=\"CppCheck.htm\">checking</a>",
        "  <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to get the maximal value of an <a href=\"CppInt.htm\">int</a>."
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGetMaxInt.zip\">Download the Qt Creator project 'CppGetMaxInt' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppGetPath",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetPath.htm\">GetPath</a> is a <a href=\"CppFileIo.htm\">file I/O</a>",
        "  <a href=\"CppStdString.htm\">std::string</a> <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to get a filename's path.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGetPath.zip\">Download the Qt Creator project 'CppGetPath' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppGetPermutations",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetPermutations.htm\">GetPermutations</a> is a <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to obtain all permutations of a <a href=\"CppVector.htm\">std::vector</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetCombinations.htm\">GetCombinations</a> is a <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to obtain all combinations of a <a href=\"CppVector.htm\">std::vector</a>.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppGetRandomNormal",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetRandomNormal.htm\">GetRandomNormal</a> is a ",
        "  <a href=\"CppRandom.htm\">random</a> <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to draw a value from a normal distribution with average 'mean' and a",
        "  standard deviation of 'sigma'.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppGetRandomUniform",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetRandomUniform.htm\">GetRandomUniform</a> is a ",
        "  <a href=\"CppRandom.htm\">random</a> <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to draw a value from 0.0 to (and not including) 1.0.",
        "  All values have an equal likelyhood to be drawn.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppGetRegexMatches",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppGetRegexMatches.htm\">GetRegexMatches</a> is a <a href=\"CppRegex.htm\">Regex</a> <a href=\"CppCodeSnippets.htm\">code snippet</a> to obtain",
        "all <a href=\"CppStdString.htm\">std::strings</a> in a <a href=\"CppStdString.htm\">std::string</a> that satisfy a regular expression.</p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppGetRegexMatches.htm\">GetRegexMatches</a> is demonstrated in the <a href=\"Tools.htm\">tool</a> <a href=\"ToolRegexTester.htm\">RegexTester</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGetRegexMatches.zip\">Download the Qt Creator project 'GetRegexMatches' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppGetSmallestDouble",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetSmallestDouble.htm\">GetSmallestDouble</a> is a <a href=\"CppCheck.htm\">checking</a>",
        "  <a href=\"CppCodeSnippets.htm\">code snippet</a>",
        "  to get the smallest value of an <a href=\"CppDouble.htm\">double</a>."
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGetSmallestDouble.zip\">Download the Qt Creator project 'CppGetSmallestDouble' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppGetTime",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetTime.htm\">GetTime</a> is a <a href=\"CppTime.htm\">time</a>",
        "  <a href=\"CppCodeSnippets.htm\">code snippet</a> to obtain now's time.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetTime.htm\">GetTime</a> can depend on two different <a href=\"CppLibrary.htm\">libraries</a>:",
        "</p>",
        "<ul>",
        "  <li><img src=\"PicBoost.png\" alt=\"Boost\"/> <a href=\"CppBoost.htm\">Boost</a> version of <a href=\"CppGetTime.htm\">GetTime</a></li>",
        "  <li><img src=\"PicStl.png\" alt=\"STL\"/> <a href=\"CppStl.htm\">STL</a> version of <a href=\"CppGetTime.htm\">GetTime</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppGetToday",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetToday.htm\">GetToday</a> is a <a href=\"CppTime.htm\">time</a>",
        "  <a href=\"CppCodeSnippets.htm\">code snippet</a> to obtain today its date.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppGetToday.htm\">GetToday</a> can depend on two different <a href=\"CppLibrary.htm\">libraries</a>:",
        "</p>",
        "<ul>",
        "  <li><img src=\"PicBoost.png\" alt=\"Boost\"/> <a href=\"CppBoostDate_Time.htm\">Boost.Date_Time</a></li>",
        "  <li><img src=\"PicStl.png\" alt=\"STL\"/> <a href=\"CppStl.htm\">STL</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppGetTxtFilesInFolder",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppGetTxtFilesInFolder.htm\">GetFilesInFolder</a> is a <a href=\"CppFileIo.htm\">file I/O</a> <a href=\"CppCodeSnippets.htm\">code snippet</a> to obtain all text filenames in a folder.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGetTxtFilesInFolder.zip\">Download the Qt Creator project 'CppGetTxtFilesInFolder' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppGnuplotInterface",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppGnuplotInterface.htm\">GnuplotInterface</a> is a <a href=\"CppClass.htm\">class</a> ",
        "that enables the user to easily plot values in <a href=\"CppGnuplot.htm\">Gnuplot</a>. It handles ",
        "both the connection to <a href=\"CppGnuplot.htm\">Gnuplot</a> and performs the window management as well. ",
        "It creates a text-file in which the location of the <a href=\"CppGnuplot.htm\">Gnuplot</a> executable can ",
        "be entered (without recompiling the program).</p>",
        "<p>&nbsp;</p>",
        "<p>The <a href=\"Tools.htm\">tool</a> <a href=\"ToolTestGnuplotInterface.htm\">TestGnuplotInterface</a> tests ",
        "the <a href=\"CppGnuplotInterface.htm\">GnuplotInterface</a> <a href=\"CppClass.htm\">class</a>.",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Note: only tested under MacOS\" border = \"1\"><tr><td><code>",
        "I only got this interface to work under MacOS<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>The one function that this <a href=\"CppClass.htm\">class</a> is built around is the popen function. This is a non-standard function to open a pipe. If this function is unknown under your programming environment, try either std::popen, std::_popen, std::__popen, popen, _popen or __popen.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGnuplotInterface.png\">View a screenshot of a graph created with Gnuplot interface</a>. Thanks to Roger Wehage for submitting this image and allowing me to use it.</li>",
        "  <li><a href=\"CppGnuplotInterfaceSource.zip\">Download the 'Gnuplot Interface' source code (zip)</a>.</li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>Known <a href=\"CppCompileError.htm\">compile errors</a></h2>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppCompileError_popenIsNotAmemberOfStd.htm\">_popen is not a member of std</a></li>",
        "  <li><a href=\"CppCompileErrorCLK_TCKwasNotDeclaredInThisScope.htm\">CLK_TCK was not declared in this scope</a></li>",
        "  <li><a href=\"CppCompileErrorDuplicateSymbol.htm\">Duplicate symbol Gnuplot::SetLineStyles()</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppGprofQtCreatorExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppGprofQtCreatorExample1.htm\">Qt Creator gprof example 1: profiling a simple console application in Qt Creator, using Build Settings</a> is a",
        "<a href=\"CppGprof.htm\">gprof</a> <a href=\"CppExample.htm\">example</a> that shows how to profile a simple console application in  <a href=\"CppQt.htm\">Qt Creator</a>,",
        "using the Build Settings.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGprofQtCreatorExample1.zip\">Download the Qt Project of 'CppGprofQtCreatorExample1' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>Here follows a step-by-step guide to use <a href=\"CppGprof.htm\">gprof</a> to do the profiling of a simple <a href=\"CppQt.htm\">Qt Creator</a> project:</p>",
        "<p>&nbsp;</p>",
        "<ol>",
        "  <li>Go to 'Projects -> Build Settings' and add a custom Build step. Fill in the information as in the screenshot below</li>",
        "  <li><a href=\"CppGprofQtCreatorExample1_1.png\">View screenshot</a></li>",
        "  <li>View your project folder. There will be few files</li>",
        "  <li><a href=\"CppGprofQtCreatorExample1_2.png\">View screenshot</a></li>",
        "  <li>Run the program. The executable 'profile_main' has been created in your project folder</li>",
        "  <li><a href=\"CppGprofQtCreatorExample1_3.png\">View screenshot</a></li>",
        "  <li>Run 'profile_main' and the file 'gmon.out' is created</li>",
        "  <li><a href=\"CppGprofQtCreatorExample1_4.png\">View screenshot</a></li>",
        "  <li>Start a Terminal, go to the project folder and use the command 'gprof profile_main > profile.txt'</li>",
        "  <li><a href=\"CppGprofQtCreatorExample1_5.png\">View screenshot</a></li>",
        "  <li>The file 'profile.txt' will be created</li>",
        "  <li><a href=\"CppGprofQtCreatorExample1_6.png\">View screenshot</a></li>",
        "  <li>The file 'profile.txt' will contain the profiling information</li>",
        "</ol>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>Profiling results</h2>",
        "<p>&nbsp;</p>",
        "<p>Here I show the results comparing the five functions, copied from the results file:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Profiling result\"border = \"1\"><tr><td><code>",
        "Flat profile:<br/>",
        "<br/>",
        "&nbsp;&nbsp;%&nbsp;&nbsp; cumulative&nbsp;&nbsp; self&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;self&nbsp;&nbsp;&nbsp;&nbsp; total<br/>",
        " time&nbsp;&nbsp; seconds&nbsp;&nbsp; seconds&nbsp;&nbsp;&nbsp;&nbsp;calls&nbsp;&nbsp;ms/call&nbsp;&nbsp;ms/call&nbsp;&nbsp;name<br/>",
        " 13.59&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1.54&nbsp;&nbsp;&nbsp;&nbsp; 0.28&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp; 280.00&nbsp;&nbsp; 700.00&nbsp;&nbsp;void BubbleSort&lt;int&gt;(std::vector&lt;int, std::allocator&lt;int&gt; &gt;&amp;)<br/>",
        " 12.14&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1.79&nbsp;&nbsp;&nbsp;&nbsp; 0.25&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp; 250.00&nbsp;&nbsp; 670.00&nbsp;&nbsp;void InsertionSort&lt;int&gt;(std::vector&lt;int, std::allocator&lt;int&gt; &gt;&amp;)<br/>",
        " 11.65&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2.03&nbsp;&nbsp;&nbsp;&nbsp; 0.24&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp; 240.00&nbsp;&nbsp; 660.00&nbsp;&nbsp;void SelectionSort&lt;int&gt;(std::vector&lt;int, std::allocator&lt;int&gt; &gt;&amp;)<br/>",
        "&nbsp;&nbsp;0.00&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2.06&nbsp;&nbsp;&nbsp;&nbsp; 0.00&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp; 0.00&nbsp;&nbsp;&nbsp;&nbsp;24.98&nbsp;&nbsp;void SortVector&lt;int&gt;(std::vector&lt;int, std::allocator&lt;int&gt; &gt;&amp;)<br/>",
        "&nbsp;&nbsp;0.00&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2.06&nbsp;&nbsp;&nbsp;&nbsp; 0.00&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp; 0.00&nbsp;&nbsp;&nbsp;&nbsp; 5.02&nbsp;&nbsp;CreateShuffledVector(unsigned int)<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>Conclusion: as expected, SortVector (a QuickSort) is by far the quickest <a href=\"CppSort.htm\">sorting</a> <a href=\"CppAlgorithm.htm\">algorithm</a>.</p>"
      }
    }
  );
  m.push_back(
    { "CppGprofQtCreatorExample2",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppGprofQtCreatorExample2.htm\">gprof example 2: profiling a simple console application in Qt Creator, using Qt project file</a> is a",
        "<a href=\"CppGprof.htm\">gprof</a> <a href=\"CppExample.htm\">example</a> to  profile a simple console application under <a href=\"CppQt.htm\">Qt Creator</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppGprofQtCreatorExample2.zip\">Download the Qt Project of 'CppGprofQtCreatorExample2' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>To be able to use <a href=\"CppGprof.htm\">gprof</a> to profile a project, add the following lines to a ",
        "<a href=\"CppQtProjectFile.htm\">Qt project file</a>:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Qt Creator project file\" border = \"1\"><tr><td><code>",
        "QMAKE_CXXFLAGS_DEBUG += -pg<br/>",
        "QMAKE_LFLAGS_DEBUG += -pg<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>then, for a terminal, type the following lines:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Terminal commands needed for gprof\"border = \"1\"><tr><td><code>",
        "qmake -config debug<br/>",
        "make clean<br/>",
        "make<br/>",
        "./Cpp<a href=\"CppGprof.htm\">Gprof</a><a href=\"CppQtCreator.htm\">QtCreator</a>Example2<br/>",
        "<a href=\"CppGprof.htm\">gprof</a> Cpp<a href=\"CppGprof.htm\">Gprof</a><a href=\"CppQtCreator.htm\">QtCreator</a>Example2 &gt; <a href=\"CppGprof.htm\">gprof</a>.txt<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>Or easier, run the script profile.sh:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Start profiling command\" border = \"1\"><tr><td><code>",
        "./profile.sh<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>Profiling results</h2>",
        "<p>&nbsp;</p>",
        "<p>Here I show the results comparing the five functions, copied from the results file:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Profiling result\" border = \"1\"><tr><td><code>",
        "Each sample counts as 0.01 seconds.<br/>",
        "&nbsp;&nbsp;<a href=\"CppOperatorModulus.htm\">%</a>&nbsp;&nbsp; cumulative&nbsp;&nbsp; self&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;self&nbsp;&nbsp;&nbsp;&nbsp; total&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <br/>",
        " <a href=\"CppTime.htm\">time</a>&nbsp;&nbsp; seconds&nbsp;&nbsp; seconds&nbsp;&nbsp;&nbsp;&nbsp;calls&nbsp;&nbsp; s/call&nbsp;&nbsp; s/call&nbsp;&nbsp;name&nbsp;&nbsp;&nbsp;&nbsp;<br/>",
        " 12.51&nbsp;&nbsp;&nbsp;&nbsp;172.28&nbsp;&nbsp;&nbsp;&nbsp;29.52&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp;29.52&nbsp;&nbsp;&nbsp;&nbsp;77.11&nbsp;&nbsp;<b><a href=\"CppVoid.htm\">void</a></b> <a href=\"CppBubbleSort.htm\">BubbleSort</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt;(<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>, <a href=\"CppStd.htm\">std</a>::allocator&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt;&amp;)<br/>",
        " 12.39&nbsp;&nbsp;&nbsp;&nbsp;201.51&nbsp;&nbsp;&nbsp;&nbsp;29.23&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp;29.23&nbsp;&nbsp;&nbsp;&nbsp;76.82&nbsp;&nbsp;<b><a href=\"CppVoid.htm\">void</a></b> <a href=\"CppInsertionSort.htm\">InsertionSort</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt;(<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>, <a href=\"CppStd.htm\">std</a>::allocator&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt;&amp;)<br/>",
        " 12.06&nbsp;&nbsp;&nbsp;&nbsp;229.97&nbsp;&nbsp;&nbsp;&nbsp;28.45&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp;28.45&nbsp;&nbsp;&nbsp;&nbsp;76.04&nbsp;&nbsp;<b><a href=\"CppVoid.htm\">void</a></b> <a href=\"CppSelectionSort.htm\">SelectionSort</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt;(<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>, <a href=\"CppStd.htm\">std</a>::allocator&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt;&amp;)<br/>",
        "&nbsp;&nbsp;0.00&nbsp;&nbsp;&nbsp;&nbsp;235.89&nbsp;&nbsp;&nbsp;&nbsp; 0.00&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp; 0.00&nbsp;&nbsp;&nbsp;&nbsp; 0.52&nbsp;&nbsp;<b><a href=\"CppVoid.htm\">void</a></b> <a href=\"CppSortVector.htm\">SortVector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt;(<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>, <a href=\"CppStd.htm\">std</a>::allocator&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt;&amp;)<br/>",
        "&nbsp;&nbsp;0.00&nbsp;&nbsp;&nbsp;&nbsp;235.89&nbsp;&nbsp;&nbsp;&nbsp; 0.00&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;&nbsp; 0.00&nbsp;&nbsp;&nbsp;&nbsp; 0.09&nbsp;&nbsp;CreateShuffledVector(<b><a href=\"CppUnsigned.htm\">unsigned</a></b> <b><a href=\"CppInt.htm\">int</a></b>)<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>Conclusion: as expected, SortVector (a QuickSort) is by far the quickest <a href=\"CppSort.htm\">sorting</a> <a href=\"CppAlgorithm.htm\">algorithm</a>.</p>"
      }
    }
  );
  m.push_back(
    { "CppHeaderFileExample1",
      {
         "<p><a href=\"CppHeaderFileExample1.htm\">Header file example 1</a> shows what does and what does not belong in a header file [1].</p>",
         "<p>&nbsp;</p>",
         "<ul>",
         "  <li><a href=\"CppHeaderFileExample1.zip\">Download the Qt Creator project 'CppHeaderFileExample1' (zip)</a></li>",
         "</ul>",
         "<p>&nbsp;</p>",
         "<p>&nbsp;</p>",
         "<p>&nbsp;</p>",
         "<p>&nbsp;</p>",
         "<p>&nbsp;</p>",
         "<h2><a href=\"CppReferences.htm\">References</a></h2>",
         "<p>&nbsp;</p>",
         "<ol>",
         "  <li><!--  1 --> <a href=\"CppJohnLakos.htm\">John Lakos</a>. Large-Scale C++ Software Design. 1996. ISBN: 0-201-63362-0. Chapter 1.1.3, figure 1-3, page 28</li>",
         "</ol>",
         "<p>&nbsp;</p>)"

      }
    }
  );
  m.push_back(
    { "CppHelloBoostLexical_CastQtCreatorCygwin",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicCygwin.png\" alt=\"Cygwin\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostLexical_CastQtCreatorCygwin.htm\">Hello Boost.Lexical_cast using Qt Creator under Cygwin</a>",
        "  is a <a href=\"CppHelloBoostLexical_Cast.htm\">Hello Boost.Lexical_cast</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostLexical_CastQtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloBoostLexical_CastQtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostLexical_CastQtCreatorLubuntu",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostLexical_CastQtCreatorLubuntu.htm\">Hello Boost.Lexical_cast using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloBoostLexical_Cast.htm\">Hello Boost.Lexical_cast</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostLexical_CastQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloBoostLexical_CastQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostLexical_CastQtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostLexical_CastQtCreatorLubuntuToWindows.htm\">Hello Boost.Lexical_cast using Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostLexical_Cast.htm\">Hello Boost.Lexical_cast</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostLexical_CastQtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostLexical_CastQtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostLexical_CastQtCreatorSliTaz",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostLexical_CastQtCreatorSliTaz.htm\">Hello Boost.Lexical_cast using Qt Creator under SliTaz</a>",
        "  is a <a href=\"CppHelloBoostLexical_Cast.htm\">Hello Boost.Lexical_cast</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostLexical_CastQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloBoostLexical_CastQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostLexical_CastQt4QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt4.png\" alt=\"Qt4\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostLexical_CastQt4QtCreatorLubuntuToWindows.htm\">Hello Boost.Lexical_cast using Qt4 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostLexical_Cast.htm\">Hello Boost.Lexical_cast</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostLexical_CastQt4QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostLexical_CastQt4QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostLexical_CastQt5QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt5.png\" alt=\"Qt5\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostLexical_CastQt5QtCreatorLubuntuToWindows.htm\">Hello Boost.Lexical_cast using Qt5 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostLexical_Cast.htm\">Hello Boost.Lexical_cast</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostLexical_CastQt5QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostLexical_CastQt5QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostLexical_CastQtCreatorWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostLexical_CastQtCreatorWindows.htm\">Hello Boost.Lexical_cast using Qt Creator under Windows</a>",
        "  is a <a href=\"CppHelloBoostLexical_Cast.htm\">Hello Boost.Lexical_cast</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostLexical_CastQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloBoostLexical_CastQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostQtCreatorLubuntu",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoost.htm\">Hello Boost</a> is an extension of <a href=\"CppHelloWorld.htm\">Hello World</a>.",
        "  Like <a href=\"CppHelloWorld.htm\">Hello World</a>, <a href=\"CppHelloBoost.htm\">Hello Boost</a> is a simple console",
        "  application. <a href=\"CppHelloBoost.htm\">Hello Boost</a>, however, also requires multiple <a href=\"CppBoost.htm\">Boost</a> ",
        "  <a href=\"CppLibrary.htm\">libraries</a> to <a href=\"CppLink.htm\">link</a> against.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloBoostQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostRegexQtCreatorCygwin",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicCygwin.png\" alt=\"Cygwin\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostRegexQtCreatorCygwin.htm\">Hello Boost.Regex using Qt Creator under Cygwin</a>",
        "  is a <a href=\"CppHelloBoostRegex.htm\">Hello Boost.Regex</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostRegexQtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloBoostRegexQtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostRegexQtCreatorLubuntu",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostRegexQtCreatorLubuntu.htm\">Hello Boost.Regex using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloBoostRegex.htm\">Hello Boost.Regex</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostRegexQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloBoostRegexQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostRegexQtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostRegexQtCreatorLubuntuToWindows.htm\">Hello Boost.Regex using Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostRegex.htm\">Hello Boost.Regex</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostRegexQtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostRegexQtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostRegexQtCreatorSliTaz",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostRegexQtCreatorSliTaz.htm\">Hello Boost.Regex using Qt Creator under SliTaz</a>",
        "  is a <a href=\"CppHelloBoostRegex.htm\">Hello Boost.Regex</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostRegexQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloBoostRegexQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostRegexQt4QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt4.png\" alt=\"Qt4\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostRegexQt4QtCreatorLubuntuToWindows.htm\">Hello Boost.Regex using Qt4 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostRegex.htm\">Hello Boost.Regex</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostRegexQt4QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostRegexQt4QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostRegexQt5QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt5.png\" alt=\"Qt5\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostRegexQt5QtCreatorLubuntuToWindows.htm\">Hello Boost.Regex using Qt5 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostRegex.htm\">Hello Boost.Regex</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostRegexQt5QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostRegexQt5QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostRegexQtCreatorWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostRegexQtCreatorWindows.htm\">Hello Boost.Regex using Qt Creator under Windows</a>",
        "  is a <a href=\"CppHelloBoostRegex.htm\">Hello Boost.Regex</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostRegexQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloBoostRegexQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostSignalsQtCreatorCygwin",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicCygwin.png\" alt=\"Cygwin\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostSignalsQtCreatorCygwin.htm\">Hello Boost.Signals using Qt Creator under Cygwin</a>",
        "  is a <a href=\"CppHelloBoostSignals.htm\">Hello Boost.Signals</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostSignalsQtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloBoostSignalsQtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostSignalsQtCreatorLubuntu",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostSignalsQtCreatorLubuntu.htm\">Hello Boost.Signals using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloBoostSignals.htm\">Hello Boost.Signals</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostSignalsQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloBoostSignalsQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostSignalsQtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostSignalsQtCreatorLubuntuToWindows.htm\">Hello Boost.Signals using Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostSignals.htm\">Hello Boost.Signals</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostSignalsQtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostSignalsQtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostSignalsQtCreatorSliTaz",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostSignalsQtCreatorSliTaz.htm\">Hello Boost.Signals using Qt Creator under SliTaz</a>",
        "  is a <a href=\"CppHelloBoostSignals.htm\">Hello Boost.Signals</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostSignalsQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloBoostSignalsQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostSignalsQt4QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt4.png\" alt=\"Qt4\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostSignalsQt4QtCreatorLubuntuToWindows.htm\">Hello Boost.Signals using Qt4 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostSignals.htm\">Hello Boost.Signals</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostSignalsQt4QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostSignalsQt4QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostSignalsQt5QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt5.png\" alt=\"Qt5\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostSignalsQt5QtCreatorLubuntuToWindows.htm\">Hello Boost.Signals using Qt5 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostSignals.htm\">Hello Boost.Signals</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostSignalsQt5QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostSignalsQt5QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostSignalsQtCreatorWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostSignalsQtCreatorWindows.htm\">Hello Boost.Signals using Qt Creator under Windows</a>",
        "  is a <a href=\"CppHelloBoostSignals.htm\">Hello Boost.Signals</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostSignalsQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloBoostSignalsQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostUblasQtCreatorCygwin",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicCygwin.png\" alt=\"Cygwin\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostUblasQtCreatorCygwin.htm\">Hello Boost.uBLAS using Qt Creator under Cygwin</a>",
        "  is a <a href=\"CppHelloBoostUblas.htm\">Hello Boost.uBLAS</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostUblasQtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloBoostUblasQtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostUblasQtCreatorLubuntu",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostUblasQtCreatorLubuntu.htm\">Hello Boost.uBLAS using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloBoostUblas.htm\">Hello Boost.uBLAS</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostUblasQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloBoostUblasQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostUblasQtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostUblasQtCreatorLubuntuToWindows.htm\">Hello Boost.uBLAS using Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostUblas.htm\">Hello Boost.uBLAS</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostUblasQtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostUblasQtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostUblasQtCreatorSliTaz",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostUblasQtCreatorSliTaz.htm\">Hello Boost.uBLAS using Qt Creator under SliTaz</a>",
        "  is a <a href=\"CppHelloBoostUblas.htm\">Hello Boost.uBLAS</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostUblasQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloBoostUblasQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostUblasQt4QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt4.png\" alt=\"Qt4\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostUblasQt4QtCreatorLubuntuToWindows.htm\">Hello Boost.uBLAS using Qt4 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostUblas.htm\">Hello Boost.uBLAS</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>"
        "  <li><a href=\"CppHelloBoostUblasQt4QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostUblasQt4QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostUblasQt5QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt5.png\" alt=\"Qt5\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostUblasQt5QtCreatorLubuntuToWindows.htm\">Hello Boost.uBLAS using Qt5 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostUblas.htm\">Hello Boost.uBLAS</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostUblasQt5QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostUblasQt5QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostUblasQtCreatorWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostUblasQtCreatorWindows.htm\">Hello Boost.uBLAS using Qt Creator under Windows</a>",
        "  is a <a href=\"CppHelloBoostUblas.htm\">Hello Boost.uBLAS</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostUblasQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloBoostUblasQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostXpressiveQtCreatorCygwin",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicCygwin.png\" alt=\"Cygwin\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostXpressiveQtCreatorCygwin.htm\">Hello Boost.Xpressive using Qt Creator under Cygwin</a>",
        "  is a <a href=\"CppHelloBoostXpressive.htm\">Hello Boost.Xpressive</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostXpressiveQtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloBoostXpressiveQtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostXpressiveQtCreatorLubuntu",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostXpressiveQtCreatorLubuntu.htm\">Hello Boost.Xpressive using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloBoostXpressive.htm\">Hello Boost.Xpressive</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostXpressiveQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloBoostXpressiveQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostXpressiveQtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostXpressiveQtCreatorLubuntuToWindows.htm\">Hello Boost.Xpressive using Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostXpressive.htm\">Hello Boost.Xpressive</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostXpressiveQtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostXpressiveQtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostXpressiveQtCreatorSliTaz",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostXpressiveQtCreatorSliTaz.htm\">Hello Boost.Xpressive using Qt Creator under SliTaz</a>",
        "  is a <a href=\"CppHelloBoostXpressive.htm\">Hello Boost.Xpressive</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostXpressiveQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloBoostXpressiveQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostXpressiveQt4QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt4.png\" alt=\"Qt4\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostXpressiveQt4QtCreatorLubuntuToWindows.htm\">Hello Boost.Xpressive using Qt4 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostXpressive.htm\">Hello Boost.Xpressive</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostXpressiveQt4QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostXpressiveQt4QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostXpressiveQt5QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQt5.png\" alt=\"Qt5\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostXpressiveQt5QtCreatorLubuntuToWindows.htm\">Hello Boost.Xpressive using Qt5 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloBoostXpressive.htm\">Hello Boost.Xpressive</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostXpressiveQt5QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloBoostXpressiveQt5QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloBoostXpressiveQtCreatorWindows",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloBoostXpressiveQtCreatorWindows.htm\">Hello Boost.Xpressive using Qt Creator under Windows</a>",
        "  is a <a href=\"CppHelloBoostXpressive.htm\">Hello Boost.Xpressive</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloBoostXpressiveQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloBoostXpressiveQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloCpp0xQtCreatorLubuntu",
      {
        "<p><img src=\"PicCpp0x.png\" alt=\"C++0x\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloCpp0xQtCreatorLubuntu.htm\">'HelloC++0x' using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloCpp0x.htm\">HelloC++0x</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloCpp0xQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloCpp0xQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloCpp0xQtCreatorSliTaz",
      {
        "<p><img src=\"PicCpp0x.png\" alt=\"C++0x\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloCpp0xQtCreatorSliTaz.htm\">'HelloC++0x' using Qt Creator under SliTaz</a> is a ",
        "  <a href=\"CppHelloCpp0x.htm\">HelloC++0x</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloCpp0xQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloCpp0xQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloCpp11QtCreatorCygwin",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicCygwin.png\" alt=\"Cygwin\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloCpp11QtCreatorCygwin.htm\">Hello C++11 using Qt Creator under Cygwin</a>",
        "  is a <a href=\"CppHelloCpp11.htm\">Hello C++11</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloCpp11QtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloCpp11QtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloCpp11QtCreatorLubuntu",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloCpp11QtCreatorLubuntu.htm\">Hello C++11 using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloCpp11.htm\">Hello C++11</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloCpp11QtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloCpp11QtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloCpp11QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloCpp11QtCreatorLubuntuToWindows.htm\">Hello C++11 using Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloCpp11.htm\">Hello C++11</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloCpp11QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloCpp11QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloCpp11QtCreatorSliTaz",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloCpp11QtCreatorSliTaz.htm\">Hello C++11 using Qt Creator under SliTaz</a>",
        "  is a <a href=\"CppHelloCpp11.htm\">Hello C++11</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloCpp11QtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloCpp11QtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloCpp11Qt4QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicQt4.png\" alt=\"Qt4\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloCpp11Qt4QtCreatorLubuntuToWindows.htm\">Hello C++11 using Qt4 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloCpp11.htm\">Hello C++11</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloCpp11Qt4QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloCpp11Qt4QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloCpp11Qt5QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicQt5.png\" alt=\"Qt5\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloCpp11Qt5QtCreatorLubuntuToWindows.htm\">Hello C++11 using Qt5 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloCpp11.htm\">Hello C++11</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloCpp11Qt5QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloCpp11Qt5QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloCpp11QtCreatorWindows",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloCpp11QtCreatorWindows.htm\">Hello C++11 using Qt Creator under Windows</a>",
        "  is a <a href=\"CppHelloCpp11.htm\">Hello C++11</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloCpp11QtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloCpp11QtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQtQtCreatorCygwin",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicCygwin.png\" alt=\"Cygwin\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQtQtCreatorCygwin.htm\">Hello Qt using Qt Creator under Cygwin</a>",
        "  is a <a href=\"CppHelloQt.htm\">Hello Qt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQtQtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloQtQtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQtQtCreatorLubuntu",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQtQtCreatorLubuntu.htm\">Hello Qt using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloQt.htm\">Hello Qt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQtQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloQtQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQtQtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQtQtCreatorLubuntuToWindows.htm\">Hello Qt using Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloQt.htm\">Hello Qt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQtQtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloQtQtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQtQtCreatorSliTaz",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQtQtCreatorSliTaz.htm\">Hello Qt using Qt Creator under SliTaz</a>",
        "  is a <a href=\"CppHelloQt.htm\">Hello Qt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQtQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloQtQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQtQt4QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQt4.png\" alt=\"Qt4\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQtQt4QtCreatorLubuntuToWindows.htm\">Hello Qt using Qt4 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloQt.htm\">Hello Qt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQtQt4QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloQtQt4QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQtQt5QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQt5.png\" alt=\"Qt5\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQtQt5QtCreatorLubuntuToWindows.htm\">Hello Qt using Qt5 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloQt.htm\">Hello Qt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQtQt5QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloQtQt5QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQtQtCreatorWindows",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQtQtCreatorWindows.htm\">Hello Qt using Qt Creator under Windows</a>",
        "  is a <a href=\"CppHelloQt.htm\">Hello Qt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQtQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloQtQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }

    }
  );
  m.push_back(
    { "CppHelloQwtQtCreatorCygwin",
      {
        "<p><img src=\"PicQwt.png\" alt=\"Qwt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicCygwin.png\" alt=\"Cygwin\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQwtQtCreatorCygwin.htm\">Hello Qwt using Qt Creator under Cygwin</a>",
        "  is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloQwtQtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQwtQtCreatorLubuntu",
      {
        "<p><img src=\"PicQwt.png\" alt=\"Qwt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQwtQtCreatorLubuntu.htm\">Hello Qwt using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloQwtQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQwtQtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicQwt.png\" alt=\"Qwt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQwtQtCreatorLubuntuToWindows.htm\">Hello Qwt using Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloQwtQtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQwtQtCreatorSliTaz",
      {
        "<p><img src=\"PicQwt.png\" alt=\"Qwt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQwtQtCreatorSliTaz.htm\">Hello Qwt using Qt Creator under SliTaz</a>",
        "  is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloQwtQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQwtQt4QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicQwt.png\" alt=\"Qwt\"/><img src=\"PicQt4.png\" alt=\"Qt4\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQwtQt4QtCreatorLubuntuToWindows.htm\">Hello Qwt using Qt4 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQt4QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloQwtQt4QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQwtQt5QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicQwt.png\" alt=\"Qwt\"/><img src=\"PicQt5.png\" alt=\"Qt5\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQwtQt5QtCreatorLubuntuToWindows.htm\">Hello Qwt using Qt5 under Qt Creator under Lubuntu, crosscompiled to Windows</a>",
        "  is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQt5QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloQwtQt5QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQwtQtCreatorWindows",
      {
        "<p><img src=\"PicQwt.png\" alt=\"Qwt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloQwtQtCreatorWindows.htm\">Hello Qwt using Qt Creator under Windows</a>",
        "  is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloQwtQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorld64QtCreatorLubuntu",
      {
        "<p>",
        "  <a href=\"CppHelloWorl64QtCreatorLubuntu.htm\">Hello World (64-bit) using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloWorld64.htm\">Hello World (64-bit)</a> program using the",
        "  <a href=\"CppQtCreator.htm\">Qt Creator</a> <a href=\"CppIde.htm\">IDE</a> under",
        "  the <a href=\"CppLubuntu.htm\">Lubuntu</a> <a href=\"CppOs.htm\">operating system</a>.",
        "</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorld64QtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloWorl64QtCreatorLubuntu' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>Compiling the code results in the following error:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Compile error\" border = \"1\"><tr><td><code>",
        "/usr/include/c++/4.5/iostream:39: error: bits/c++config.h: No such file or directory<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorCygwin",
      {
        "<p><a href=\"CppHelloWorldQtCreatorCygwin.htm\">Hello World using Qt Creator under Cygwin</a> is <a href=\"CppHelloWorld.htm\">Hello World</a> program",
        "using the <a href=\"CppQtCreator.htm\">Qt Creator</a>",
        "<a href=\"CppIde.htm\">IDE</a> under <a href=\"CppCygwin.htm\">Cygwin</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorLubuntu",
      {
        "<p><a href=\"CppHelloWorldQtCreatorLubuntu.htm\">Hello World using Qt Creator under Lubuntu</a> is <a href=\"CppHelloWorld.htm\">Hello World</a> program",
        "using the <a href=\"CppQtCreator.htm\">Qt Creator</a>",
        "<a href=\"CppIde.htm\">IDE</a> under <a href=\"CppLubuntu.htm\">Lubuntu</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"to\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppHelloWorldQtCreatorLubuntuToWindows.htm\">'Hello World' using Qt Creator under Lubuntu, crosscompile to Windows</a> is a",
        "<a href=\"CppHelloWorld.htm\">Hello World</a> program using the <a href=\"CppQtCreator.htm\">Qt Creator</a>",
        "<a href=\"CppIde.htm\">IDE</a> under the <a href=\"CppLubuntu.htm\">Lubuntu</a> <a href=\"CppOs.htm\">operating system</a>,",
        "<a href=\"CppCrossCompile.htm\">cross compiled</a> using <a href=\"CppMxe.htm\">MXE</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorSliTaz",
      {
        "<p><a href=\"CppHelloWorldQtCreatorSliTaz.htm\">Hello World using Qt Creator under SliTaz</a> is <a href=\"CppHelloWorld.htm\">Hello World</a> program",
        "using the <a href=\"CppQtCreator.htm\">Qt Creator</a>",
        "<a href=\"CppIde.htm\">IDE</a> under <a href=\"CppSliTaz.htm\">SliTaz</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorUbuntu",
      {
        "<p><a href=\"CppHelloWorldQtCreatorUbuntu.htm\">Hello World using Qt Creator under Ubuntu</a> is <a href=\"CppHelloWorld.htm\">Hello World</a> program",
        "using the <a href=\"CppQtCreator.htm\">Qt Creator</a>",
        "<a href=\"CppIde.htm\">IDE</a> under <a href=\"CppUbuntu.htm\">Ubuntu</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorUbuntu.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorUbuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorWindows",
      {
        "<p><a href=\"CppHelloWorldQtCreatorWindows.htm\">Hello World using Qt Creator under Windows</a> is <a href=\"CppHelloWorld.htm\">Hello World</a> program",
        "using the <a href=\"CppQtCreator.htm\">Qt Creator</a>",
        "<a href=\"CppIde.htm\">IDE</a> under <a href=\"CppWindows.htm\">Windows</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQwtQtCreatorLubuntu",
      {

        "<p><a href=\"CppHelloQwtQtCreatorLubuntu.htm\">'Hello Qwt' using Qt Creator under Lubuntu</a> is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a>",
        "program using the <a href=\"CppQtCreator.htm\">Qt Creator</a> <a href=\"CppIde.htm\">IDE</a> under the <a href=\"CppLubuntu.htm\">Lubuntu</a>",
        "<a href=\"CppOs.htm\">operating system</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQtCreatorLubuntu.png\">View a screenshot of 'CppHelloQwtQtCreatorLubuntu' (png)</a></li>",
        "  <li><a href=\"CppHelloQwtQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloQwtQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQwtQtCreatorUbuntu",
      {

        "<p><a href=\"CppHelloQwtQtCreatorUbuntu.htm\">'Hello Qwt' using Qt Creator under Ubuntu</a> is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a>",
        "program using the <a href=\"CppQtCreator.htm\">Qt Creator</a> <a href=\"CppIde.htm\">IDE</a> under",
        "the <a href=\"CppUbuntu.htm\">Ubuntu</a> <a href=\"CppOs.htm\">operating system</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQtCreatorUbuntu.png\">View a screenshot of 'CppHelloQwtQtCreatorUbuntu' (png)</a></li>",
        "  <li><a href=\"CppHelloQwtQtCreatorUbuntu.zip\">Download the Qt Creator project 'CppHelloQwtQtCreatorUbuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloQwtQtCreatorWindows",
      {
        "<p><a href=\"CppHelloQwtQtCreatorWindows.htm\">'Hello Qwt' using Qt Creator under Windows</a> is a <a href=\"CppHelloQwt.htm\">Hello Qwt</a>",
        "program using the <a href=\"CppQtCreator.htm\">Qt Creator</a> <a href=\"CppIde.htm\">IDE</a> under",
        "the <a href=\"CppWindows.htm\">Windows</a> <a href=\"CppOs.htm\">operating system</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloQwtQtCreatorWindows.png\">View a screenshot of 'CppHelloQwtQtCreatorWindows' (png)</a></li>",
        "  <li><a href=\"CppHelloQwtQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloQwtQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorCygwin",
      {
        "<p><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicCygwin.png\" alt=\"Cygwin\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloWorldQtCreatorCygwin.htm\">Hello World using Qt Creator under Cygwin</a>",
        "  is a <a href=\"CppHelloWorld.htm\">Hello World</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorCygwin.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorCygwin' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorLubuntu",
      {
        "<p><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelloWorldQtCreatorLubuntu.htm\">Hello World using Qt Creator under Lubuntu</a>",
        "  is a <a href=\"CppHelloWorld.htm\">Hello World</a> program.",
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorLubuntu.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorLubuntu' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppHelloWorldQtCreatorLubuntuToWindows.htm\">Hello World using Qt Creator under Lubuntu, crosscompiled to Windows</a> is a <a href=\"CppHelloWorld.htm\">Hello World</a> program.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorSliTaz",
      {
        "<p><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicSliTaz.png\" alt=\"SliTaz\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppHelloWorldQtCreatorSliTaz.htm\">Hello World using Qt Creator under SliTaz</a> is a <a href=\"CppHelloWorld.htm\">Hello World</a> program.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorSliTaz.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorSliTaz' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQt4QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQt4.png\" alt=\"Qt4\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppHelloWorldQt4QtCreatorLubuntuToWindows.htm\">Hello World using Qt4 under Qt Creator under Lubuntu, crosscompiled to Windows</a> is a <a href=\"CppHelloWorld.htm\">Hello World</a> program.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQt4QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloWorldQt4QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQt5QtCreatorLubuntuToWindows",
      {
        "<p><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQt5.png\" alt=\"Qt5\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicTo.png\" alt=\"To\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppHelloWorldQt5QtCreatorLubuntuToWindows.htm\">Hello World using Qt5 under Qt Creator under Lubuntu, crosscompiled to Windows</a> is a <a href=\"CppHelloWorld.htm\">Hello World</a> program.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQt5QtCreatorLubuntuToWindows.zip\">Download the Qt Creator project 'CppHelloWorldQt5QtCreatorLubuntuToWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppHelloWorldQtCreatorWindows",
      {
        "<p><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppHelloWorldQtCreatorWindows.htm\">Hello World using Qt Creator under Windows</a> is a <a href=\"CppHelloWorld.htm\">Hello World</a> program.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppHelloWorldQtCreatorWindows.zip\">Download the Qt Creator project 'CppHelloWorldQtCreatorWindows' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppHelp",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppHelp.htm\">Help</a> is a",
        "  <a href=\"CppClass.htm\">class</a> to display help information",
        "  in a command-line application.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppHtmlPage",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppHtmlPage.htm\">HtmlPage</a> is a <a href=\"CppClass.htm\">class</a>",
        "for processing an HTML page.</p>"
      }
    }
  );

  m.push_back(
    { "CppIfExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppIfExample1.htm\">if example 1: basics</a> is an <a href=\"CppIf.htm\">if</a> <a href=\"CppExample.htm\">example</a>.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppIfExample1.zip\">Download the Qt Creator project 'CppIfExample1' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppImageCanvas",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/><img src=\"PicWindows.png\" alt=\"Windows\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppImageCanvas.htm\">ImageCanvas</a> is a <a href=\"CppCanvas.htm\">Canvas</a>",
        "  to load images.",
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppIntToStr",
      {
        "<p>"
        "  <a href=\"CppIntToStr.htm\">IntToStr</a> is a <a href=\"CppCodeSnippets.htm\">code snippet</a> to "
        "  <a href=\"CppConvert.htm\">convert</a> an <a href=\"CppInt.htm\">int</a> to <a href=\"CppStdString.htm\">std::string</a>. "
        "  To <a href=\"CppConvert.htm\">convert</a> a <a href=\"CppStdString.htm\">std::string</a> to <a href=\"CppInt.htm\">int</a>, "
        "  use <a href=\"CppStrToInt.htm\">StrToInt</a>."
        "</p>"
      }
    }
  );


  m.push_back(
    { "CppIpAddress",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppIpAddress.htm\">IpAddress</a> is a <a href=\"CppClass.htm\">class</a>",
        "  for containing an IP address.",
        "</p>"
      }
    }
  );
  m.push_back(
    { "CppIrcBot",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppIrcBot.htm\">IrcBot</a> is a <a href=\"CppClass.htm\">class</a>",
        "for an IRC bot. Its default name is 'lambda'.</p>"
      }
    }
  );

  m.push_back(
    { "CppIsInt",
      {
        "<p>"
        "  <a href=\"CppIsInt.htm\">IsInt</a> is a <a href=\"CppCheck.htm\">checking</a>"
        "  <a href=\"CppCodeSnippets.htm\">code snippet</a> to <a href=\"CppCheck.htm\">check</a> if a"
        "  <a href=\"CppStdString.htm\">std::string</a> can be"
        "  <a href=\"CppConvert.htm\">converted</a> to an"
        "  <a href=\"CppInt.htm\">integer</a>."
        "</p>"
        "<p>&nbsp;</p>"
        "<p>"
        "  <a href=\"CppCanCast.htm\">CanCast</a> and"
        "  <a href=\"CppCanLexicalCast.htm\">CanLexicalCast</a> are more general versions"
        "  of <a href=\"CppIsInt.htm\">IsInt</a>."
        "</p>"
      }
    }
  );

  m.push_back(
    { "CppIsRegularFile",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppIsRegularFile.htm\">IsRegularFile</a> is a <a href=\"CppFileIo.htm\">file I/O</a>  <a href=\"CppCodeSnippets.htm\">code snippet</a> to determine if a filename is a regular file.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppIsRegularFile.zip\">Download the Qt Creator project 'CppIsRegularFile' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppKalmanFilter",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>The <a href=\"CppKalmanFilter.htm\">Kalman filter</a> is a way to do predictions from noisy measurements. For a (far) more precise",
        "definition, see [1].</p>",
        "<p>&nbsp;</p>",
        "<p>The <a href=\"Tools.htm\">tool</a> <a href=\"ToolKalmanFilterer.htm\">KalmanFilterer</a> allows one to work with <a href=\"CppKalmanFilter.htm\">Kalman filters</a>.</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>Examples</h2>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppKalmanFilterExample1.htm\">Kalman filter example 1: single state, from adapted C code</a></li>",
        "  <li><a href=\"CppKalmanFilterExample2.htm\">Kalman filter example 2: single state, use of classes</a></li>",
        "  <li><a href=\"CppKalmanFilterExample3.htm\">Kalman filter example 3: single state, use of 1x1 boost::numeric::ublas::matrix</a></li>",
        "  <li><a href=\"CppKalmanFilterExample4.htm\">Kalman filter example 4: single state, use of 1x1 boost::numeric::ublas::matrix and boost::numeric::ublas::vector</a></li>",
        "  <li><a href=\"CppKalmanFilterExample5.htm\">Kalman filter example 5</a></li>",
        "  <li><a href=\"CppKalmanFilterExample6.htm\">Kalman filter example 6</a></li>",
        "  <li><a href=\"CppKalmanFilterExample7.htm\">Kalman filter example 7</a></li>",
        "  <li><a href=\"CppKalmanFilterExample8.htm\">Kalman filter example 8: displaying the graphs (initial)</a></li>",
        "  <li><a href=\"CppKalmanFilterExample9.htm\">Kalman filter example 9: displaying the graphs (better)</a></li>",
        "  <li><a href=\"CppKalmanFilterExample10.htm\">Kalman filter example 10: displaying the graphs (even better)</a></li>",
        "  <li><a href=\"CppKalmanFilterExample11.htm\">Kalman filter example 11: displaying the graphs (best)</a></li>",
        "  <li><a href=\"CppKalmanFilterExample12.htm\">Kalman filter example 12: displaying the equations</a></li>",
        "  <li><a href=\"CppKalmanFilterExample13.htm\">Kalman filter example 13: displaying the equations only</a></li>",
        "  <li><a href=\"ToolKalmanFilterer.htm\">KalmanFilterer</a>: <a href=\"Tools.htm\">tool</a> to work with <a href=\"CppKalmanFilter.htm\">Kalman filters</a></li>",
        "  <li><a href=\"CppKalmanFilterEquations.png\">Kalman filter equations</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppReferences.htm\">References</a></h2>",
        "<p>&nbsp;</p>",
        "<ol>",
        "  <li><a href=\"https://en.wikipedia.org/wiki/Kalman_filter\">Wikipedia page about the Kalman filter</a></li>",
        "  <li><a href=\"http://academic.csuohio.edu/simond/estimation\">Kalman filter examples (in Matlab)</a></li>",
        "  <li><a href=\"http://greg.czerniak.info/guides/kalman1/\">Kalman filter tutorial by Greg Czerniak</a></li>",
        "</ol>"
      }
    }
  );
  m.push_back(
    { "CppLazy_init",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLazy_init.htm\">Lazy_init</a> is a <a href=\"CppClass.htm\">class</a></p>",
        "<p>with lazy initialization.</p>"
      }
    }
  );
  m.push_back(
    { "CppLed",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLed.htm\">Led</a> is a <a href=\"CppClass.htm\">class</a> for an LED light.</p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLed.htm\">Led</a> is used in the <a href=\"Tools.htm\">tool</a> <a href=\"ToolTestLed.htm\">TestLed</a>.</p>"
      }
    }
  );
  m.push_back(
    { "CppLedWidget",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppLedWidget.htm\">LedWidget</a> is a <a href=\"CppLed.htm\">Led</a>",
        "  <a href=\"CppWidget.htm\">widget</a>.",
        "</p>"
      }
    }
  );
  m.push_back(
    { "CppLinkErrorCannotFindLgstapp",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLinkErrorCannotFindLgstapp.htm\">cannot find -lgstapp-0.10</a> is a",
        "<a href=\"CppLinkError.htm\">link error</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppLinkErrorCannotFindLgstapp.zip\">Download the Qt Creator project 'CppLinkErrorCannotFindLgstapp' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>This bug is reported with this <a href=\"https://bugs.launchpad.net/ubuntu/+source/qtwebkit-opensource-src/+bug/1134745\">Launchpad bug report</a>",
        "and another <a href=\"https://bugs.launchpad.net/ubuntu/+source/qtbase-opensource-src/+bug/1165250\">Launchpad bug report</a>.</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>Solution</h2>",
        "<p>&nbsp;</p>",
        "<p>Install some gstreamer packages:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"fileMMYf2H.txt\" border = \"1\"><tr><td><code>",
        "sudo apt-get install libgstreamer1.0-dev <br/>",
        "sudo apt-get install libgstreamer0.10-dev <br/>",
        "sudo apt-get install libgstreamer-plugins-base1.0-dev <br/>",
        "sudo apt-get install libgstreamer-plugins-base0.10-dev <br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->"
      }
    }
  );

  m.push_back(
    { "CppLibcvautomationExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLibcvautomationExample1.htm\">libcvautomation example 1: using an example</a> is a",
        "<a href=\"CppLibcvautomation.htm\">libcvautomation</a> <a href=\"CppExample.htm\">example</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppLibcvautomationExample1.zip\">Download the code 'CppLibcvautomationExample1' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>After successfully building libcvautomation, there will be two executables in [YOURPATH]/libcvautomation/examples. An executable",
        "called 'cva-input' will be used by the shell script. Copy the script to [YOURPATH]/libcvautomation/examples and run it.</p>",
        "<p>&nbsp;</p>",
        "<p>The script performs a left-mouse click on coordinat (100,100).</p>",
        "<p>&nbsp;</p>",
        "<table summary=\"libcvautomation example 1: using an example example 1\" border = \"1\"><tr><td><code>",
        "#!/bin/sh<br/>",
        "./cva-input -s \"mouselocation\" <br/>",
        "./cva-input -s \"mousexy 100 100\" <br/>",
        "./cva-input -s \"mouseclick\"<br/>",
        "./cva-input -s \"mouselocation\"<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->"
      }
    }
  );
  m.push_back(
    { "CppLibcvautomationExample2",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLibcvautomationExample2.htm\">libcvautomation example 2: Qt Creator project around example (using C)</a> is a",
        "<a href=\"CppLibcvautomation.htm\">libcvautomation</a> example of a <a href=\"CppQtCreator.htm\">Qt Creator</a> project around",
        "an example supplied by Bradlee Speice (the author of libcvautomation). Note that the project is set to compile C code, instead of C++.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppLibcvautomationExample2.zip\">Download the Qt Creator project 'CppLibcvautomationExample2' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppLibcvautomationExample3",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLibcvautomationExample3.htm\">libcvautomation example 3: Qt Creator project around example</a> is a",
        "<a href=\"CppLibcvautomation.htm\">libcvautomation</a> example of a <a href=\"CppQtCreator.htm\">Qt Creator</a> project around",
        "an example supplied by Bradlee Speice (the author of libcvautomation). This example uses C++, but does not compile cleanly and uses tabs.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppLibcvautomationExample3.zip\">Download the Qt Creator project 'CppLibcvautomationExample3' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppLibcvautomationExample4",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLibcvautomationExample4.htm\">libcvautomation example 4: Qt Creator project around adapted example</a> is a",
        "<a href=\"CppLibcvautomation.htm\">libcvautomation</a> example of a <a href=\"CppQtCreator.htm\">Qt Creator</a> project around",
        "an example supplied by Bradlee Speice (the author of libcvautomation). This example uses C++ and compiles cleanly and has the tabs replaced by spaces.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppLibcvautomationExample4.zip\">Download the Qt Creator project 'CppLibcvautomationExample4' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppLibcvautomationExample5",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLibcvautomationExample5.htm\">libcvautomation example 5: basic Qt GUI</a> is a",
        "<a href=\"CppLibcvautomation.htm\">libcvautomation</a> example of a <a href=\"CppQtCreator.htm\">Qt Creator</a> project with",
        "a basic GUI to give commands.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppLibcvautomationExample5.png\">View a screenshot of 'CppLibcvautomationExample5' (png)</a></li>",
        "  <li><a href=\"CppLibcvautomationExample5.zip\">Download the Qt Creator project 'CppLibcvautomationExample5' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppLibcvautomationExample6",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLibcvautomationExample6.htm\">libcvautomation example 6: test a simple Qt desktop application</a> is a",
        "<a href=\"CppLibcvautomation.htm\">libcvautomation</a> example with a simple Qt desktop application and a ",
        "<a href=\"CppLibcvautomation.htm\">libcvautomation</a> test script. The application is called from the script, and has three",
        "buttons: two labeled 'Press me' and one labeled 'DON'T PRESS ME'. The test presses both 'Press me' buttons (their text will change",
        "to 'OK') and then click the 'DON'T PRESS ME' button, which causes an error.</p>",
        "<p>&nbsp;</p>",
        "<p>For the testing script, I have supplied part of screenshots of the application. I guess that would I change my desktop theme (for example: using",
        "a black theme), the test will not find the buttons anymore.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppLibcvautomationExample6.png\">View a screenshot of 'CppLibcvautomationExample6' (png)</a></li>",
        "  <li><a href=\"CppLibcvautomationExample6.zip\">Download the Qt Creator project 'CppLibcvautomationExample6' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppLibcvautomationExample7",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLibcvautomationExample7.htm\">libcvautomation example 7: test a simple Qt desktop application by sending keys</a> is a",
        "<a href=\"CppLibcvautomation.htm\">libcvautomation</a> example with a simple Qt desktop application and a ",
        "<a href=\"CppLibcvautomation.htm\">libcvautomation</a> test script. The application is called from the script, and has three",
        "buttons: two labeled 'Press me' and one labeled 'DON'T PRESS ME'. The test presses the tab and space keys, which causes that the upper 'Press me' button",
        "its text will change to OK, after which the 'DON'T PRESS ME' button is pressed, which causes an error.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppLibcvautomationExample7.zip\">Download the Qt Creator project 'CppLibcvautomationExample7' (zip)</a></li>",
        "</ul>"
      }
    }
  );

  m.push_back(
    { "CppLinkErrorUndefinedReferenceToWebCore",
      {
        "<p><img src=\"PicQt.png\" alt=\"Qt\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppLinkErrorUndefinedReferenceToWebCore.htm\">CppLinkErrorUndefinedReferenceToWebCore</a> is a",
        "<a href=\"CppLinkError.htm\">link error</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppLinkErrorUndefinedReferenceToWebCore.zip\">Download the Qt Creator project 'CppLinkErrorUndefinedReferenceToWebCore' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppLoopReader",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppLoopReader.htm\">LoopReader</a> is a",
        "  <a href=\"CppTemplateClass.htm\">template class</a> to iterate",
        "  through a <a href=\"CppContainer.htm\">container</a>. If the",
        "  <a href=\"CppContainer.htm\">container</a>'s end is",
        "  reached, however, <a href=\"CppLoopReader.htm\">LoopReader</a> starts reading",
        "  from the beginning again.",
        "</p>"
      }
    }
  );
  m.push_back(
    { "CppManyDigitNewick",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  A <a href=\"CppNewick.htm\">Newick</a> <a href=\"CppClass.htm\">class</a>.",
        "</p>"
      }
    }
  );
  m.push_back(
    { "CppMatrix",
      {
        "<p><img src=\"PicBoost.png\" alt=\"Boost\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppMatrix.htm\">matrix</a> is a two-dimensional <a href=\"CppContainer.htm\">container</a>",
        "  (that is a <a href=\"CppContainer.htm\">container</a> in which two values",
        "  are needed to retrieve an element). For one-dimensional containers,",
        "  <a href=\"CppContainer.htm\">go to the container page</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>There exists no std::matrix (yet).</p>",
        "<p>&nbsp;</p>",
        "<p>Possibilities are:</p>",
        "<ol>",
        "  <li><img src=\"PicCpp98.png\" alt=\"C++98\"/><img src=\"PicStl.png\" alt=\"STL\"/> <a href=\"CppStdVector.htm\">std::vector</a>&lt;<a href=\"CppStdVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt;</li>",
        "  <li><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicStl.png\" alt=\"STL\"/> <a href=\"CppStdArray.htm\">std::array</a>&lt;<a href=\"CppStdArray.htm\">std::array</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt;</li>",
        "  <li><img src=\"PicBoost.png\" alt=\"Boost\"/> <a href=\"CppMulti_array.htm\">boost::multi_array</a></li>",
        "  <li><img src=\"PicBoost.png\" alt=\"Boost\"/> <a href=\"CppUblasMatrix.htm\">boost::numeric::ublas::matrix</a></li>",
        "  <li><img src=\"PicSpacer.png\" alt=\" \"/>blitz::Array</li>",
        "  <li><img src=\"PicSpacer.png\" alt=\" \"/><a href=\"http://www.techsoftpl.com/matrix\">Techsoft</a>'s matrix</li>",
        "  <li><img src=\"PicSpacer.png\" alt=\" \"/>Flood::Matrix</li>",
        "</ol>",
        "<p>&nbsp;</p>",
        "<p>These possibilities are described below in more detail.</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><img src=\"PicStl.png\" alt=\"STL\"/> <a href=\"CppVector.htm\">std::vector</a>&lt;<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt;</h2>",
        "<p>&nbsp;</p>",
        "<p>",
        "  A <a href=\"CppVector.htm\">std::vector</a> can contain a collection of",
        "  <a href=\"CppVector.htm\">std::vector</a>s. If all",
        "  <a href=\"CppVector.htm\">std::vector</a>s in this collection are of the same",
        "  size, one has a matrix.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>When using <a href=\"CppVector.htm\">std::vector</a>&lt;<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt; for a two-dimensional matrix, the choice between x-y-ordering or y-x-ordering must be made. The run-time speed difference does not reside in individual element read/write, but when obtaining a row or collumn: in a y-x-ordered <a href=\"CppVector.htm\">std::vector</a>&lt;<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt; an individual row can be obtained, in an x-y-ordered <a href=\"CppVector.htm\">std::vector</a>&lt;<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt; an individual collumn can be obtained.</p>",
        "<p>&nbsp;</p>",
        "<p>Below is an example of a y-x-ordered <a href=\"CppVector.htm\">std::vector</a>&lt;<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt;.</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"2D vector example\" border = \"1\"><tr><td><code>",
        "<a href=\"CppInclude.htm\">#include</a> &lt;<a href=\"CppCassertH.htm\">cassert</a>&gt;<br/>",
        "<a href=\"CppInclude.htm\">#include</a> &lt;<a href=\"CppVectorH.htm\">vector</a>&gt;<br/>",
        "<br/>",
        "<b><a href=\"CppInt.htm\">int</a></b> <a href=\"CppMain.htm\">main</a>()<br/>",
        "{<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> n_rows <a href=\"CppOperatorAssign.htm\">=</a> 5;<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> n_cols <a href=\"CppOperatorAssign.htm\">=</a> 10;<br/>",
        "&nbsp;&nbsp;<a href=\"CppComment.htm\">//</a>Create the y-x-ordered 2D-vector<br/>",
        "&nbsp;&nbsp;<a href=\"CppVector.htm\">std::vector</a>&lt;<a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; &gt; v(n_rows, <a href=\"CppVector.htm\">std::vector</a>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt;(n_cols,0),<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> y <a href=\"CppOperatorAssign.htm\">=</a> n_rows <a href=\"CppOperatorMinus.htm\">-</a> 1;<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> x <a href=\"CppOperatorAssign.htm\">=</a> n_cols <a href=\"CppOperatorMinus.htm\">-</a> 1;<br/>",
        "&nbsp;&nbsp;<a href=\"CppAssert.htm\">assert</a>(y &lt; <b><a href=\"CppStatic_cast.htm\">static_cast</a></b>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt;(v.size()),<br/>",
        "&nbsp;&nbsp;<a href=\"CppAssert.htm\">assert</a>(x &lt; <b><a href=\"CppStatic_cast.htm\">static_cast</a></b>&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt;(v[y].size()),<br/>",
        "&nbsp;&nbsp;v[y][x] <a href=\"CppOperatorAssign.htm\">=</a> 10; <a href=\"CppComment.htm\">//</a>y-x-ordered<br/>",
        "}<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h3><a href=\"CppVector.htm\">std::vector</a>&lt;<a href=\"CppVector.htm\">std::vector</a>&lt;<a href=\"CppInt.htm\">int</a>&gt; &gt; <a href=\"CppCodeSnippets.htm\">code snippets</a></h3>",
        "<p>&nbsp;</p>",
        "<p>Note that some of these <a href=\"CppCodeSnippets.htm\">code snippets</a> also work on other <a href=\"CppContainer.htm\">containers</a>.</p>",
        "<p>&nbsp;</p>",
        "<ol>",
        "  <li><a href=\"CppConvertMatrix.htm\">Convert Matrix&lt;X&gt; to Matrix&lt;Y&gt;, ConvertMatrix</a></li>",
        "  <li><a href=\"CppConvertMatrix.htm\">Convert std::vector&lt;std::vector&lt;X&gt; &gt; to std::vector&lt;std::vector&lt;Y&gt; &gt;, ConvertMatrix</a></li>",
        "  <li><a href=\"CppConvertMatrix.htm\">Convert two 2D std::vector&lt;X&gt; to 2D std::vector&lt;Y&gt;, ConvertMatrix</a></li>",
        "  <li><a href=\"CppConvertMatrix.htm\">ConvertMatrix, convert Matrix&lt;X&gt; to Matrix&lt;Y&gt;</a></li>",
        "  <li><a href=\"CppConvertMatrix.htm\">ConvertMatrix, convert std::vector&lt;std::vector&lt;X&gt; &gt; to std::vector&lt;std::vector&lt;Y&gt; &gt;</a></li>",
        "  <li><a href=\"CppConvertMatrix.htm\">ConvertMatrix, convert two 2D std::vector&lt;X&gt; to 2D std::vector&lt;Y&gt;</a></li>",
        "  <li><a href=\"CppMaxElement.htm\">Get the maximal element of a 2D container, MaxElement</a></li>",
        "  <li><a href=\"CppMinElement.htm\">Get the minimum element of a 2D container, MinElement</a></li>",
        "  <li><a href=\"CppGetSizes.htm\">Get the sizes of the std::vectors in a 2D std::vector, GetSizes</a></li>",
        "  <li><a href=\"CppGetSumMatrix.htm\">Get the sum of a 2D std::vector, GetSum</a></li>",
        "  <li><a href=\"CppGetSizes.htm\">GetSizes, get the sizes of the std::vectors in a 2D std::vector</a></li>",
        "  <li><a href=\"CppGetSumMatrix.htm\">GetSum, get the sum of a 2D std::vector</a></li>",
        "  <li><a href=\"CppMaxElement.htm\">MaxElement, get the maximal element of a 2D container</a></li>",
        "  <li><a href=\"CppMinElement.htm\">MinElement, get the minimum element of a 2D container</a></li>",
        "</ol>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><img src=\"PicBoost.png\" alt=\"Boost\"/> <a href=\"CppMulti_array.htm\">boost::multi_array</a></h2>",
        "<p>&nbsp;</p>",
        "<p>The <a href=\"CppMulti_array.htm\">boost::multi_array</a> (part of the <a href=\"CppBoost.htm\">Boost</a> library) is not only support a two-dimensional matrix, but to many more dimensions.</p>",
        "<p>&nbsp;</p>",
        "<p>When using <a href=\"CppBuilder.htm\">C++ Builder</a> 6.0, this does not <a href=\"CppCompile.htm\">compile</a> (it results in the <a href=\"CppCompileError.htm\">compile error</a> <a href=\"CppCompileErrorBorlandHppOnlyMemberFunctionsMayBeConstOrVolatile.htm\">borland.hpp: Only member functions may be 'const' or 'volatile'</a>).</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><img src=\"PicBoost.png\" alt=\"Boost\"/> <a href=\"CppUblasMatrix.htm\">boost::numeric::ublas::matrix</a></h2>",
        "<p>&nbsp;</p>",
        "<p>The <a href=\"CppUblasMatrix.htm\">boost::numeric::ublas::matrix</a> (part of the ",
        "<a href=\"CppUblas.htm\">Boost.uBLAS</a> <a href=\"CppLibrary.htm\">library</a>) support a two-dimensional matrix.</p>",
        "<p>&nbsp;</p>",
        "<p>See <a href=\"CppUblasMatrix.htm\">boost::numeric::ublas::matrix</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><img src=\"PicGreen.png\" alt=\"OKAY\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/> In <a href=\"CppQtCreator.htm\">Qt Creator</a> <a href=\"CppUblasMatrix.htm\">boost::numeric::ublas::matrix</a> works fine</li>",
        "  <li><img src=\"PicRed.png\" alt=\"FAIL\"/><img src=\"PicCppBuilder.png\" alt=\"C++ Builder\"/> In <a href=\"CppBuilder.htm\">C++ Builder</a> 6.0, this does not <a href=\"CppCompile.htm\">compile</a> (it results in the <a href=\"CppCompileError.htm\">compile error</a> <a href=\"CppCompileErrorYourCompilerAndOrConfigurationIsUnsupportedByThisVerionsOfUblas.htm\">Your compiler and/or configuration is unsupported by this verions of uBLAS</a>)</li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>blitz::Array</h2>",
        "<p>&nbsp;</p>",
        "<p>The blitz::Array (part of the <a href=\"CppBlitzpp.htm\">Blitz++</a> <a href=\"CppLibrary.htm\">library</a>) is not only support a two-dimensional matrix, but to many more dimensions.</p>",
        "<p>&nbsp;</p>",
        "<p>When using <a href=\"CppBuilder.htm\">C++ Builder</a> 6.0, this does not <a href=\"CppCompile.htm\">compile</a> (it results in the <a href=\"CppCompileError.htm\">compile error</a> <a href=\"CppCompileErrorBzconfigHunknownCompiler.htm\">bzconfig.h: Unknown compiler</a>).</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"http://www.techsoftpl.com/matrix\">Techsoft</a>'s matrix</h2>",
        "<p>&nbsp;</p>",
        "<p><a href=\"http://www.techsoftpl.com/matrix\">Techsoft</a>'s matrix supports a x-y-ordered two-dimensional matrix.</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Techsoft matrix example\" border = \"1\"><tr><td><code>",
        "<a href=\"CppInclude.htm\">#include</a> &lt;<a href=\"CppCassertH.htm\">cassert</a>&gt;<br/>",
        "<a href=\"CppInclude.htm\">#include</a> &lt;techsoft/matrix.h&gt;<br/>",
        "<br/>",
        "<b><a href=\"CppInt.htm\">int</a></b> <a href=\"CppMain.htm\">main</a>()<br/>",
        "{<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> n_rows <a href=\"CppOperatorAssign.htm\">=</a> 5;<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> n_cols <a href=\"CppOperatorAssign.htm\">=</a> 10;<br/>",
        "&nbsp;&nbsp;math::matrix&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; v(n_rows,n_cols,<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> y <a href=\"CppOperatorAssign.htm\">=</a> n_rows <a href=\"CppOperatorMinus.htm\">-</a> 1;<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> x <a href=\"CppOperatorAssign.htm\">=</a> n_cols <a href=\"CppOperatorMinus.htm\">-</a> 1;<br/>",
        "&nbsp;&nbsp;<a href=\"CppAssert.htm\">assert</a>(v(x,y)<a href=\"CppOperatorEqual.htm\">==</a>0,<br/>",
        "&nbsp;&nbsp;v(x,y) <a href=\"CppOperatorAssign.htm\">=</a> 10;<br/>",
        "&nbsp;&nbsp;<a href=\"CppAssert.htm\">assert</a>(v(x,y)<a href=\"CppOperatorEqual.htm\">==</a>10,<br/>",
        "}<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>Flood::Matrix</h2>",
        "<p>&nbsp;</p>",
        "<p>The Flood::Matrix (from the <a href=\"CppFlood.htm\">Flood</a> library) supports a x-y-ordered two-dimensional matrix.</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Flood::Matrix example\" border = \"1\"><tr><td><code>",
        "<a href=\"CppInclude.htm\">#include</a> &lt;<a href=\"CppCassertH.htm\">cassert</a>&gt;<br/>",
        "<a href=\"CppInclude.htm\">#include</a> &lt;flood/utilities/matrix.h&gt;<br/>",
        "&nbsp;<br/>",
        "<b><a href=\"CppInt.htm\">int</a></b> <a href=\"CppMain.htm\">main</a>()<br/>",
        "{<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> n_rows <a href=\"CppOperatorAssign.htm\">=</a> 5;<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> n_cols <a href=\"CppOperatorAssign.htm\">=</a> 10;<br/>",
        "&nbsp;&nbsp;Flood::Matrix&lt;<b><a href=\"CppInt.htm\">int</a></b>&gt; v(n_rows,n_cols,<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> y <a href=\"CppOperatorAssign.htm\">=</a> n_rows <a href=\"CppOperatorMinus.htm\">-</a> 1;<br/>",
        "&nbsp;&nbsp;<b><a href=\"CppConst.htm\">const</a></b> <b><a href=\"CppInt.htm\">int</a></b> x <a href=\"CppOperatorAssign.htm\">=</a> n_cols <a href=\"CppOperatorMinus.htm\">-</a> 1;<br/>",
        "&nbsp;&nbsp;<a href=\"CppAssert.htm\">assert</a>( x &lt; v.getNumberOfRows(),<br/>",
        "&nbsp;&nbsp;<a href=\"CppAssert.htm\">assert</a>( y &lt; v.getNumberOfColumns(),<br/>",
        "&nbsp;&nbsp;<a href=\"CppAssert.htm\">assert</a>(v[x][y]<a href=\"CppOperatorEqual.htm\">==</a>0,<br/>",
        "&nbsp;&nbsp;v[x][y] <a href=\"CppOperatorAssign.htm\">=</a> 10;<br/>",
        "&nbsp;&nbsp;<a href=\"CppAssert.htm\">assert</a>(v[x][y]<a href=\"CppOperatorEqual.htm\">==</a>10,<br/>",
        "}<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>External links</h2>",
        "<p>&nbsp;</p>",
        "<ol>",
        "  <li><a href=\"http://en.wikipedia.org/wiki/Matrix_%28mathematics%29\">Wikipedia page about matrices</a></li>",
        "  <li><a href=\"http://www.boost.org/doc/libs/1_42_0/libs/multi_array/doc/index.html\">Boost page about boost::multi_array</a></li>",
        "  <li><a href=\"http://www.oonumerics.org/blitz\">Blitz++ homepage</a></li>",
        "  <li><a href=\"http://www.techsoftpl.com/matrix\">Techsoft homepage</a></li>",
        "</ol>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2><a href=\"CppReferences.htm\">References</a></h2>",
        "<p>&nbsp;</p>",
        "<ol>",
        "  <li><a href=\"http://en.wikipedia.org/wiki/Matrix_%28mathematics%29\">Wikipedia page about matrices</a></li>",
        "</ol>"
      }
    }
  );

  m.push_back(
    { "CppMemberFunctionExample1",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  <a href=\"CppMemberFunctionExample1.htm\">member function example 1: Hello World</a>",
        "  is a <a href=\"CppMemberFunction.htm\">member function</a> <a href=\"CppExample.htm\">example</a>.",
        "</p>",
        "<p>&nbsp;</p>",
        "<p>",
        "  The class 'HelloWorld' has a single <a href=\"CppConstMemberFunction.htm\">const member function</a> called",
        "  'SayHelloWorld'. It is called in <a href=\"CppMain.htm\">main</a>, producing the same output as",
        "  a <a href=\"CppHelloWorld.htm\">Hello World program</a>."
        "</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppMemberFunctionExample1.zip\">Download the Qt Creator project 'CppMemberFunctionExample1' (zip)</a></li>",
        "</ul>"
      }
    }
  );
  m.push_back(
    { "CppMemberFunctionExample2",
      {
        "<p><img src=\"PicCpp11.png\" alt=\"C++11\"/><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppMemberFunctionExample2.htm\">member function example 2: pointer to member functions</a> is a <a href=\"CppMemberFunction.htm\">member function</a> <a href=\"CppExample.htm\">example</a>.",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppMemberFunctionExample2.zip\">Download the Qt Creator project 'CppMemberFunctionExample2' (zip)</a></li>",
        "</ul>"
      }
    }
  );


  m.push_back(
    { "CppMemcheckExample1",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppMemcheckExample1.htm\">memcheck example 1: Hello World</a> is a <a href=\"CppMemcheck.htm\">memcheck</a> example shows how ",
        "to check a <a href=\"CppHelloWorld.htm\">Hello world</a>",
        "program for, among others, <a href=\"CppMemoryLeak.htm\">memory leaks</a>.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppMemcheckExample1.zip\">Download the Qt Creator project 'CppMemcheckExample1' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppValgrind.htm\">valgrind</a> can be used from command line:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"Command to start memgrind\" border = \"1\"><tr><td><code>",
        "<a href=\"CppValgrind.htm\">valgrind</a> --leak-check=full -v --show-reachable=yes --log-file=my_log_filename.txt ./my_executable_filename<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>valgrind_memcheck.txt</h2>",
        "<p>&nbsp;</p>",
        "<p>I got the following output:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"memcheck result\" border = \"1\"><tr><td><code>",
        "==13471== Memcheck, a memory error detector<br/>",
        "==13471== Copyright (C) 2002-2010, and GNU GPL'd, by Julian Seward et al.<br/>",
        "==13471== Using Valgrind-3.6.1 and LibVEX; rerun with -h for copyright info<br/>",
        "==13471== Command: ../CppMemcheckExample1-build-desktop/./CppMemcheckExample1<br/>",
        "==13471== Parent PID: 13470<br/>",
        "==13471== <br/>",
        "--13471-- <br/>",
        "--13471-- Valgrind options:<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;--suppressions=/usr/lib/valgrind/debian-libc6-dbg.supp<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;--leak-check=full<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;-v<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;--show-reachable=yes<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;--log-file=valgrind_memcheck.txt<br/>",
        "--13471-- Contents of /proc/version:<br/>",
        "--13471--&nbsp;&nbsp; Linux version 2.6.38-8-generic-pae (buildd@vernadsky) (gcc version 4.5.2 (Ubuntu/Linaro 4.5.2-8ubuntu3) ) #42-Ubuntu SMP Mon Apr 11 05:17:09 UTC 2011<br/>",
        "--13471-- Arch and hwcaps: X86, x86-sse1-sse2<br/>",
        "--13471-- Page sizes: currently 4096, max supported 4096<br/>",
        "--13471-- Valgrind library directory: /usr/lib/valgrind<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/ld-2.13.so (0x4000000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/ld-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 2a2c2799 wanted 1e351f1f)<br/>",
        "--13471--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/ld-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13471-- Reading syms from /home/richel/Projects/Website/CppMemcheckExample1-build-desktop/CppMemcheckExample1 (0x8048000)<br/>",
        "--13471-- Reading syms from /usr/lib/valgrind/memcheck-x86-linux (0x38000000)<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a dynamic symbol table<br/>",
        "--13471-- Reading suppressions file: /usr/lib/valgrind/debian-libc6-dbg.supp<br/>",
        "--13471-- Reading suppressions file: /usr/lib/valgrind/default.supp<br/>",
        "--13471-- REDIR: 0x4016a80 (index) redirected to 0x3803f82b (vgPlain_x86_linux_REDIR_FOR_index)<br/>",
        "--13471-- Reading syms from /usr/lib/valgrind/vgpreload_core-x86-linux.so (0x4020000)<br/>",
        "--13471-- Reading syms from /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so (0x4023000)<br/>",
        "==13471== WARNING: new redirection conflicts with existing -- ignoring it<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp; new: 0x04016a80 (index&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ) R-&gt; 0x04026c78 index<br/>",
        "--13471-- REDIR: 0x4016c20 (strlen) redirected to 0x4027048 (strlen)<br/>",
        "--13471-- Reading syms from /usr/lib/libQtCore.so.4.7.2 (0x4043000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /usr/lib/libQtCore.so.4.7.2 ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 0c8a8d9d wanted ce78deb8)<br/>",
        "--13471--&nbsp;&nbsp; Considering /usr/lib/debug/usr/lib/libQtCore.so.4.7.2 ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/libpthread-2.13.so (0x42d6000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libpthread-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 87269ed5 wanted 7df95f2f)<br/>",
        "--13471--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libpthread-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13471-- Reading syms from /usr/lib/i386-linux-gnu/libstdc++.so.6.0.14 (0x42ef000)<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/libm-2.13.so (0x43da000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libm-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed e686ed93 wanted a0f1e52c)<br/>",
        "--13471--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libm-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/libgcc_s.so.1 (0x4400000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libgcc_s.so.1 ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 3fa6d24f wanted 8b2bf89f)<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/libc-2.13.so (0x441c000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libc-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 97e88cd2 wanted 4635a554)<br/>",
        "--13471--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libc-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/libz.so.1.2.3.4 (0x457e000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libz.so.1.2.3.4 ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 995eb12f wanted 33a06a21)<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/libdl-2.13.so (0x4593000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libdl-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 608d0daf wanted 983d6578)<br/>",
        "--13471--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libdl-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13471-- Reading syms from /usr/lib/i386-linux-gnu/libgthread-2.0.so.0.2800.6 (0x4597000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /usr/lib/i386-linux-gnu/libgthread-2.0.so.0.2800.6 ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 244482a3 wanted 61a9cd3c)<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/librt-2.13.so (0x459c000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/librt-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 680ec6ea wanted 247d4d27)<br/>",
        "--13471--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/librt-2.13.so ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/libglib-2.0.so.0.2800.6 (0x45a5000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libglib-2.0.so.0.2800.6 ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 2312631e wanted e21a44de)<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13471-- Reading syms from /lib/i386-linux-gnu/libpcre.so.3.12.1 (0x467d000)<br/>",
        "--13471--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libpcre.so.3.12.1 ..<br/>",
        "--13471--&nbsp;&nbsp; .. CRC mismatch (computed 9e5ab3c1 wanted 29aaf7e3)<br/>",
        "--13471--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13471-- REDIR: 0x448ffb0 (strncmp) redirected to 0x4020479 (_vgnU_ifunc_wrapper)<br/>",
        "--13471-- REDIR: 0x4497140 (strstr) redirected to 0x4020479 (_vgnU_ifunc_wrapper)<br/>",
        "--13471-- REDIR: 0x4496db0 (__GI_strstr) redirected to 0x4028ef1 (strstr)<br/>",
        "--13471-- REDIR: 0x44900b0 (rindex) redirected to 0x4026acc (rindex)<br/>",
        "--13471-- REDIR: 0x439b650 (operator new(unsigned int)) redirected to 0x4026398 (operator new(unsigned int))<br/>",
        "--13471-- REDIR: 0x448bef0 (malloc) redirected to 0x40267df (malloc)<br/>",
        "--13471-- REDIR: 0x448fd80 (__GI_strlen) redirected to 0x402702d (__GI_strlen)<br/>",
        "--13471-- REDIR: 0x448f740 (strcmp) redirected to 0x4020479 (_vgnU_ifunc_wrapper)<br/>",
        "--13471-- REDIR: 0x4538cb0 (__strcmp_ssse3) redirected to 0x40279d0 (strcmp)<br/>",
        "--13471-- REDIR: 0x43994b0 (operator delete(void*)) redirected to 0x4025882 (operator delete(void*))<br/>",
        "--13471-- REDIR: 0x448c3b0 (free) redirected to 0x4025b6b (free)<br/>",
        "==13471== <br/>",
        "==13471== HEAP SUMMARY:<br/>",
        "==13471==&nbsp;&nbsp;&nbsp;&nbsp; in use at exit: 0 bytes in 0 blocks<br/>",
        "==13471==&nbsp;&nbsp; total heap usage: 8 allocs, 8 frees, 336 bytes allocated<br/>",
        "==13471== <br/>",
        "==13471== All heap blocks were freed -- no leaks are possible<br/>",
        "==13471== <br/>",
        "==13471== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 33 from 6)<br/>",
        "--13471-- <br/>",
        "--13471-- used_suppression:&nbsp;&nbsp;&nbsp;&nbsp; 33 U1004-ARM-_dl_relocate_object<br/>",
        "==13471== <br/>",
        "==13471== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 33 from 6)<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p>Zero errors, excellent!</p>"
      }
    }
  );
  m.push_back(
    { "CppMemcheckExample2",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppMemcheckExample2.htm\">memcheck example 2: a small memory leak</a> is a ",
        "<a href=\"CppMemcheck.htm\">memcheck</a> example that shows how <a href=\"CppMemcheck.htm\">memcheck</a>",
        "reports a <a href=\"CppMemoryLeak.htm\">memory leak</a> we put in on purpose.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppMemcheckExample2.zip\">Download the Qt Creator project 'CppMemcheckExample2' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>valgrind_memcheck.txt</h2>",
        "<p>&nbsp;</p>",
        "<p>Running the script valgrind_memcheck.sh resulted in the following output file:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"memcheck result\" border = \"1\"><tr><td><code>",
        "==13939== Memcheck, a memory error detector<br/>",
        "==13939== Copyright (C) 2002-2010, and GNU GPL'd, by Julian Seward et al.<br/>",
        "==13939== Using Valgrind-3.6.1 and LibVEX; rerun with -h for copyright info<br/>",
        "==13939== Command: ../CppMemcheckExample2-build-desktop/./CppMemcheckExample2<br/>",
        "==13939== Parent PID: 13938<br/>",
        "==13939== <br/>",
        "--13939-- <br/>",
        "--13939-- Valgrind options:<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;--suppressions=/usr/lib/valgrind/debian-libc6-dbg.supp<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;--leak-check=full<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;-v<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;--show-reachable=yes<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;--log-file=valgrind_memcheck.txt<br/>",
        "--13939-- Contents of /proc/version:<br/>",
        "--13939--&nbsp;&nbsp; Linux version 2.6.38-8-generic-pae (buildd@vernadsky) (gcc version 4.5.2 (Ubuntu/Linaro 4.5.2-8ubuntu3) ) #42-Ubuntu SMP Mon Apr 11 05:17:09 UTC 2011<br/>",
        "--13939-- Arch and hwcaps: X86, x86-sse1-sse2<br/>",
        "--13939-- Page sizes: currently 4096, max supported 4096<br/>",
        "--13939-- Valgrind library directory: /usr/lib/valgrind<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/ld-2.13.so (0x4000000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/ld-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 2a2c2799 wanted 1e351f1f)<br/>",
        "--13939--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/ld-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13939-- Reading syms from /home/richel/Projects/Website/CppMemcheckExample2-build-desktop/CppMemcheckExample2 (0x8048000)<br/>",
        "--13939-- Reading syms from /usr/lib/valgrind/memcheck-x86-linux (0x38000000)<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a dynamic symbol table<br/>",
        "--13939-- Reading suppressions file: /usr/lib/valgrind/debian-libc6-dbg.supp<br/>",
        "--13939-- Reading suppressions file: /usr/lib/valgrind/default.supp<br/>",
        "--13939-- REDIR: 0x4016a80 (index) redirected to 0x3803f82b (vgPlain_x86_linux_REDIR_FOR_index)<br/>",
        "--13939-- Reading syms from /usr/lib/valgrind/vgpreload_core-x86-linux.so (0x4020000)<br/>",
        "--13939-- Reading syms from /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so (0x4023000)<br/>",
        "==13939== WARNING: new redirection conflicts with existing -- ignoring it<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp; new: 0x04016a80 (index&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ) R-&gt; 0x04026c78 index<br/>",
        "--13939-- REDIR: 0x4016c20 (strlen) redirected to 0x4027048 (strlen)<br/>",
        "--13939-- Reading syms from /usr/lib/libQtCore.so.4.7.2 (0x4043000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /usr/lib/libQtCore.so.4.7.2 ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 0c8a8d9d wanted ce78deb8)<br/>",
        "--13939--&nbsp;&nbsp; Considering /usr/lib/debug/usr/lib/libQtCore.so.4.7.2 ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/libpthread-2.13.so (0x42d6000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libpthread-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 87269ed5 wanted 7df95f2f)<br/>",
        "--13939--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libpthread-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13939-- Reading syms from /usr/lib/i386-linux-gnu/libstdc++.so.6.0.14 (0x42ef000)<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/libm-2.13.so (0x43da000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libm-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed e686ed93 wanted a0f1e52c)<br/>",
        "--13939--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libm-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/libgcc_s.so.1 (0x4400000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libgcc_s.so.1 ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 3fa6d24f wanted 8b2bf89f)<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/libc-2.13.so (0x441c000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libc-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 97e88cd2 wanted 4635a554)<br/>",
        "--13939--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libc-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/libz.so.1.2.3.4 (0x457e000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libz.so.1.2.3.4 ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 995eb12f wanted 33a06a21)<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/libdl-2.13.so (0x4593000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libdl-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 608d0daf wanted 983d6578)<br/>",
        "--13939--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libdl-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13939-- Reading syms from /usr/lib/i386-linux-gnu/libgthread-2.0.so.0.2800.6 (0x4597000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /usr/lib/i386-linux-gnu/libgthread-2.0.so.0.2800.6 ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 244482a3 wanted 61a9cd3c)<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/librt-2.13.so (0x459c000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/librt-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 680ec6ea wanted 247d4d27)<br/>",
        "--13939--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/librt-2.13.so ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/libglib-2.0.so.0.2800.6 (0x45a5000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libglib-2.0.so.0.2800.6 ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 2312631e wanted e21a44de)<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13939-- Reading syms from /lib/i386-linux-gnu/libpcre.so.3.12.1 (0x467d000)<br/>",
        "--13939--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libpcre.so.3.12.1 ..<br/>",
        "--13939--&nbsp;&nbsp; .. CRC mismatch (computed 9e5ab3c1 wanted 29aaf7e3)<br/>",
        "--13939--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--13939-- REDIR: 0x448ffb0 (strncmp) redirected to 0x4020479 (_vgnU_ifunc_wrapper)<br/>",
        "--13939-- REDIR: 0x4497140 (strstr) redirected to 0x4020479 (_vgnU_ifunc_wrapper)<br/>",
        "--13939-- REDIR: 0x4496db0 (__GI_strstr) redirected to 0x4028ef1 (strstr)<br/>",
        "--13939-- REDIR: 0x44900b0 (rindex) redirected to 0x4026acc (rindex)<br/>",
        "--13939-- REDIR: 0x439b650 (operator new(unsigned int)) redirected to 0x4026398 (operator new(unsigned int))<br/>",
        "--13939-- REDIR: 0x448bef0 (malloc) redirected to 0x40267df (malloc)<br/>",
        "--13939-- REDIR: 0x43994b0 (operator delete(void*)) redirected to 0x4025882 (operator delete(void*))<br/>",
        "--13939-- REDIR: 0x448c3b0 (free) redirected to 0x4025b6b (free)<br/>",
        "==13939== <br/>",
        "==13939== HEAP SUMMARY:<br/>",
        "==13939==&nbsp;&nbsp;&nbsp;&nbsp; in use at exit: 4 bytes in 1 blocks<br/>",
        "==13939==&nbsp;&nbsp; total heap usage: 9 allocs, 8 frees, 340 bytes allocated<br/>",
        "==13939== <br/>",
        "==13939== Searching for pointers to 1 not-freed blocks<br/>",
        "==13939== Checked 150,724 bytes<br/>",
        "==13939== <br/>",
        "==13939== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1<br/>",
        "==13939==&nbsp;&nbsp;&nbsp;&nbsp;at 0x402641D: operator new(unsigned int) (vg_replace_malloc.c:255)<br/>",
        "==13939==&nbsp;&nbsp;&nbsp;&nbsp;by 0x8048544: main (in /home/richel/Projects/Website/CppMemcheckExample2-build-desktop/CppMemcheckExample2)<br/>",
        "==13939== <br/>",
        "==13939== LEAK SUMMARY:<br/>",
        "==13939==&nbsp;&nbsp;&nbsp;&nbsp;definitely lost: 4 bytes in 1 blocks<br/>",
        "==13939==&nbsp;&nbsp;&nbsp;&nbsp;indirectly lost: 0 bytes in 0 blocks<br/>",
        "==13939==&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;possibly lost: 0 bytes in 0 blocks<br/>",
        "==13939==&nbsp;&nbsp;&nbsp;&nbsp;still reachable: 0 bytes in 0 blocks<br/>",
        "==13939==&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; suppressed: 0 bytes in 0 blocks<br/>",
        "==13939== <br/>",
        "==13939== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 33 from 6)<br/>",
        "--13939-- <br/>",
        "--13939-- used_suppression:&nbsp;&nbsp;&nbsp;&nbsp; 33 U1004-ARM-_dl_relocate_object<br/>",
        "==13939== <br/>",
        "==13939== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 33 from 6)<br/>",
        "<br/>",
        "</code></td></tr></table>",
        "<!-- end of the code -->",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppValgrind.htm\">valgrind</a> did detect the <a href=\"CppMemoryLeak.htm\">memory leak</a> in ",
        "<a href=\"CppMain.htm\">main</a>, but does not report exactly which line caused this.</p>"
      }
    }
  );
  m.push_back(
    { "CppMemcheckExample3",
      {
        "<p><img src=\"PicStl.png\" alt=\"STL\"/><img src=\"PicQtCreator.png\" alt=\"Qt Creator\"/><img src=\"PicLubuntu.png\" alt=\"Lubuntu\"/></p>",
        "<p>&nbsp;</p>",
        "<p><a href=\"CppMemcheckExample3.htm\">memcheck example 3: deleting an array the wrong way</a> is a ",
        "<a href=\"CppMemcheck.htm\">memcheck</a> example shows how <a href=\"CppMemcheck.htm\">memcheck</a>",
        "reports a <a href=\"CppMemoryLeak.htm\">memory leak</a> we put in on purpose.</p>",
        "<p>&nbsp;</p>",
        "<ul>",
        "  <li><a href=\"CppMemcheckExample3.zip\">Download the Qt Creator project 'CppMemcheckExample3' (zip)</a></li>",
        "</ul>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<p>&nbsp;</p>",
        "<h2>valgrind_memcheck.txt</h2>",
        "<p>&nbsp;</p>",
        "<p>Running the script valgrind_memcheck.sh resulted in the following output file:</p>",
        "<p>&nbsp;</p>",
        "<!-- start of code -->",
        "<table summary=\"memcheck result\" border = \"1\"><tr><td><code>",
        "==14146== Memcheck, a memory error detector<br/>",
        "==14146== Copyright (C) 2002-2010, and GNU GPL'd, by Julian Seward et al.<br/>",
        "==14146== Using Valgrind-3.6.1 and LibVEX; rerun with -h for copyright info<br/>",
        "==14146== Command: ../CppMemcheckExample3-build-desktop/./CppMemcheckExample3<br/>",
        "==14146== Parent PID: 14145<br/>",
        "==14146== <br/>",
        "--14146-- <br/>",
        "--14146-- Valgrind options:<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;--suppressions=/usr/lib/valgrind/debian-libc6-dbg.supp<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;--leak-check=full<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;-v<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;--show-reachable=yes<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;--log-file=valgrind_memcheck.txt<br/>",
        "--14146-- Contents of /proc/version:<br/>",
        "--14146--&nbsp;&nbsp; Linux version 2.6.38-8-generic-pae (buildd@vernadsky) (gcc version 4.5.2 (Ubuntu/Linaro 4.5.2-8ubuntu3) ) #42-Ubuntu SMP Mon Apr 11 05:17:09 UTC 2011<br/>",
        "--14146-- Arch and hwcaps: X86, x86-sse1-sse2<br/>",
        "--14146-- Page sizes: currently 4096, max supported 4096<br/>",
        "--14146-- Valgrind library directory: /usr/lib/valgrind<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/ld-2.13.so (0x4000000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/ld-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 2a2c2799 wanted 1e351f1f)<br/>",
        "--14146--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/ld-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--14146-- Reading syms from /home/richel/Projects/Website/CppMemcheckExample3-build-desktop/CppMemcheckExample3 (0x8048000)<br/>",
        "--14146-- Reading syms from /usr/lib/valgrind/memcheck-x86-linux (0x38000000)<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a dynamic symbol table<br/>",
        "--14146-- Reading suppressions file: /usr/lib/valgrind/debian-libc6-dbg.supp<br/>",
        "--14146-- Reading suppressions file: /usr/lib/valgrind/default.supp<br/>",
        "--14146-- REDIR: 0x4016a80 (index) redirected to 0x3803f82b (vgPlain_x86_linux_REDIR_FOR_index)<br/>",
        "--14146-- Reading syms from /usr/lib/valgrind/vgpreload_core-x86-linux.so (0x4020000)<br/>",
        "--14146-- Reading syms from /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so (0x4023000)<br/>",
        "==14146== WARNING: new redirection conflicts with existing -- ignoring it<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp; new: 0x04016a80 (index&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ) R-&gt; 0x04026c78 index<br/>",
        "--14146-- REDIR: 0x4016c20 (strlen) redirected to 0x4027048 (strlen)<br/>",
        "--14146-- Reading syms from /usr/lib/libQtCore.so.4.7.2 (0x4043000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /usr/lib/libQtCore.so.4.7.2 ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 0c8a8d9d wanted ce78deb8)<br/>",
        "--14146--&nbsp;&nbsp; Considering /usr/lib/debug/usr/lib/libQtCore.so.4.7.2 ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/libpthread-2.13.so (0x42d6000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libpthread-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 87269ed5 wanted 7df95f2f)<br/>",
        "--14146--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libpthread-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--14146-- Reading syms from /usr/lib/i386-linux-gnu/libstdc++.so.6.0.14 (0x42ef000)<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/libm-2.13.so (0x43da000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libm-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed e686ed93 wanted a0f1e52c)<br/>",
        "--14146--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libm-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/libgcc_s.so.1 (0x4400000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libgcc_s.so.1 ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 3fa6d24f wanted 8b2bf89f)<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/libc-2.13.so (0x441c000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libc-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 97e88cd2 wanted 4635a554)<br/>",
        "--14146--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libc-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/libz.so.1.2.3.4 (0x457e000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libz.so.1.2.3.4 ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 995eb12f wanted 33a06a21)<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/libdl-2.13.so (0x4593000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libdl-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 608d0daf wanted 983d6578)<br/>",
        "--14146--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/libdl-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--14146-- Reading syms from /usr/lib/i386-linux-gnu/libgthread-2.0.so.0.2800.6 (0x4597000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /usr/lib/i386-linux-gnu/libgthread-2.0.so.0.2800.6 ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 244482a3 wanted 61a9cd3c)<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/librt-2.13.so (0x459c000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/librt-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 680ec6ea wanted 247d4d27)<br/>",
        "--14146--&nbsp;&nbsp; Considering /usr/lib/debug/lib/i386-linux-gnu/librt-2.13.so ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC is valid<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/libglib-2.0.so.0.2800.6 (0x45a5000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libglib-2.0.so.0.2800.6 ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 2312631e wanted e21a44de)<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--14146-- Reading syms from /lib/i386-linux-gnu/libpcre.so.3.12.1 (0x467d000)<br/>",
        "--14146--&nbsp;&nbsp; Considering /lib/i386-linux-gnu/libpcre.so.3.12.1 ..<br/>",
        "--14146--&nbsp;&nbsp; .. CRC mismatch (computed 9e5ab3c1 wanted 29aaf7e3)<br/>",
        "--14146--&nbsp;&nbsp;&nbsp;&nbsp;object doesn't have a symbol table<br/>",
        "--14146-- REDIR: 0x448ffb0 (strncmp) redirected to 0x4020479 (_vgnU_ifunc_wrapper)<br/>",
        "--14146-- REDIR: 0x4497140 (strstr) redirected to 0x4020479 (_vgnU_ifunc_wrapper)<br/>",
        "--14146-- REDIR: 0x4496db0 (__GI_strstr) redirected to 0x4028ef1 (strstr)<br/>",
        "--14146-- REDIR: 0x44900b0 (rindex) redirected to 0x4026acc (rindex)<br/>",
        "--14146-- REDIR: 0x439b650 (operator new(unsigned int)) redirected to 0x4026398 (operator new(unsigned int))<br/>",
        "--14146-- REDIR: 0x448bef0 (malloc) redirected to 0x40267df (malloc)<br/>",
        "--14146-- REDIR: 0x439b790 (operator new[](unsigned int)) redirected to 0x4025ece (operator new[](unsigned int))<br/>",
        "--14146-- REDIR: 0x4399510 (operator delete[](void*)) redirected to 0x4025504 (operator delete[](void*))<br/>",
        "--14146-- REDIR: 0x43994b0 (operator delete(void*)) redirected to 0x4025882 (operator delete(void*))<br/>",
        "==14146== Mismatched free() / delete / delete []<br/>",
        "==14146==&nbsp;&nbsp;&nbsp;&nbsp;at 0x4025907: operator delete(void*) (vg_replace_malloc.c:387)<br/>",
        "==14146==&nbsp;&nbsp;&nbsp;&nbsp;by 0x80485D9: Bad() (in /home/richel/Projects/Website/CppMemcheckExample3-build-desktop/CppMemcheckExample3)<br/>",
        "==14146==&nbsp;&nbsp;&nbsp;&nbsp;by 0x80485EF: main (in /home/richel/Projects/Website/CppMemcheckExample3-build-desktop/CppMemcheckExample3)<br/>",
        "==14146==&nbsp;&nbsp;Address 0x46be360 is 0 bytes inside a block of size 40 alloc'd<br/>",
        "==14146==&nbsp;&nbsp;&nbsp;&nbsp;at 0x4025F53: operator new[](unsigned int) (vg_replace_malloc.c:299)<br/>",
        "==14146==&nbsp;&nbsp;&nbsp;&nbsp;by 0x80485D1: Bad() (in /home/richel/Projects/Website/CppMemcheckExample3-build-desktop/CppMemcheckExample3)<br/>",
        "==14146==&nbsp;&nbsp;&nbsp;&nbsp;by 0x80485EF: main (in /home/richel/Projects/Website/CppMemcheckExample3-build-desktop/CppMemcheckExample3)<br/>",
        "==14146== <br/>",
        "==14146== Mismatched free() / delete / delete []<br/>",
        "==14146==&nbsp;&nbsp;&nbsp;&nbsp;at 0x4025907: operator delete(void*) (vg_replace_malloc.c:387)<br/>",
        "==14146==&nbsp;&nbsp;&nbsp;&nbsp;by 0x80485D9: Bad() (in /home/richel/Projects/Website/CppMemcheckExample3-build-desktop/CppMemcheckExample3)<br/>",
        "==14146==&nbsp;&nbsp;&nbsp;&nbsp;by 0x80485F9: