Search for files & folders

My boss wanted a tool for searching files and folders from a dedicated path… He used to write it using Powershell but took hours to run… Here is why system programming is important. No runtime, no framwork, no virtual machine, it runs direct on the metal. Fast !

#include <string>
#include <iostream>
#include <atlstr.h> 
#include <tchar.h>
#include <Windows.h>
#include <Shlwapi.h>

#pragma comment(lib, "Shlwapi.lib")


CString SearchDrive(const CString& strFile, const CString& strFilePath, const bool& bRecursive, const bool& bStopWhenFound) 
{
       CString strFoundFilePath;
       WIN32_FIND_DATA file;

       CString strPathToSearch = strFilePath;
       strPathToSearch += _T("\\");

       HANDLE hFile = FindFirstFile((strPathToSearch + "*"), &file);
       if (hFile != INVALID_HANDLE_VALUE)
       {
             do
             {
                    CString strTheNameOfTheFile = file.cFileName;

                    // It could be a directory we are looking at
                    // if so look into that dir
                    if (file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                    {
                           if ((strTheNameOfTheFile != ".") && (strTheNameOfTheFile != "..") && (bRecursive))
                           {
                                  strFoundFilePath = SearchDrive(strFile, strPathToSearch + strTheNameOfTheFile, bRecursive, bStopWhenFound);

                                  if (!strFoundFilePath.IsEmpty() && bStopWhenFound)
                                        break;
                           }
                    }
                    else
                    {
                           strFoundFilePath = strPathToSearch + strTheNameOfTheFile; //strFile;

                           long size = (file.nFileSizeHigh * (MAXDWORD + 1)) + file.nFileSizeLow;

                           TCHAR szPath[10240];
                           memset(szPath, 0, 10240);
                           _tcscpy_s(szPath, (LPCTSTR)strFoundFilePath);
                           ::PathRemoveFileSpec(szPath);
                           _tprintf(_T("%s;%s;%ld\n"), szPath, (LPCTSTR)strTheNameOfTheFile, size);


                           if (bStopWhenFound)
                                  break;
                    }
             } while (FindNextFile(hFile, &file));

             FindClose(hFile);
       }

       return strFoundFilePath;
}


int _tmain(int argc, TCHAR *argv[])
{
       if (argc != 2)
       {
             std::wcout << _T("Help") << std::endl;
             std::wcout << _T("usage: scanfiles <path>") << std::endl;
             return 0;
       }

       TCHAR strPath[1024];
       wcscpy_s(strPath, argv[1]);

       TCHAR strWildcard[255];
       wcscpy_s(strWildcard, _T("*.*"));

       SearchDrive(strWildcard, strPath, true, false);

       return 0;
}

 

Advertisements

Article in Programmez for January 2019

My next article will be in french Magazine Programmez in January 2019. It will talks about rootkits and key logger.

225

Visual Studio 2019 Live Share

With LiveShare feature, you can do remote debugging and remote coding from and to VS &nd VS Code:

Microsoft Connect(); 2018 KeyNote !

https://blogs.msdn.microsoft.com/dotnet/2018/12/04/announcing-net-core-3-preview-1-and-open-sourcing-windows-desktop-frameworks/

En vrac:

  • Visual Studio Code Collaboration Mode
  • Visual Studio 2019 Preview
  • Intellicode : Intellisence avec machine learning
  • Nouveautés Github
  • NET Core 3
  • Open Source WinForms, WPF et XAML UI
  • Nouveautés Azure Cognitive Services

Microsoft Connect() ; 2018

You as developers more productive.

The world runs on software.

It’s a great time to be a developer

Next generation of softwares

Powerful open in a productive way

Connected Apps

Intellicode vs code extension

Azure App Service

Python function

VS Code and VS collaboration

Microsoft loves open source

Nat GitHub CEO

CD with Github

Build your pipeline

VS2019

.NET Core 3

New capabilities

Fix my code

Power of Intellicode

Azure

AI

Articles C++ en Serie…

OOP : http://bit.ly/2rhQFYl

Basic – Partie 1 : http://bit.ly/2FT92Nn

Les classes – Partie 2 : http://bit.ly/2FROSDK

Les Templates – Partie 3 : http://bit.ly/2zwZ4fd

STL – Partie 4 : http://bit.ly/2Sp6kAJ

Boost – Partie 5: http://bit.ly/2U7r4OX

 

La Programmation Orientée Objet (OOP)

Introduction

Il y a plusieurs façons d’utiliser le C++. On peut être utilisateur de classes ou concepteur de classes. Dans les deux cas, définir, designer et implémenter des classes sont les activités primaires des développeurs C++. Par où on commence ? En général, on démarre avec une abstraction ou un concept. On considère un truc à coder et puis on essaie de voir comment on va gérer son ou ses fonctions, ce qui est interne et ce qui est public et comment on va l’utiliser… Au démarrage de cette réflexion, il faut se mettre la casquette de celui qui va utiliser la classe. Notre exemple de concept pour cet article sera un élément graphique à dessiner comme une ligne, un rectangle, une ellipse, etc. En anglais, c’est un shape.

// C’est une déclaration de classe

class CShape;

// C’est la future manière avec laquelle je veux dessiner des Shapes

bool Draw(const CShape& item);

Ensuite on envisage la classe dans son ensemble :

class CShape

{

public:

// interface publique

private:

// implémentation privée

};

Qu’est-ce que l’on met en private/public et comment va-t-elle être structurée. On commence petit bras et puis la classe prend du volume.

Constructeur et Destructeur

La première question qui vient à l’esprit est comment je vais créer mon objet et ai-je besoin de lui fournir des paramètres. Avec ma classe CShape, on peut se dire, je n’ai pas besoin mais aussi j’en ai besoin. Les deux possibilités existent ! Soit c’est une figure connue -> d’où une énumération pour les types connus et autre possibilité qui est de dessiner une image et là, il me faut un nom de fichier ; tout est ouvert !

enum ShapeType

{

line,

circle,

rectangle,

left_arrow,

right_arrow,

picture

};

L’avantage de l’énumération es que c’est évalué à la compilation. Il ne peut pas y avoir d’erreur sur le nommage car c’est un type explicite contrairement à une simple chaîne de caractères. Voyons sommairement comment pourrait être construite cette fameuse classe CShape…

class CShape

{

public:

CShape();

CShape(int x, int y, int xx, int yy, ShapeType type);

CShape(int x, int y, int xx, int yy, std::string fileName);

virtual ~CShape();

private:

std::string m_fileName;

ShapeType m_type;

};

J’y vois deux façons de créer un shape. Soit à partir de l’énumération soit à partir d’un fichier pour les images. Pour le moment, je ne sais pas comment organiser le dessin du shape. Dois-je le mettre à l’intérieur de la classe ou à l’extérieur ? Je ne sais pas… Il faut du temps pour considérer quelle sera la façon la plus naturelle de réaliser cette opération. Dans le monde Windows GDI+, pour dessiner un élément il faut un handle particulier qui possède toutes les primitives de dessins. En pensant comment allait être dessiner un élément, on peut envisager d’inclure une méthode Draw dans la classe CShape. La première pensée, c’est de se dire, je vais implémenter tous les cas possibles dans Draw avec une construction qui ressemble à ça :

void Draw(const CDrawingContext& ctxt) const

{

if (m_type == ShapeType::line)

{

ctxt.Line(m_rect.left, m_rect.bottom,

m_rect.top, m_rect.right);

}

if (m_type == ShapeType::rectangle)

{

ctxt.Rectangle(m_rect);

}

// TODO

}

Dans la classe, il est important de marquer les méthodes qui ne modifient pas les données private. Pour faire cela, on leur ajoute le mot-clé const à la fin comme c’est indiqué sur la méthode Draw.

De plus, lorsque l’on passe un argument qui n’as pas vocation à être modifié, on le passe en référence const. Comme on peut le voir ci-dessus, la définition d’une classe est un travail itératif dans lequel, les meilleures idées chassent celles d’avant ou les conforte. Si une classe est bien conçue, le lecture de ses membres public est limpide car on va à l’essentiel. Attention, les membres private expliquent aussi beaucoup de choses sur les détails d’implémentation. Maintenant, mettons-nous dans un contexte où il existe plusieurs classes et les principes vu ci-dessus ne suffisent pas à faire un modèle objet. Il nous faut des mécanismes plus sophistiqués pour relier les classes les unes avec les autres.

Les classes possèdent des associations et des comportements et c’est ici que les Jedi se positionnent pour y designer u nmodèle élégant, facile à utiliser et qui rend les services voulus.

Notre méthode Draw n’est pas OOP car si je rajoute un type dans l’énumération, je dois ajouter un if() dans la méthode Draw() et coder l’implémentation. On peut faire mieux, beaucoup mieux.

Les concepts de OOP

Les deux piliers de l’OOP sont l’héritage et le polymorphisme. L’héritage permet de grouper les classes en famille de types et permet de partager des opérations et des comportements et des données. Le polymorphisme permet de déclencher des opérations dans ces familles à un niveau unitaire. Ainsi ajouter ou supprimer une classe n’est pas trop un problème.

L’héritage définit une relation parent/enfant. Le parent définit l’interface public et l’implémentation private est commune à tous ses enfants. Chaque enfant choisit s’il veut hériter d’un comportement unique ou bien le surcharger. En C++, le parent est appelé « classe de base » et l’enfant « classe dérivée ». Le parent et les enfants définissent une hiérarchie de classes. Le parent est souvent une classe abstraite et les enfants implémentent les méthodes virtuelles pures pour que l’ensemble fonctionne.

Dans un programme OOP, on manipule les classes via un pointeur sur la classe de base plutôt que sur les objets dérivés.

Une classe abstraite

Revenons sur la classe CShape… La prochaine étape dans le design est de créer une classe abstraite pour identifier les opérations propres à chaque item – ce qui implique des opérations avec une implémentation basée sur une classe dérivée. Ces opérations sont des fonctions virtuelles pures de la classe de base. Une méthode virtuelle pure est une méthode abstraite. Il n’y a pas de corps. Cela implique que le classe devient abstraite aussi. Il n’est pas possible de créer un objet à partir d’une classe abstraite. La méthode Draw() doit être définie comme virtuelle pure car il y a plusieurs types de dessin à faire et que chaque dessin est propre à une classe donnée. Le corps de Draw() n’existe pas, c’est la raison pour laquelle on dit que la classe est abstraite ; il y a au moins une méthode virtuelle pure.

Voici donc comment on fait :

class CShapeEx

{

public:

CShapeEx() {}

CShapeEx(ShapeType type, RECT rect, const std::string &fileName)

: m_type(type), m_rect(rect), m_fileName(fileName) {}

virtual ~CShapeEx() {}

public:

virtual void Draw(const CDrawingContext& ctxt) const = 0;

virtual void DrawTracker(const CDrawingContext& ctxt) const = 0;

private:

std::string m_fileName;

ShapeType m_type;

RECT m_rect;

};

Et nous allons maintenant déclarer des classes dérivées de CShapeEx :

class CRectangle : public CShapeEx

{

public:

CRectangle() {}

virtual ~CRectangle() {}

public:

virtual void Draw(const CDrawingContext& ctxt) const

{

// TODO

std::cout << "Rectangle::Draw" << std::endl;

}

virtual void DrawTracker(const CDrawingContext& ctxt) const

{

// TODO

}

};

class CLine : public CShapeEx

{

public:

CLine() {}

virtual ~CLine() {}

public:

virtual void Draw(const CDrawingContext& ctxt) const

{

// TODO

std::cout << "Line ::Draw" << std::endl;

}

virtual void DrawTracker(const CDrawingContext& ctxt) const

{

// TODO

}

};

Si on veut rajouter un item à dessiner dans la hiérarchie, il suffit de rajouter une classe dérivée ! Maintenant nous allons voir comment fonctionne ce mécanisme de virtual…

CDrawingContext ctxt;

CRectangle * pRect = new CRectangle();

CLine * pLine = new CLine();

CShapeEx * ptr = nullptr;

ptr = pRect;

ptr->Draw(ctxt);

ptr = pLine;

ptr->Draw(ctxt);

On commence par déclarer 2 items à dessiner. Puis le manager, un pointeur sur la classe de base CShapeEx est déclaré. A chaque fois qu’il pointe sur un objet d’une classe dérivée, la fonction virtuelle Draw() appelée est celle de la classe dérivée car cette fonction est définie comme virtuelle.

Maintenant, il nous manque quelque chose de très utile et qui évitera les usines à gaz de construction d’objets dérivés. Il nous faut une factory ! Un mécanisme de création d’objet.

La factory

class CFactory

{

private:

CFactory();

public:

static CShapeEx * CreateObject(ShapeType type)

{

if (type == ShapeType::line)

{

CLine * pObj = new CLine();

pObj->m_type = type;

return pObj;

}

if (type == ShapeType::rectange)

{

CRectangle * pObj = new CRectangle();

pObj->m_type = type;

return pObj;

}

// TODO

return nullptr;

}

};

Cette classe permet via une méthode static de créer un objet en fonction de son type dans l’énumération. Le type est affecté en variable membre de l’objet créé. On notera que le constructeur est private, cela veut dire que l’on ne peut pas déclarer d’objet CFactory. On ne peut qu’utiliser la méthode static CreateObject. Sauf que, la compilation tombe en erreur :

Le membre m_type est inaccessible vue son niveau de protection… On va donc ajouter quelque chose à la classe CShapeEx :

class CShapeEx

{

public:

CShapeEx() {}

CShapeEx(ShapeType type, RECT rect, const std::string &fileName)

: m_type(type), m_rect(rect), m_fileName(fileName) {}

virtual ~CShapeEx() {}

public:

virtual void Draw(const CDrawingContext& ctxt) const = 0;

virtual void DrawTracker(const CDrawingContext& ctxt) const = 0;

private:

std::string m_fileName;

ShapeType m_type;

RECT m_rect;

// La classe CFactory peux avoir accès aux membres…

friend class CFactory;

};

On ajoute en fin de classe que la classe CFactory est amie de la classe CShapeEx. Et là, il n’y a plus d’erreur de compilation ! Les puristes comme AlainZ, à Redmond, vous diront que cela viole la mécanique objet et que c’est une construction exotique et qu’il vaut mieux passer par le constructeur pour passer le type… Je ne suis pas de cet avis. Je pense que c’est élégant de faire une entorse pour la factory. Voici maintenant le code qui appelle la factory :

CDrawingContext ctxt;

CShapeEx * pRect = CFactory::CreateObject(ShapeType::rectange);

CShapeEx * pLine = CFactory::CreateObject(ShapeType::line);

CShapeEx * ptr = nullptr;

ptr = pRect;

ptr->Draw(ctxt);

ptr = pLine;

ptr->Draw(ctxt);

Et le résultat est équivalent.

Compilation sous Linux

Pour ceux qui ne le savent pas, le langage C++ est normalisé ISO. Sur la plateforme Linux, là où tout est fait en C/C++, le langage possède plusieurs compilateurs dont le célèbre GCC. Vous pouvez utiliser Visual Studio Code que fournit Microsoft comme IDE pour compiler sous Linux via le terminal.

Il faut installer l’extension C++. Moi j’ai installé Cygwin et MSYS. Ainsi je dispose de commandes Linux.

Une touche de C++ 11

On va essayer de continuer notre application de dessin en matérialisant la zone de dessiner. Cela ressemble à un ensemble de shapes sur un support de dessin. Première étape quand on pense au concept de la planche à dessin c’est quoi ? Le stockage des éléments graphiques dans un container STL. Oui Monsieur, quand on veut stocker quelque chose, on passe par les containers STL. On va donc utiliser le std::vector<T> de la STL. On va stocker des shapes un peu particulier que sont les shapes partagés. Partagés ? Par qui ? Dans un vrai logiciel de dessin, on affiche les propriétés dans une grille et le dessin est sur le panneau central donc on partage nos objets et ce n’est pas que de l’affichage. Je vous montre le résultat.

Sur cet écran, on voit que le rectangle bleu sélectionné a ses attributs directement dans le grille de propriétés mais aussi sur le Ribbon. Comment faire pour partager les données entre le panneau de dessin, le Ribbon et la grille de propriétés ? Est-ce que l’on fait des copies des objets ? Oui, mais on fait des copies de pointeurs et non des copies d’objets. Pour faire cela, une utilise le mécanisme des pointeurs partagés de la STL. Voyons son utilisation. Premièrement, on va designer la zone de dessin.

La zone de dessin

Cette zone contient les objets shape à dessiner. On va donc créer un vector<shared_ptr<CShapeEx>>. Le container vector est défini dans <vector>. On va avoir une collection d’éléments partagés CShapeEx. Ainsi, on pourra stocker ce pointeur particulier où on veut sans se soucier de la libération de la mémoire. La zone de dessin est une vue fille MDI en jargon Windows. Elle possède deux scrollbars, un verticale et une horizontale. Si on veut faire une gestion de shared_ptr<T>, il faut faire évoluer la factory :

static std::shared_ptr<CShapeEx> CreateObject(ShapeType type)

{

std::shared_ptr<CShapeEx> pObj = nullptr;

if (type == ShapeType::line)

{

pObj = std::make_shared<CLine>();

pObj->m_type = type;

return pObj;

}

if (type == ShapeType::rectangle)

{

pObj = std::make_shared<CRectangle>();

pObj->m_type = type;

return pObj;

}

return nullptr;

}

On ne fait plus un new() mais un appel à std::make_shared<T>().

De plus, dans l’utilisation des objets, cela donne ça :

CDrawingContext ctxt;

std::shared_ptr<CShapeEx> pRect = CFactory::CreateObject(ShapeType::rectangle);

std::shared_ptr<CShapeEx> pLine = CFactory::CreateObject(ShapeType::line);

std::shared_ptr<CShapeEx> ptr = nullptr;

ptr = pRect;

ptr->Draw(ctxt);

ptr = pLine;

ptr->Draw(ctxt);

Il existe même une façon de laisser le compilateur déterminer le type de variable utilisée en utilisant auto :

CDrawingContext ctxt;

auto pRect = CFactory::CreateObject(ShapeType::rectangle);

auto pLine = CFactory::CreateObject(ShapeType::line);

auto ptr = pRect;

ptr->Draw(ctxt);

ptr = pLine;

ptr->Draw(ctxt);

Revenons à notre design de classes. Le container de shapes est juste une collection std::vector<T> de std::shared_ptr<CShapeEx> :

class CElementContainer : public CObject

{

private:

public:

DECLARE_SERIAL(CElementContainer);

CElementContainer();

virtual ~CElementContainer(void);

// ../..

// overridden for document i/o

virtual void Serialize(CElementManager * pElementManager, CArchive& ar);

// Debuging Operations

public:

void DebugDumpObjects(CModeler1View * pView);

// Operations MFC like

public:

std::shared_ptr<CElement> GetHead();

int GetCount();

void RemoveAll();

void Remove(std::shared_ptr<CElement> pElement);

void AddTail(std::shared_ptr<CElement> pElement);

// Attributes

private:

vector<std::shared_ptr<CElement>> m_objects;

};

Là, je vous montre un vrai code et les éléments sont matérialisés par la classe CElement mais c’est pareil que CShapeEx. On notera que les fonctions de gestion associées au vector sont des méthodes helpers dans cette classe. Il faut maintenant intégrer cette classe dans la mécanique de fenêtrage Windows.

Je pratique le C++ – Partie 5/5 – Boost

Je pratique le C++ – Partie 5/5.

Nous vous proposons une série d’articles sur la pratique de C++ pour que vous puissiez tous vous y mettre. Ce mois-ci on aborde la librairie Boost du site www.boost.org. Boost est une communauté de programmeurs C++ dont le but est de pousser les librairies qu’ils font vers la standardisation C++. Boost c’est une librairie C++ portable. Vous pouvez l’utiliser avec Visual C++ sur Windows et GCC ou CLang sur Linux.

Comment obtenir Boost ?

Très simplement en allant dans la rubrique download du site et vous êtes et vous télécharger un zip de 120 MB ou un targz de 80 MB. Vous décompressez votre archive et vous êtes presque prêt. La décompression vous donne une arborescence de 430 MB. Il y a énormément de documentation HTML c’est la raison pour laquelle la taille du dossier est conséquente.

 

Compilation de Boost

Malgré que Boost soit en majorité un ensemble de templates et de fonctions inline donc juste les fichiers d’entêtes suffisent, il y a des librairies qu’il faut compiler.

La première chose à faire c’est de lancer la compilation de la librairie. Cela se fait en deux étapes. Premièrement, il faut compiler le custom Make de Boost qui se nomme bjam. Il faut lancer bootstrap.bat. Maintenant que bjam est compilé, on va builder la librairie avec notre chaine de compilation particulière à une plateforme. Je travaille avec Visual Studio 2013 donc voici ma ligne de commande :

 

bjam toolset=msvc-12.0 variant=debug,release threading=multi link=shared

 

Je fais une compilation en debug et en relase et indiquant que je veux une librairie multi-thread et en mode dynamique (DLL). La compilation prends un peu de temps mais disons qu’en 15 minutes c’est terminé.

 

 

Introduction à Boost.Serialization

Maintenant que nous avons listé l’ensemble des librairies disponibles dans Boost, nous allons passer au code ! Examinons une librairie très utile qui sait sérialiser et dé-sérialiser des classes en format binaire ou XML sans forcer. Cette librairie permet de sérialiser des containers ce qui évitera de parcourir nos différentes collections pour sérialiser des éléments simples. Par contre, nous devons faire attention à une collision de nom dans l’espace de noms disponible. Je m’explique… Boost sérialise les boost ::string, les boost ::vector & co… Ce qui veut dire qu’il va falloir transvaser nos objets écrits avec la STL standard dans des objets Boost compatibles à moins que notre application soit écrite complètement avec Boost. C’est un choix d’Architecture !

Nous allons partir sur une application que j’ai écrite pour ma fille en 2012. Il s’agit d’une application de dessin ou l’on dispose des éléments prédéfinis sur une page comme des images, des rectangles, des ronds, des triangles, etc. Cette application a permit à ma fille de 8 ans à l’époque de savoir manier la souris et de jouer avec le Ribbon pour changer les caractéristiques des objets (couleur, épaisseur de traits, etc).

 

Le résultat de la sérialisation XML

Commençons par la fin… Le dessin est le suivant :

Le but du jeu est de sauvegarder ce dessin sous forme de document XML.

Ouvrons la documentation de Boost.Serialization pour prendre la chose du bon côté et pour arriver au résultat ci-dessus. Si vous avez l’œil, vous verrez que l’application que je vous propose est réalisée avec les Microsoft Foundation Classes (MFC) car elle me permet de faire un joli Ribbon et de mettre en place le support du Document/Vue qui me permet de faire une application qui charge/enregistre mes données. Bref, MFC rocks. Je crois d’ailleurs qu’on va refaire une série Je Pratique le C++ sous Windows en 5 épisodes pour que vous puissiez développer vous aussi des applications qui rocks ! On verra… revenons à nos moutons. Le XML. Boost.Serialization fonctionne avec ce que l’on appelle une Archive dans laquelle on a accès à des données. Il faut nourrir l’archive avec des données. J’ai donc une classe d’objets à dessiner et des objets. Le modèle de données est constitué de 2 classes : CSimpleShape et CShapeCollection.

 

La classe CSimpleShape

Cette classe contient les propriétés suivantes :

public:

wstring m_name;

wstring m_id;

string m_rect;

long m_type;

long m_shapeType;

wstring m_caption;

wstring m_text;

long m_x1;

long m_y1;

long m_x2;

long m_y2;

int m_colorFillR;

int m_colorFillG;

int m_colorFillB;

int m_colorLineR;

int m_colorLineG;

int m_colorLineB;

bool m_bSolidColorFill;

bool m_bColorLine;

bool m_bColorFill;

};

 

BOOST_CLASS_VERSION(CSimpleShape, 1)

 

La classe CShapeCollection

Cette classe contient la liste des elements:

public:

vector<boost::shared_ptr<CSimpleShape> > m_shapes;

};

 

BOOST_CLASS_VERSION(CShapeCollection, 1)

 

C’est un vecteur de CSimpleShape tout simplement… Pour que ces éléments soient stockés sous forme de fichier texte, binaire ou XML il faut préciser quelques petites choses dans les classes. Il faut spécifier cela en private :

private:

friend class boost::serialization::access;

template<class Archive>

void save(Archive & ar, const unsigned int version) const

{

ar & BOOST_SERIALIZATION_NVP(m_shapes);

}

 

template<class Archive>

void load(Archive & ar, const unsigned int version)

{

ar & BOOST_SERIALIZATION_NVP(m_shapes);

}

 

BOOST_SERIALIZATION_SPLIT_MEMBER()

 

Cette partie de code nous montre le template à définir. Il s’agit d’une fonction template load et save qui travaille sur une Archive. La syntaxe pour enroler une donnée dans l’archive se fait au travers de l’opérateur &. Cette partie de code enregistre le vecteur d’éléments. Mais pour que cela fonctionne, il faut aussi que le classe CSimpleShape enregistre ses éléments dans l’archive.

template<class Archive>

void save(Archive & ar, const unsigned int version) const

{

// ar & name;

// ar & id;

ar & BOOST_SERIALIZATION_NVP(m_name);

ar & BOOST_SERIALIZATION_NVP(m_id);

ar & BOOST_SERIALIZATION_NVP(m_rect);

ar & BOOST_SERIALIZATION_NVP(m_type);

ar & BOOST_SERIALIZATION_NVP(m_shapeType);

ar & BOOST_SERIALIZATION_NVP(m_caption);

ar & BOOST_SERIALIZATION_NVP(m_text);

ar & BOOST_SERIALIZATION_NVP(m_x1);

ar & BOOST_SERIALIZATION_NVP(m_y1);

ar & BOOST_SERIALIZATION_NVP(m_x2);

ar & BOOST_SERIALIZATION_NVP(m_y2);

ar & BOOST_SERIALIZATION_NVP(m_colorFillR);

ar & BOOST_SERIALIZATION_NVP(m_colorFillG);

ar & BOOST_SERIALIZATION_NVP(m_colorFillB);

ar & BOOST_SERIALIZATION_NVP(m_colorLineR);

ar & BOOST_SERIALIZATION_NVP(m_colorLineG);

ar & BOOST_SERIALIZATION_NVP(m_colorLineB);

ar & BOOST_SERIALIZATION_NVP(m_bSolidColorFill);

ar & BOOST_SERIALIZATION_NVP(m_bColorLine);

ar & BOOST_SERIALIZATION_NVP(m_bColorFill);

}

 

Le code du load et du save est le même. L’archive sait dans quel sens on travaille soit en lecture soit en écriture. Il faut noter que les MFC fournissent une infrastructure similaire avec les opérateurs << et >> ; je trouve que c’est plus lisible à mon goût mais bon. Pour pouvoir compiler ce code, il faut disposer des entêtes suivante :

#define BOOST_SERIALIZATION_DYN_LINK TRUE

#define BOOST_ALL_DYN_LINK TRUE

 

#include <boost/smart_ptr/shared_ptr.hpp>

#include <boost/archive/tmpdir.hpp>

#include <boost/serialization/nvp.hpp>

 

#include <boost/archive/xml_iarchive.hpp>

#include <boost/archive/xml_oarchive.hpp>

#include <boost/archive/text_iarchive.hpp>

#include <boost/archive/text_oarchive.hpp>

#include <boost/serialization/shared_ptr.hpp>

#include <boost/serialization/base_object.hpp>

#include <boost/serialization/string.hpp>

#include <boost/serialization/list.hpp>

#include <boost/serialization/vector.hpp>

#include <boost/serialization/map.hpp>

#include <boost/serialization/utility.hpp>

#include <boost/serialization/assume_abstract.hpp>

using namespace boost;

 

L’écriture des données

Maintenant que nous avons nos classes qui savent utiliser une Archive, voyons le code qui donne l’ordre de faire Load ou Save. Vous allez voir, c’est très simple :

boost::shared_ptr<CShapeCollection> data(new CShapeCollection());

for( vector<std::shared_ptr<CElement>>::iterator i = m_objects.m_objects.begin() ; i!=m_objects.m_objects.end() ; i++ )

{

std::shared_ptr<CElement> pElement = *i;

boost::shared_ptr<CSimpleShape> pNewElement(new CSimpleShape());

pNewElement->m_name = pElement->m_name;

pNewElement->m_id = pElement->m_objectId;

pNewElement->m_type = pElement->m_type;

pNewElement->m_shapeType = pElement->m_shapeType;

pNewElement->m_caption = pElement->m_caption;

pNewElement->m_text = pElement->m_text;

 

CPoint p1 = pElement->m_rect.TopLeft();

CPoint p2 = pElement->m_rect.BottomRight();

pNewElement->m_x1 = p1.x;

pNewElement->m_y1 = p1.y;

pNewElement->m_x2 = p2.x;

pNewElement->m_y2 = p2.y;

 

pNewElement->m_colorFillR = GetRValue(pElement->m_colorFill);

pNewElement->m_colorFillG = GetGValue(pElement->m_colorFill);

pNewElement->m_colorFillB = GetBValue(pElement->m_colorFill);

pNewElement->m_colorLineR = GetRValue(pElement->m_colorLine);

pNewElement->m_colorLineG = GetGValue(pElement->m_colorLine);

pNewElement->m_colorLineB = GetBValue(pElement->m_colorLine);

 

pNewElement->m_bSolidColorFill = pElement->m_bSolidColorFill;

pNewElement->m_bColorLine = pElement->m_bColorLine;

pNewElement->m_bColorFill = pElement->m_bColorFill;

 

data->m_shapes.push_back(pNewElement);

}

 

std::ofstream xofs(filename.c_str());

boost::archive::xml_oarchive xoa(xofs);

xoa << BOOST_SERIALIZATION_NVP(data);

 

La variable filename est remplie par l’ouverture d’une Common Dialog Windows SaveAs et toute la magie consiste à déclarer une xml_archive et à utiliser l’opérateur << pour sauver toutes nos données.

 

La lecture des données

La lecture des données est calquée sur l’écriture, on récupère les données et on les transvase dans la collection qui va s’afficher à l’écran :

 

boost::shared_ptr<CShapeCollection> data(new CShapeCollection());

// load an archive

std::ifstream xifs(filename.c_str());

assert(xifs.good());

boost::archive::xml_iarchive xia(xifs);

xia >> BOOST_SERIALIZATION_NVP(data);

// Clear existing shapes

m_objects.RemoveAll();

 

for( vector<boost::shared_ptr<CSimpleShape> >::iterator i = data->m_shapes.begin() ; i!=data->m_shapes.end() ; i++ )

{

boost::shared_ptr<CSimpleShape> pElement = *i;

//AfxMessageBox(pElement->m_name + ” ” + pElement->m_id);

 

std::shared_ptr<CElement> pNewElement = CFactory::CreateElementOfType((ElementType)pElement->m_type,

(ShapeType)pElement->m_shapeType);

pNewElement->m_name = pElement->m_name.c_str();

pNewElement->m_objectId = pElement->m_id.c_str();

pNewElement->m_caption = pElement->m_caption.c_str();

pNewElement->m_text = pElement->m_text.c_str();

pNewElement->m_pManager = this;

pNewElement->m_pView = pView;

 

CPoint p1;

CPoint p2;

p1.x = pElement->m_x1;

p1.y = pElement->m_y1;

p2.x = pElement->m_x2;

p2.y = pElement->m_y2;

pNewElement->m_rect = CRect(p1, p2);

 

int colorFillR = pElement->m_colorFillR;

int colorFillG = pElement->m_colorFillG;

int colorFillB = pElement->m_colorFillB;

pNewElement->m_colorFill = RGB(colorFillR, colorFillG, colorFillB);

int colorLineR = pElement->m_colorLineR;

int colorLineG = pElement->m_colorLineG;

int colorLineB = pElement->m_colorLineB;

pNewElement->m_colorLine = RGB(colorLineR, colorLineG, colorLineB);

 

pNewElement->m_bSolidColorFill = pElement->m_bSolidColorFill;

pNewElement->m_bColorLine = pElement->m_bColorLine;

pNewElement->m_bColorFill = pElement->m_bColorFill;

 

m_objects.AddTail(pNewElement);

pView->LogDebug(_T(“object created ->”) + pNewElement->ToString());

}

 

// Redraw the view

Invalidate(pView);

 

Conclusion

L’utilisation de Boost et de Boost.Serialization est plutôt simple à appréhender. La documentation fournie est de bonne facture et les exemples sont légions dans la documentation. L’avantage de Boost.Serialization est que les archives sont portables… Donc pour faire du multi-plateforme, c’est easy ! Le code complet de l’application de dessin est disponible ici : http://ultrafluid.codeplex.com .

 

Conclusion sur la série « Je Pratique C++ »

Avec cet article, la série « Je pratique le C++ » s’arrête mais je vais trouver un deal avec Programmez pour que nous ayons toujours du C++ dans Programmez. Tous les logiciels Microsoft sont faits en C/C++ à 90% et il ne serait pas normal de ne pas en parler. Le C++ n’est pas mort, loin de la. Avec C++11, le C++ à rajeuni et les standards C++14 et C++17 apportent leur lot de nouveautés. Stay tuned comme dirait l’autre et à Bientôt pour de nouveaux articles sur le C++.