Un site utilisant Quod est Absurdum

Informatique

Monthly Archives: juin 2012

Serveur dédié

Posted on by Posted in Non classé Leave a comment

Avec quelques amis, nous avons décidé de prendre un serveur dédié. Les buts étaient multiples:

  • que les geeks qui sommeillent (ou ne sommeillent pas) en nous puissent s’amuser
  • héberger des sites web
  • héberger des mails
  • d’une manière générale, quitter (ou ne pas utiliser) des services Google, c’est-à-dire trouver des alternatives à: Google Drive (ou Dropbox), gmail, documents google, agendas

Les outils

  • Pour les emails, pas de soucis. Héberger des mails, c’est classique.
  • Pour ce qui est de remplacer: Google Drive, Dropbox, des calendriers/agendas: ownCloud.
  • Pour Google Docs: on attend Libre Office Online (aka LOOL).

ownCloud

ownCloud est un logiciel libre fonctionnant comme service web (i.e. s’appuyant sur PHP & MySQL) pour fournir les services suivants:

  • gestion d’agendas
  • gestion de carnets d’adresses
  • gestion de fichiers (via web mais que l’on peut aussi monter en webdav)
  • streaming de musique
  • viewer de fichiers

Quelques liens:

Agendas

Mon but ici est d’utiliser ownCloud comme gestionnaire d’agendas et de synchroniser ensuite mes différents clients (Thunderbird, smratphone, webmail, …) avec lui.

  1. Sous ownCloud, créer un calendrier et en récupérer l’adresse CalDav.

Installation Thunderbird

  1. Sous Thunderbird, installer le plugin: Lightning.
  2. Le calendrier s’ajoute facilement dans l’onglets des calendriers, via le lien CalDav.

Contacts

Mon but ici est d’utiliser ownCloud comme gestionnaire de contacts et de synchroniser ensuite mes différents clients (Thunderbird, smratphone, webmail, …) avec lui. A la base, tous mes contacts étaient sous Thunderbird. Voici les différentes étapes:

  1. Exporter les contacts depuis Thunderbird
    Dans « Address book », choisir « Tools » puis « Export »
  2. Malheureusement, Thunderbird export les contacts en ldif et ownCloud les veut en vcard. Pour les convertir, il y a des outils en lignes (je leur fait pas confiance car on sait pas vraiment s’ils gardent les emails ou pas et je veux pas être responsable des fuites des emails des autres gens). L’application kaddressbook (sous Ubuntu, donc) permet d’importer le fichier ldif et de l’exporter en vcard. Parfait.
  3. Sous ownCloud, dans l’onglet contacts, importer le fichier et récupérer l’adresse CardDav. La mettre de côté.

Installation Thunderbird

  1. Sous Thunderbird, installer l’extensions « SOGo Connector Thunderbird extension », qui peut être téléchargée ici: http://www.sogo.nu/fr/downloads/frontends.html
  2. Aller dans le carnet d’addresse et « File » > « New » > « Remote address book » et entrer l’adresse CardDav récupérée.
  3. Cliquer sur le nouveau carnet d’adresse et choisir « Synchronize ».
  4. Eventuellement, supprimer les autres carnets d’adresses, 🙂

Instantiation dynamique en C++

Posted on by Posted in C++, C++ Leave a comment

Dans le cadre d’un petit projet, je me posais la question suivante: comment créer un objet facilement à partir du nom de sa classe. Par exemple, imaginons que j’aie une classe Product et deux classes qui héritent de Product: Product_child1 et Product_child2. On suppose de plus que ces deux classes ont les mêmes types de constructeur (par exemple un constructeur par défaut et un constructeur qui prend un entier comme paramètre). Mon but est de pouvoir faire quelque chose qui ressemble à cela:

Product *p1( instantiateObject( "Product_child1", 42 ) );
Product *p2( instantiateObject( "Product_child2", 58 ) );

Pour faire cela, on va passer par une classe ProductFactory qui va se charger de faire la création de l’objet selon le type souhaité. Cette classe va contenir un tableau associatif (map) avec une ligne pour chacun des types d’objets que l’on veut manipuler. Voici la classe en question:

class ProductFactory
{
	private:
		static map< string, Product *> productsTable;

	public:
		~ProductFactory( )
		{
			// libération de la mémoire
			map< string, Product *>::iterator itr;
			for( itr = productsTable.begin( ); itr != productsTable.end( ); ++ itr )
				delete itr->second;
		}

		void addProduct( string strClassName, Product *p )
		{
			ProductFactory::productsTable[ strClassName ] = p;
		}

		Product* instantiate( string strClassName, int iV )
		{
			if( productsTable.find( strClassName ) == productsTable.end( ) )
				return 0;

			return productsTable[ strClassName ]->create( iV );
		}
};

Pour pouvoir l’utiliser, notre main ressemble à cela:

int main() 
{
	// ------------------------------------------------------------------
	ProductFactory pf; // cet objet est utile tout au long du programe

	// on met une fois pour toute une instance de chaque classe
	pf.addProduct( "Product_child1", new Product_child1( ) );
	pf.addProduct( "Product_child2", new Product_child2( ) );

	// ------------------------------------------------------------------
	// création des objets
	Product *p1( pf.instantiate( "Product_child1", 42 ) );
	Product *p2( pf.instantiate( "Product_child2", 58 ) );

	// ------------------------------------------------------------------
	delete p1;
	delete p2;

    return 0; 
}

Et le code lié aux classes Produits:

class Product
{
protected:
	int iVal;

public:
	Product( int iValue )
		: iVal( iValue ) { }

	virtual ~Product( )
	{
	}

	virtual Product* create( int ) = 0;
	virtual void display( ) = 0;
};

class Product_child1 : public Product
{
public:
	Product_child1( ) 
		: Product( 0 )
	{
		cout << "Constructeur Product_child1 sans paramètre" << endl;
	}

	Product_child1( int iValue )
		: Product( iValue )
	{
		cout << "Constructeur Product_child1 avec paramètre: " << iValue << endl;
	}

	~Product_child1( )
	{
		cout << "Destructeur de Product_child1: " << iVal << endl;
	}

	Product_child1* create( int iV )
	{
		return new Product_child1( iV );
	}

	void display( )
	{
		cout << "display de Product_child1: " << iVal << endl;
	}
};

class Product_child2 : public Product
{
public:
	Product_child2( ) 
		: Product( 0 )
	{
		cout << "Constructeur Product_child2 sans paramètre" << endl;
	}

	Product_child2( int iValue ) 
		: Product( iValue )
	{
		cout << "Constructeur Product_child2 avec paramètre: " << iValue << endl;
	}

	~Product_child2( )
	{
		cout << "Destructeur de Product_child2 : " << iVal << endl;
	}

	Product_child2* create( int iV )
	{
		return new Product_child2( iV );
	}

	void display( )
	{
		cout << "display de Product_child2: " << iVal << endl;
	}
};

L’exécution du programme donne:

Constructeur Product_child1 sans paramètre
Constructeur Product_child2 sans paramètre
Constructeur Product_child1 avec paramètre: 42
Constructeur Product_child2 avec paramètre: 58
Destructeur de Product_child1: 42
Destructeur de Product_child2 : 58
Destructeur de Product_child1: 0
Destructeur de Product_child2 : 0

Voici le code complet:

#include <iostream>
#include <vector>
#include <map>
#include <string>

using namespace std;

class Product
{
protected:
	int iVal;

public:
	Product( int iValue )
		: iVal( iValue ) { }

	virtual ~Product( )
	{
	}

	virtual Product* create( int ) = 0;
	virtual void display( ) = 0;
};

class Product_child1 : public Product
{
public:
	Product_child1( ) 
		: Product( 0 )
	{
		cout << "Constructeur Product_child1 sans paramètre" << endl;
	}

	Product_child1( int iValue )
		: Product( iValue )
	{
		cout << "Constructeur Product_child1 avec paramètre: " << iValue << endl;
	}

	~Product_child1( )
	{
		cout << "Destructeur de Product_child1: " << iVal << endl;
	}

	Product_child1* create( int iV )
	{
		return new Product_child1( iV );
	}

	void display( )
	{
		cout << "display de Product_child1: " << iVal << endl;
	}
};

class Product_child2 : public Product
{
public:
	Product_child2( ) 
		: Product( 0 )
	{
		cout << "Constructeur Product_child1 sans paramètre" << endl;
	}

	Product_child2( int iValue ) 
		: Product( iValue )
	{
		cout << "Constructeur Product_child2 avec paramètre: " << iValue << endl;
	}

	~Product_child2( )
	{
		cout << "Destructeur de Product_child2 : " << iVal << endl;
	}

	Product_child2* create( int iV )
	{
		return new Product_child2( iV );
	}

	void display( )
	{
		cout << "display de Product_child2: " << iVal << endl;
	}
};

class ProductFactory
{
	private:
		static map< string, Product *> productsTable;

	public:
		~ProductFactory( )
		{
			// libération de la mémoire
			map< string, Product *>::iterator itr;
			for( itr = productsTable.begin( ); itr != productsTable.end( ); ++ itr )
				delete itr->second;
		}

		void addProduct( string strClassName, Product *p )
		{
			ProductFactory::productsTable[ strClassName ] = p;
		}

		Product* instantiate( string strClassName, int iV )
		{
			if( productsTable.find( strClassName ) == productsTable.end( ) )
				return 0;

			return productsTable[ strClassName ]->create( iV );
		}
};

map< string, Product *> ProductFactory::productsTable;

int main() 
{
	// ------------------------------------------------------------------
	ProductFactory pf; // cet objet est utile tout au long du programe

	// on met une fois pour toute une instance de chaque classe
	pf.addProduct( "Product_child1", new Product_child1( ) );
	pf.addProduct( "Product_child2", new Product_child2( ) );

	// ------------------------------------------------------------------
	// création des objets
	Product *p1( pf.instantiate( "Product_child1", 42 ) );
	Product *p2( pf.instantiate( "Product_child2", 58 ) );

	// ------------------------------------------------------------------
	delete p1;
	delete p2;

    return 0; 
}