Ubuntu-fr

HP

Re : /* Topic des codeurs [7] */

Petit test de développemnt d'extension (simple), avec le Add-on SDK :

Assez favorablement impressionné… même si tout n'est pas parfait : il faut, par exemple, travailler dans le dossier du sdk… ce qui est un peu étrange et assez peu pratique ; même si, on peut (légèrement) s'en arranger avec des liens symboliques.

---

cat /dev/urandom >/dev/null 2>&1 #github

Pylades

Re : /* Topic des codeurs [7] */

Elzen, peut-être la solution à tes soucis de touchpad…

Faut juste trouver comme s’appelle le paquet chez Debian. ^^
Trouvé : http://packages.debian.org/squeeze/xser … -synaptics.

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

Elzen

Re : /* Topic des codeurs [7] */

Soucis, ç't'un bien grand mot, hein ^^ Ça n'me dérange pas particulièrement, c'est juste que ça pourrait éventuellement être fun.

Le paquet est déjà installé chez moi ; je regarderai la doc pour voir la config qu'il y a à faire un peu plus tard, merci

---

Elzen : polisson, polémiste, polymathe ! (ex-ArkSeth)
Un script pour améliorer quelques trucs du forum.
La joie de t'avoir connu surpasse la peine de t'avoir perdu…
timezone[blocklist]

Ras'

Re : /* Topic des codeurs [7] */

Hej les copains !

J'me quote depuis le TdCT, je cherche un codeur qui aurait un peu de temps libre pour un mini truc dont j'aurai besoin, il/elle sera remercié(e) en bière, bisou, paypal et jeunes filles vierges et innocentes, les modalités restent à définir mais nous verrons ça plus tard :

Un genre de bonjourmadame, un truc très simple (très sobre)
Soit un peu évolué avec possibilité de faire précédent / suivant (je n'sais pas si c'est bien compliqué à faire, sur le papier ça paraît simple), soit un truc qui ne donne accès qu'à l'image du jour, à voir suivant la complexité.

Donc, tout comme le site exemple sus-cité, une page web qui affiche la photo du jour, et qui permette de voir les photos suivantes et précédentes (si la suivante existe bien sûr). C'est pour un décompte qui irait de 300 à 0, donc pour nommer les objets et faire un lien entre les pages c'est peut être plus simple, mais ça c'est si on veut se simplifier la vie au niveau du code...
(ne vous en faites pas, ce n'est pas pour faire « bonjournesthib » avec des photos de geek en caleçon, c'est un truc perso qui n'a rien de saiksuel)

---

Va t'faire shampouiner par le compteur_V2 en timezone[Canada/Eastern] !
 
Les types awesome n'ont rien à prouver. À personne.
'k bye là

HP

Re : /* Topic des codeurs [7] */

je cherche un codeur qui aurait un peu de temps libre pour un mini truc dont j'aurai besoin, […]

Dans ce cas, vas t'apprendre à coder…

---

cat /dev/urandom >/dev/null 2>&1 #github

Ras'

Re : /* Topic des codeurs [7] */

-____-'

Je demande si au hasard personne n'aurait envie de coder un truc et propose remerciement en échange, s'tout. J'me doute bien que je pourrais aussi apprendre à coder mais ça n'm'intéresse pas plus que ça et j'n'ai surtout pas le temps. Puis ce qui prendrait 1h à un codeur me prendrait plusieurs jours / semaines...

Enfin, si personne n'est intéressé pour ça je ferai un truc à-la-ras'

EDIT : semblerait que ça ne soit qu'un tumblr avec un thème approprié, faut juste que j'trouve comment le mettre à jour plus ou moins automatiquement.

Dernière modification par Ras' (Le 04/08/2012, à 12:07)

---

Va t'faire shampouiner par le compteur_V2 en timezone[Canada/Eastern] !
 
Les types awesome n'ont rien à prouver. À personne.
'k bye là

maxpoulin64

Re : /* Topic des codeurs [7] */

Hej les copains !

J'me quote depuis le TdCT, je cherche un codeur qui aurait un peu de temps libre pour un mini truc dont j'aurai besoin, il/elle sera remercié(e) en bière, bisou, paypal et jeunes filles vierges et innocentes, les modalités restent à définir mais nous verrons ça plus tard :

Un genre de bonjourmadame, un truc très simple (très sobre)
Soit un peu évolué avec possibilité de faire précédent / suivant (je n'sais pas si c'est bien compliqué à faire, sur le papier ça paraît simple), soit un truc qui ne donne accès qu'à l'image du jour, à voir suivant la complexité.

Donc, tout comme le site exemple sus-cité, une page web qui affiche la photo du jour, et qui permette de voir les photos suivantes et précédentes (si la suivante existe bien sûr). C'est pour un décompte qui irait de 300 à 0, donc pour nommer les objets et faire un lien entre les pages c'est peut être plus simple, mais ça c'est si on veut se simplifier la vie au niveau du code...
(ne vous en faites pas, ce n'est pas pour faire « bonjournesthib » avec des photos de geek en caleçon, c'est un truc perso qui n'a rien de saiksuel)

Un truc d'image dans le même genre que XKCD ( http://www.xkcd.com/ ) ? J'ai bien compris?

Mindiell

Re : /* Topic des codeurs [7] */

J'pense que l'plus long c'est surtout tout le édesigno-commercial" derrière en fait...

---

Développeur indépendant

maxpoulin64

Re : /* Topic des codeurs [7] */

PHP est en train de me rendre fou T_T

http://pix.toile-libre.org/?img=1344307838.png

Ligne 18, j'utilise $ex comme nom de variable référence dans un foreach bien normal
Ligne 20, je copie la référence dans le tableau (je dois modifier seulement ce sous-sous objet plus loin, mais je veux pas le copier)
Ligne 25, je vérifie que le tableau est bien remplis: OUI
Ligne 28, je réutilise $ex, ça correspond à la même chose, je vois pas pourquoi je changerais de noms, c'est comme le for($i=0;$i<10;$i++).
Ligne 35, le dernier élément de mon tableau vaut maintenant null. Il vaut même pas la dernière valeur de mon while! Nah, il vaut NULL!
Ligne 39, kaboom, un truc qui est nécessairement présent n'y est plus.

EDIT: Bon, apparamment que si je ne fais que mettre la référence dans le tableau, ça marche. C'est pas clair en PHP si tu accède à la référence ou si tu accède à la valeur de la référence ><

Je veux bien que travailler avec des références en PHP soit doublement plus suicidaire que de le faire en C, mais de là à confondre le scope des variables, ça devient ridicule. Surtout que j'aurais pu utiliser quelque chose de bien trop générique, comme $i ou $e ><

Ça fait 3 mois que je suis sur ce projet à la con, me reste encore pour 2-3 semaines, je sens que je vais craquer.

Vous avez des trucs pour pas vous pendre quand vous travaillez sur des projets chiants? HTML/CSS/Javascript/PHP, je peux pas trouver quoi que ce soit qui donne le plus envie de se suicider -_-"

Dernière modification par maxpoulin64 (Le 07/08/2012, à 05:22)

grim7reaper

Re : /* Topic des codeurs [7] */

Je veux bien que travailler avec des références en PHP soit doublement plus suicidaire que de le faire en C

Surtout qu’en C y’a pas de référence en fait :] (en C++ oui, en C non).

je peux pas trouver quoi que ce soit qui donne le plus envie de se suicider -_-"

Du VB ?
Du Cobol ?
Utiliser un DSL qui impose Microsoft Word en tant qu’IDE (c’est du vécu) ?

Dernière modification par grim7reaper (Le 07/08/2012, à 05:51)

---

Blog

The Uploader

Re : /* Topic des codeurs [7] */

Javascript c'est bien pourri aussi.

---

- Oldies PC : Intel Pentium 3 @ 800 Mhz sur CM ASUS P2B-F, GeForce 4 Ti4800 SE, Disque Dur Hitachi 160 Go, 512 Mo de RAM, 3DFX Voodoo 2, Sound Blaster 16 ISA PnP, Windows 98 SE / XP)
- Desktop : Intel Core i7 6700K @ 4 GHz sur CM ASUS Z170-P, GeForce GTX 1070, SSD Samsung 850 EVO 1 To, 16 Go de RAM, Disque Dur Seagate Barracuda 3 To, Windows 10

grim7reaper

Re : /* Topic des codeurs [7] */

Tiens, comme le chan IRC d’Hortus Belli est plus mort que mort, je reposte ma question ici pour ceux concernés :

17:47 < grim7reaper> plop
17:47 < grim7reaper> ça avance super bien à ce que je vois :]
17:47 < grim7reaper> bon au moins je vais pas être dépaysé par les changements dans le code ^^
17:47 < grim7reaper> je devrais avoir un peu de temps dans la semaine à venir
17:48 < grim7reaper> on bossait sur quoi déjà ?

---

Blog

Jules Petibidon

Re : /* Topic des codeurs [7] */

@maxpoulin

Y'a une raison spéciale qui t'oblige à utiliser des références dans un foreach ?

The Uploader

Re : /* Topic des codeurs [7] */

Tiens en parlant de jeux, j'ai regardé le code du binding existant pour RubySFML...

Ben y'a pas un fichier source auxquel j'ai absolument rien compris.. :
SFML-1.2/ruby/RubySFML/ruby_helper.h (28,7 Kio, c'est de loin le plus gros fichier de toutes les sources, bizarre pour un "helper" !)

////////////////////////////////////////////////////////////
//
// RubySFML - Ruby extension for the SFML library
// Copyright (C) 2007 Sean O'Neil and Laurent Gomila
// (sean.p.oneil@gmail.com and laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////

#ifndef __ruby_helper_h__
#define __ruby_helper_h__
#define NOMINMAX
#include <string>
#include <algorithm>
#include <iostream>
#if defined(_WIN32) || defined(__WIN32__)
    #include <winsock2.h>
#endif
#include <ruby.h>

#if defined(_WIN32) || defined(__WIN32__)
    #define DECL __cdecl
#else
    #define DECL __attribute__((cdecl))
#endif

// Copies a string, makes the first character upper case, and then returns it
inline std::string fupr(const char *p) {
	std::string str = p;
	str[0] = toupper(str[0]);
	return str;
}

#define IS(v, c) rb_obj_class(v) == c
#define ISKO(v, c) rb_obj_is_kind_of(v, c)
#define ISNUM(v) ISKO(v, rb_cNumeric)
#define ISSTR(v) ISKO(v, rb_cString)

#define DECLARE_PTR_VAR(MyClass, MyVar, expr)\
	MyClass *p##MyVar = expr;\
	VALUE v##MyVar = p##MyVar == NULL ? Qnil : Data_Wrap_Struct(g_c##MyClass, 0, 0, p##MyVar)

#define DECLARE_OBJ_VAR(MyClass, MyVar, expr)\
	VALUE v##MyVar = MyClass##_new(0, NOARGV, g_c##MyClass);\
	MyClass *p##MyVar = NULL;\
	Data_Get_Struct(v##MyVar, MyClass, p##MyVar);\
	*p##MyVar = expr

#define GET_OBJ_VAR(MyClass, MyVar)\
	MyClass *p##MyVar = NULL;\
	Data_Get_Struct(v##MyVar, MyClass, p##MyVar)

#define DEFINE_CLASS_METHOD(MyClass, MyMethod, n)\
	rb_define_singleton_method(g_c##MyClass, #MyMethod,\
		(unsigned long (DECL *)(...))MyClass##_##MyMethod, n)

#define DEFINE_CLASS_METHOD2(MyClass, MyMethod, RubyMethod, n)\
	rb_define_singleton_method(g_c##MyClass, #RubyMethod,\
		(unsigned long (DECL *)(...))MyClass##_##MyMethod, n)

#define DEFINE_INSTANCE_METHOD(MyClass, MyMethod, n)\
	rb_define_method(g_c##MyClass, #MyMethod,\
		(unsigned long (DECL *)(...))MyClass##_##MyMethod, n)

#define DEFINE_INSTANCE_METHOD2(MyClass, MyMethod, RubyMethod, n)\
	rb_define_method(g_c##MyClass, #RubyMethod,\
		(unsigned long (DECL *)(...))MyClass##_##MyMethod, n)

// Use to define a standard getter method (for any type of member)
// (Defines both obj.variableName and obj.getVariableName)
#define DEFINE_GETTER(MyClass, MyField) \
	rb_define_method(g_c##MyClass, #MyField, \
		(unsigned long (DECL *)(...))MyClass##_get_##MyField, 0);\
	rb_define_method(g_c##MyClass, (std::string("get")+fupr(#MyField)).c_str(), \
		(unsigned long (DECL *)(...))MyClass##_get_##MyField, 0)

// Use to define a standard setter method (for any type of member)
// (Defines both obj.variableName = v and obj.setVariableName v)
#define DEFINE_SETTER(MyClass, MyField) \
	rb_define_method(g_c##MyClass, #MyField "=", \
		(unsigned long (DECL *)(...))MyClass##_set_##MyField, 1);\
	rb_define_method(g_c##MyClass, (std::string("set")+fupr(#MyField)).c_str(), \
		(unsigned long (DECL *)(...))MyClass##_set_##MyField, 1)

// Use to define standard getter and setter methods (for any type of member)
#define DEFINE_RW(MyClass, MyField) \
	DEFINE_GETTER(MyClass, MyField);\
	DEFINE_SETTER(MyClass, MyField)

// Use to define a standard getter method (for any type of member)
// (Defines both obj.variableName and obj.getVariableName)
#define DEFINE_GETTER2(MyClass, MyField, RubyField) \
	rb_define_method(g_c##MyClass, #RubyField, \
		(unsigned long (DECL *)(...))MyClass##_get_##MyField, 0);\
	rb_define_method(g_c##MyClass, (std::string("get")+fupr(#RubyField)).c_str(), \
		(unsigned long (DECL *)(...))MyClass##_get_##MyField, 0)

// Use to define a standard setter method (for any type of member)
// (Defines both obj.variableName = v and obj.setVariableName v)
#define DEFINE_SETTER2(MyClass, MyField, RubyField) \
	rb_define_method(g_c##MyClass, #RubyField "=", \
		(unsigned long (DECL *)(...))MyClass##_set_##MyField, 1);\
	rb_define_method(g_c##MyClass, (std::string("set")+fupr(#RubyField)).c_str(), \
		(unsigned long (DECL *)(...))MyClass##_set_##MyField, 1)

// Use to define standard getter and setter methods (for any type of member)
#define DEFINE_RW2(MyClass, MyField, RubyField) \
	DEFINE_GETTER2(MyClass, MyField, RubyField);\
	DEFINE_SETTER2(MyClass, MyField, RubyField)

// Use to define a static getter method (for any type of member)
// (Defines both Class.variableName and Class.getVariableName)
#define DEFINE_STATIC_GETTER(MyClass, MyField) \
	rb_define_singleton_method(g_c##MyClass, #MyField, \
		(unsigned long (DECL *)(...))MyClass##_get_##MyField, 0);\
	rb_define_singleton_method(g_c##MyClass, (std::string("get")+fupr(#MyField)).c_str(), \
		(unsigned long (DECL *)(...))MyClass##_get_##MyField, 0)

// Use to define a static setter method (for any type of member)
// (Defines both Class.variableName = v and Class.setVariableName v)
#define DEFINE_STATIC_SETTER(MyClass, MyField) \
	rb_define_singleton_method(g_c##MyClass, #MyField "=", \
		(unsigned long (DECL *)(...))MyClass##_set_##MyField, 1);\
	rb_define_singleton_method(g_c##MyClass, (std::string("set")+fupr(#MyField)).c_str(), \
		(unsigned long (DECL *)(...))MyClass##_set_##MyField, 1)

// Use to define static getter and setter methods (for any type of member)
#define DEFINE_STATIC_RW(MyClass, MyField) \
	DEFINE_STATIC_GETTER(MyClass, MyField);\
	DEFINE_STATIC_SETTER(MyClass, MyField)

#define DEFINE_MODULE_CONST(MyConst)\
	rb_define_const(g_vModule, #MyConst, INT2FIX(MyConst))

#define DEFINE_MODULE_METHOD(MyMethod, RubyMethod, n)\
	rb_define_singleton_method(g_vModule, #RubyMethod,\
		(unsigned long (DECL *)(...))SFML_##MyMethod, n)

#define DEFINE_INT_CONST(MyClass, MyConst)\
	rb_define_const(g_c##MyClass, #MyConst, INT2FIX(MyClass::MyConst))

#define DEFINE_PTR_CONST(MyClass, MyConst, expr)\
	rb_define_const(g_c##MyClass, #MyConst, Data_Wrap_Struct(g_c##MyClass, 0, 0, expr))


#define DECLARE_VOID_METHOD(MyClass, MyMethod)\
static VALUE MyClass##_##MyMethod(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyMethod();\
	return vSelf;\
}\

// Use to declare standard free, new, and init methods with 0 parameters
#define DECLARE_FREE_NEW_INIT0(MyClass)\
static void MyClass##_free(void *p)\
{\
	delete (MyClass *)p;\
}\
static VALUE MyClass##_new(VALUE vClass)\
{\
	VALUE argv[1];\
	MyClass *ptr = new MyClass;\
	VALUE tData = Data_Wrap_Struct(vClass, 0, MyClass##_free, ptr);\
	rb_obj_call_init(tData, 0, argv);\
	return tData;\
}\
static VALUE MyClass##_initialize(VALUE vSelf)\
{\
	return vSelf;\
}

// Use to declare standard free and new methods with 1 parameter
#define DECLARE_FREE_NEW1(MyClass)\
static void MyClass##_free(void *p)\
{\
	delete (MyClass *)p;\
}\
static VALUE MyClass##_new(VALUE vClass, VALUE v1)\
{\
	VALUE argv[1];\
	argv[0] = v1;\
	MyClass *ptr = new MyClass;\
	VALUE tData = Data_Wrap_Struct(vClass, 0, MyClass##_free, ptr);\
	rb_obj_call_init(tData, 1, argv);\
	return tData;\
}

// Use to define standard free, new, and init methods with n parameters
// (Also declares a free method)
#define DEFINE_CLASS_NEW_INIT(MyClass, n)\
	g_c##MyClass = rb_define_class(#MyClass, rb_cObject);\
	DEFINE_CLASS_METHOD(MyClass, new, n);\
	DEFINE_INSTANCE_METHOD(MyClass, initialize, n);


// Use to declare a standard getter method for a public int member
#define DECLARE_INT_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return INT2NUM((int)ptr->MyField);\
}

// Use to declare a static getter method for a public int member
#define DECLARE_STATIC_INT_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vClass)\
{\
	return INT2NUM((int)MyClass::MyField);\
}

// Use to declare a standard setter method for a public int member
#define DECLARE_INT_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = NUM2INT(v);\
	return v;\
}

// Use to declare a static setter method for a public int member
#define DECLARE_STATIC_INT_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vClass)\
{\
	MyClass::MyField = NUM2INT(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public int member
#define DECLARE_INT_RW(MyClass, MyField)\
DECLARE_INT_GETTER(MyClass, MyField)\
DECLARE_INT_SETTER(MyClass, MyField)

// Use to declare static getter and setter methods for a public int member
#define DECLARE_STATIC_INT_RW(MyClass, MyField)\
DECLARE_STATIC_INT_GETTER(MyClass, MyField)\
DECLARE_STATIC_INT_SETTER(MyClass, MyField)

// Use to declare a standard setter method for a public enum member
#define DECLARE_ENUM_SETTER(MyClass, MyField, EnumType)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = (EnumType)NUM2INT(v);\
	return v;\
}

// Use to declare a standard setter method for a public enum member
#define DECLARE_STATIC_ENUM_SETTER(MyClass, MyField, EnumType)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass::MyField = (EnumType)NUM2INT(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public enum member
#define DECLARE_ENUM_RW(MyClass, MyField, EnumType)\
DECLARE_INT_GETTER(MyClass, MyField)\
DECLARE_ENUM_SETTER(MyClass, MyField, EnumType)

// Use to declare standard getter and setter methods for a public enum member
#define DECLARE_STATIC_ENUM_RW(MyClass, MyField, EnumType)\
DECLARE_STATIC_INT_GETTER(MyClass, MyField)\
DECLARE_STATIC_ENUM_SETTER(MyClass, MyField, EnumType)

// Use to declare a standard getter method for a public bool member
#define DECLARE_BOOL_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return ptr->MyField ? Qtrue : Qfalse;\
}

// Use to declare a static getter method for a public bool member
#define DECLARE_STATIC_BOOL_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vClass)\
{\
	return MyClass::MyField ? Qtrue : Qfalse;\
}

// Use to declare a standard setter method for a public bool member
#define DECLARE_BOOL_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = RTEST(v) ? true : false;\
	return v;\
}

// Use to declare a static setter method for a public bool member
#define DECLARE_STATIC_BOOL_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vClass, VALUE v)\
{\
	MyClass::MyField = RTEST(v) ? true : false;\
	return v;\
}

// Use to declare standard getter and setter methods for a public int member
#define DECLARE_BOOL_RW(MyClass, MyField)\
DECLARE_BOOL_GETTER(MyClass, MyField)\
DECLARE_BOOL_SETTER(MyClass, MyField)

// Use to declare standard getter and setter methods for a public int member
#define DECLARE_STATIC_BOOL_RW(MyClass, MyField)\
DECLARE_STATIC_BOOL_GETTER(MyClass, MyField)\
DECLARE_STATIC_BOOL_SETTER(MyClass, MyField)

// Use to declare a standard getter method for a public double member
#define DECLARE_DOUBLE_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return rb_float_new((double)ptr->MyField);\
}

// Use to declare a static getter method for a public double member
#define DECLARE_STATIC_DOUBLE_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	return rb_float_new((double)MyClass::MyField);\
}

// Use to declare a standard setter method for a public double member
#define DECLARE_DOUBLE_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = (float)NUM2DBL(v);\
	return v;\
}

// Use to declare a static setter method for a public double member
#define DECLARE_STATIC_DOUBLE_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass::MyField = NUM2DBL(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public double member
#define DECLARE_DOUBLE_RW(MyClass, MyField)\
DECLARE_DOUBLE_GETTER(MyClass, MyField)\
DECLARE_DOUBLE_SETTER(MyClass, MyField)

// Use to declare standard getter and setter methods for a public double member
#define DECLARE_STATIC_DOUBLE_RW(MyClass, MyField)\
DECLARE_DOUBLE_STATIC_GETTER(MyClass, MyField)\
DECLARE_DOUBLE_STATIC_SETTER(MyClass, MyField)

// Use to declare a standard getter method for a public std::string member
#define DECLARE_STRING_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return rb_str_new2(ptr->MyField.c_str());\
}

// Use to declare a static getter method for a public std::string member
#define DECLARE_STATIC_STRING_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	return rb_str_new2(MyClass::MyField.c_str());\
}

// Use to declare a standard setter method for a public std::string member
#define DECLARE_STRING_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = STR2CSTR(v);\
	return v;\
}

// Use to declare a static setter method for a public std::string member
#define DECLARE_STATIC_STRING_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass::MyField = STR2CSTR(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public std::string member
#define DECLARE_STRING_RW(MyClass, MyField)\
DECLARE_STRING_GETTER(MyClass, MyField)\
DECLARE_STRING_SETTER(MyClass, MyField)

// Use to declare standard getter and setter methods for a public int member
#define DECLARE_STATIC_STRING_RW(MyClass, MyField)\
DECLARE_STATIC_STRING_GETTER(MyClass, MyField)\
DECLARE_STATIC_STRING_SETTER(MyClass, MyField)

// Use to declare a standard getter method for a public short member
#define DECLARE_SHORT_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return INT2FIX((int)ptr->MyField);\
}

// Use to declare a standard getter method for a public short member
#define DECLARE_STATIC_SHORT_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	return INT2FIX((int)MyClass->MyField);\
}

// Use to declare a standard setter method for a public short member
#define DECLARE_SHORT_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = (short)FIX2INT(v);\
	return v;\
}

// Use to declare a standard setter method for a public short member
#define DECLARE_STATIC_SHORT_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass::MyField = (short)FIX2INT(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public short member
#define DECLARE_SHORT_RW(MyClass, MyField)\
DECLARE_SHORT_GETTER(MyClass, MyField)\
DECLARE_SHORT_SETTER(MyClass, MyField)

// Use to declare standard getter and setter methods for a public short member
#define DECLARE_STATIC_SHORT_RW(MyClass, MyField)\
DECLARE_STATIC_SHORT_GETTER(MyClass, MyField)\
DECLARE_STATIC_SHORT_SETTER(MyClass, MyField)


// Use to declare a standard getter method for a public object member
#define DECLARE_OBJ_GETTER(MyClass, MyField, FieldType)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	VALUE vRet = FieldType##_new(0, NOARGV, g_c##FieldType);\
	FieldType *pRet;\
	Data_Get_Struct(vRet, FieldType, pRet);\
	*pRet = pSelf->MyField;\
	return vRet;\
}

// Use to declare a static getter method for a public object member
#define DECLARE_STATIC_OBJ_GETTER(MyClass, MyField, FieldType)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	VALUE vRet = FieldType##_new(0, NOARGV, g_c##FieldType);\
	FieldType *pRet;\
	Data_Get_Struct(vRet, FieldType, pRet);\
	*pRet = MyClass::MyField;\
	return vRet;\
}

// Use to declare a standard setter method for a public object member
#define DECLARE_OBJ_SETTER(MyClass, MyField, FieldType)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	FieldType *pV;\
	Data_Get_Struct(v, FieldType, pV);\
	pSelf->MyField = *pV;\
	return Qnil;\
}

// Use to declare a static setter method for a public object member
#define DECLARE_STATIC_OBJ_SETTER(MyClass, MyField, FieldType)\
static VALUE MyClass##_set_##MyField(VALUE vClass, VALUE v)\
{\
	FieldType *pV;\
	Data_Get_Struct(v, FieldType, pV);\
	MyClass::MyField = *pV;\
	return Qnil;\
}

// Use to declare standard getter and setter methods for a public object member
#define DECLARE_OBJ_RW(MyClass, MyField, FieldType)\
DECLARE_OBJ_GETTER(MyClass, MyField, FieldType)\
DECLARE_OBJ_SETTER(MyClass, MyField, FieldType)

// Use to declare static getter and setter methods for a public object member
#define DECLARE_STATIC_OBJ_RW(MyClass, MyField, FieldType)\
DECLARE_STATIC_OBJ_GETTER(MyClass, MyField, FieldType)\
DECLARE_STATIC_OBJ_SETTER(MyClass, MyField, FieldType)


// Use to declare a standard getter method for a public unsigned short member
#define DECLARE_USHORT_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return INT2FIX((int)ptr->MyField);\
}

// Use to declare a standard getter method for a public unsigned short member
#define DECLARE_STATIC_USHORT_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	return INT2FIX((int)MyClass->MyField);\
}

// Use to declare a standard setter method for a public unsigned short member
#define DECLARE_USHORT_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = (unsigned short)FIX2INT(v);\
	return v;\
}

// Use to declare a standard setter method for a public unsigned short member
#define DECLARE_STATIC_USHORT_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass::MyField = (unsigned short)FIX2INT(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public unsigned short member
#define DECLARE_USHORT_RW(MyClass, MyField)\
DECLARE_USHORT_GETTER(MyClass, MyField)\
DECLARE_USHORT_SETTER(MyClass, MyField)

// Use to declare standard getter and setter methods for a public unsigned short member
#define DECLARE_STATIC_USHORT_RW(MyClass, MyField)\
DECLARE_STATIC_USHORT_GETTER(MyClass, MyField)\
DECLARE_STATIC_USHORT_SETTER(MyClass, MyField)


// Use to declare a standard getter method for a public unsigned char member
#define DECLARE_UCHAR_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return INT2FIX((int)ptr->MyField);\
}

// Use to declare a standard getter method for a public unsigned char member
#define DECLARE_STATIC_UCHAR_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	return INT2FIX((int)MyClass->MyField);\
}

// Use to declare a standard setter method for a public unsigned char member
#define DECLARE_UCHAR_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = (unsigned char)FIX2INT(v);\
	return v;\
}

// Use to declare a standard setter method for a public unsigned char member
#define DECLARE_STATIC_UCHAR_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass::MyField = (unsigned char)FIX2INT(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public unsigned char member
#define DECLARE_UCHAR_RW(MyClass, MyField)\
DECLARE_UCHAR_GETTER(MyClass, MyField)\
DECLARE_UCHAR_SETTER(MyClass, MyField)

// Use to declare standard getter and setter methods for a public unsigned char member
#define DECLARE_STATIC_UCHAR_RW(MyClass, MyField)\
DECLARE_STATIC_UCHAR_GETTER(MyClass, MyField)\
DECLARE_STATIC_UCHAR_SETTER(MyClass, MyField)


// Use to declare a standard getter method for a public char member
#define DECLARE_CHAR_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return INT2FIX((int)ptr->MyField);\
}

// Use to declare a standard getter method for a public char member
#define DECLARE_STATIC_CHAR_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	return INT2FIX((int)MyClass->MyField);\
}

// Use to declare a standard setter method for a public char member
#define DECLARE_CHAR_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = (char)FIX2INT(v);\
	return v;\
}

// Use to declare a standard setter method for a public char member
#define DECLARE_STATIC_CHAR_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass::MyField = (char)FIX2INT(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public char member
#define DECLARE_CHAR_RW(MyClass, MyField)\
DECLARE_CHAR_GETTER(MyClass, MyField)\
DECLARE_CHAR_SETTER(MyClass, MyField)

// Use to declare standard getter and setter methods for a public char member
#define DECLARE_STATIC_CHAR_RW(MyClass, MyField)\
DECLARE_STATIC_CHAR_GETTER(MyClass, MyField)\
DECLARE_STATIC_CHAR_SETTER(MyClass, MyField)

// Use to declare a standard getter method for a public int64 member
#define DECLARE_INT64_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return LL2NUM(ptr->MyField);\
}

// Use to declare a static getter method for a public int64 member
#define DECLARE_STATIC_INT64_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vClass)\
{\
	return LL2NUM(MyClass::MyField);\
}

// Use to declare a standard setter method for a public int64 member
#define DECLARE_INT64_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = NUM2LL(v);\
	return v;\
}

// Use to declare a static setter method for a public int64 member
#define DECLARE_STATIC_INT64_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vClass)\
{\
	MyClass::MyField = NUM2LL(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public int64 member
#define DECLARE_INT64_RW(MyClass, MyField)\
DECLARE_INT64_GETTER(MyClass, MyField)\
DECLARE_INT64_SETTER(MyClass, MyField)

// Use to declare static getter and setter methods for a public int64 member
#define DECLARE_STATIC_INT64_RW(MyClass, MyField)\
DECLARE_STATIC_INT64_GETTER(MyClass, MyField)\
DECLARE_STATIC_INT64_SETTER(MyClass, MyField)


// Use to declare a standard getter method for a public uint64 member
#define DECLARE_UINT64_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	return ULL2NUM(ptr->MyField);\
}

// Use to declare a static getter method for a public uint64 member
#define DECLARE_STATIC_UINT64_GETTER(MyClass, MyField)\
static VALUE MyClass##_get_##MyField(VALUE vClass)\
{\
	return ULL2NUM(MyClass::MyField);\
}

// Use to declare a standard setter method for a public uint64 member
#define DECLARE_UINT64_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *ptr;\
	Data_Get_Struct(vSelf, MyClass, ptr);\
	ptr->MyField = NUM2ULL(v);\
	return v;\
}

// Use to declare a static setter method for a public uint64 member
#define DECLARE_USTATIC_INT64_SETTER(MyClass, MyField)\
static VALUE MyClass##_set_##MyField(VALUE vClass)\
{\
	MyClass::MyField = NUM2ULL(v);\
	return v;\
}

// Use to declare standard getter and setter methods for a public uint64 member
#define DECLARE_UINT64_RW(MyClass, MyField)\
DECLARE_UINT64_GETTER(MyClass, MyField)\
DECLARE_UINT64_SETTER(MyClass, MyField)

// Use to declare static getter and setter methods for a public uint64 member
#define DECLARE_STATIC_UINT64_RW(MyClass, MyField)\
DECLARE_STATIC_UINT64_GETTER(MyClass, MyField)\
DECLARE_STATIC_UINT64_SETTER(MyClass, MyField)


#define DECLARE_INT_ARR_GETTER(MyClass, MyField, Size)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	VALUE v = rb_ary_new();\
	for(int i=0; i<Size; i++)\
		rb_ary_push(v, INT2FIX(pSelf->MyField[i]));\
	return v;\
}

#define DECLARE_INT_ARR_SETTER(MyClass, MyField, Size)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	for(int i=0; i<Size; i++)\
		pSelf->MyField[i] = FIX2INT(rb_ary_entry(v, i));\
	return v;\
}

#define DECLARE_INT_ARR_RW(MyClass, MyField, Size)\
DECLARE_INT_ARR_GETTER(MyClass, MyField, Size);\
DECLARE_INT_ARR_SETTER(MyClass, MyField, Size)


#define DECLARE_DOUBLE_ARR_GETTER(MyClass, MyField, Size)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	VALUE v = rb_ary_new();\
	for(int i=0; i<Size; i++)\
		rb_ary_push(v, rb_float_new(pSelf->MyField[i]));\
	return v;\
}

#define DECLARE_DOUBLE_ARR_SETTER(MyClass, MyField, Size)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	for(int i=0; i<Size; i++)\
		pSelf->MyField[i] = NUM2DBL(rb_ary_entry(v, i));\
	return v;\
}

#define DECLARE_DOUBLE_ARR_RW(MyClass, MyField, Size)\
DECLARE_DOUBLE_ARR_GETTER(MyClass, MyField, Size);\
DECLARE_DOUBLE_ARR_SETTER(MyClass, MyField, Size)


#define DECLARE_ADDR_GETTER(MyClass, MyField, FieldType)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	VALUE vRet = Data_Wrap_Struct(g_c##FieldType, 0, 0, &pSelf->MyField);\
	return vRet;\
}

// Use to declare a standard getter method for a public object pointer member
#define DECLARE_PTR_GETTER(MyClass, MyField, FieldType)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	VALUE vRet = Data_Wrap_Struct(g_c##FieldType, 0, 0, pSelf->MyField);\
	return vRet;\
}


// Use to declare a standard getter method for a public object reference member
#define DECLARE_REF_GETTER(MyClass, MyField, FieldType)\
static VALUE MyClass##_get_##MyField(VALUE vSelf)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	pSelf->MyField->ReferenceCountedObject_refCount.increment();\
	VALUE vRet = Data_Wrap_Struct(g_c##FieldType, 0, FieldType##_free, pSelf->MyField.pointer());\
	return vRet;\
}

// Use to declare a standard setter method for a public object reference member
#define DECLARE_REF_SETTER(MyClass, MyField, FieldType)\
static VALUE MyClass##_set_##MyField(VALUE vSelf, VALUE v)\
{\
	MyClass *pSelf;\
	Data_Get_Struct(vSelf, MyClass, pSelf);\
	FieldType *pV;\
	Data_Get_Struct(v, FieldType, pV);\
	pSelf->MyField = pV;\
	return Qnil;\
}

// Use to declare standard getter and setter methods for a public object member
#define DECLARE_REF_RW(MyClass, MyField, FieldType)\
DECLARE_REF_GETTER(MyClass, MyField, FieldType)\
DECLARE_REF_SETTER(MyClass, MyField, FieldType)


#endif // __ruby_helper_h__

En fait si j'pense que j'comprends le but, mais quand j'ai vu la taille du truc j'ai laissé tomber la mise à jour du binding vers la SFML 2.0...

J'crois que sans bien connaître la SFML, et s'y connaître en matière de bindings <langage bas niveau> <-> <langage haut niveau> (j'ai pas trouvé beaucoup de how to là dessus d'ailleurs. Rien, en fait. Pas pour la SFML évidemment, mais en général..), c'est mort.

Pourtant j'adorerais le faire. Des indices ?

edit : bon j'ai trouvé pour le moment :
http://www.swig.org/
et
http://en.wikipedia.org/wiki/Foreign_function_interface
Aller voir le binding Python serait pas mal aussi, j'pense.

Dernière modification par The Uploader (Le 07/08/2012, à 12:24)

---

- Oldies PC : Intel Pentium 3 @ 800 Mhz sur CM ASUS P2B-F, GeForce 4 Ti4800 SE, Disque Dur Hitachi 160 Go, 512 Mo de RAM, 3DFX Voodoo 2, Sound Blaster 16 ISA PnP, Windows 98 SE / XP)
- Desktop : Intel Core i7 6700K @ 4 GHz sur CM ASUS Z170-P, GeForce GTX 1070, SSD Samsung 850 EVO 1 To, 16 Go de RAM, Disque Dur Seagate Barracuda 3 To, Windows 10

maxpoulin64

Re : /* Topic des codeurs [7] */

@maxpoulin

Y'a une raison spéciale qui t'oblige à utiliser des références dans un foreach ?

- Éviter la copie d'un très gros tableau
- Modifier le tableau en question, et en plus j'ai besoin de passer la référence, parce que le tableau sera modifié par une autre fonction plus tard.

En gros, c'est un chargement de base de donnée en deux étapes.

1- Charger tout un calendrier générique de la base de donnée
2- Extraire les données à remplir de plus (ici, des ID d'exercices dans une autre collection)
3- Foutre les données des exercices dans le calendrier original

Après json_encode et zou dans la page.

C'est une super grosse application utilisée dans les gym que je développe (on a recommencé de zéro), donc une grosse appli PHP/Javascript. J'ai envie de me pendre, c'est déjà chiant à coder une appli javascript, si en plus faut tout repasser à PHP par la suite, déconstruire et reconstruire 4-5 niveaux d'objets (en les mettants en JSON entre les deux), c'est vraiment horrible et long. (Et ça fait beaucoup de copie).

The Uploader

Re : /* Topic des codeurs [7] */

Tu a recommencé à partir de zéro, mais tu n'as pas le choix des technos ?

Dernière modification par The Uploader (Le 07/08/2012, à 09:14)

---

- Oldies PC : Intel Pentium 3 @ 800 Mhz sur CM ASUS P2B-F, GeForce 4 Ti4800 SE, Disque Dur Hitachi 160 Go, 512 Mo de RAM, 3DFX Voodoo 2, Sound Blaster 16 ISA PnP, Windows 98 SE / XP)
- Desktop : Intel Core i7 6700K @ 4 GHz sur CM ASUS Z170-P, GeForce GTX 1070, SSD Samsung 850 EVO 1 To, 16 Go de RAM, Disque Dur Seagate Barracuda 3 To, Windows 10

maxpoulin64

Re : /* Topic des codeurs [7] */

Tu a recommencé à partir de zéro, mais tu n'as pas le choix des technos ?

Si, j'ai réussi à virer cette bouse de MySQL à temps en faveur de du NoSQL.

Vu les contraintes de temps de merde, et ceux qui devaient m'aider au début, je pouvais pas me permettre de me lancer dans un truc que je connaissais pas, pis en bonus j'aurais du me débarasser des autres devs. Au final sont tous partis pareil, mais reste qu'avec les contraintes de temps j'avais aucunement le temps de faire des tests suffisants pour me lancer dans un langage que je connais pas. Pas sur un aussi gros projet. Avoir eu un peu plus de temps j'aurais surement été voir du côté de RoR avec Ruby (parce que Python ça me donne envie de vomir).

Au final c'est pas tant le PHP qui m'enmerde d'ailleurs, sauf quand on tombe dans les bugs à la con de PHP. J'aime bien PHP quand-même, pour faire des trucs simples et rapides ça le fait pas trop mal. C'est surtout le Javascript qui est une horreur pas possible, chaque fois que j'imagine un bon design ça merde parce que c'est du JS. Enfin, encore, du JS pure, c'est pas si mal. Mais pour faire des interfaces complexes (menus déroulants, clic droit, plusieurs fenêtres, contenu qui s'actualise partout, etc.) c'est vraiment chiant, surtout de devoir gérer le DOM à plusieurs endroits à la fois. Enfin, pas besoin d'expliquer, c'est assez connu. J'ai pensé à AngularJS, mais encore une fois pas le temps d'apprendre (et pis c'est pas valide HTML5, à cause des ng-model, ng-app). Y'a jQuery qui déconne une fois de temps en temps aussi.

Jules Petibidon

Re : /* Topic des codeurs [7] */

C'est assez casse-gueule comme méthode.

Concernant l'économie sur la copie de gros tableaux, à priori c'est inutile. Voir ici : http://julien-pauli.developpez.com/tuto … variables/  (copy on write)

PHP ne crée pas de scopes pour les boucles, du coup tes lignes 20 et 31 posent un problème.

maxpoulin64

Re : /* Topic des codeurs [7] */

C'est assez casse-gueule comme méthode.

Concernant l'économie sur la copie de gros tableaux, à priori c'est inutile. Voir ici : http://julien-pauli.developpez.com/tuto … variables/  (copy on write)

PHP ne crée pas de scopes pour les boucles, du coup tes lignes 20 et 31 posent un problème.

Intéressant, je lirai ça demain.

Mais ça règle aucunement le problème du fait que j'ai besoin de travailler dans les profondeurs du tableau original, j'ai donc pas le choix d'utiliser une référence pour mon second tableau, si je veux pouvoir finir de remplir le tableau du début. Mais ça va m'éviter de faire des références pour rien (habitude tirée du C++? Sûrement).

Jules Petibidon

Re : /* Topic des codeurs [7] */

Rien ne t'empeche de continuer à utiliser des références, mais il faut faire très attention.

Dans ton cas, après ton premier bloc, le nom "$ex" est à considérer comme pestiféré. Il ne faut plus l'utiliser dans le scope courant. Ou alors peut-être en faisant un unset après la boucle. À tester, sans garantie.

HP

Re : /* Topic des codeurs [7] */

@maxpoulin

Y'a une raison spéciale qui t'oblige à utiliser des références dans un foreach ?

- Éviter la copie d'un très gros tableau
- Modifier le tableau en question, et en plus j'ai besoin de passer la référence, parce que le tableau sera modifié par une autre fonction plus tard.

Enfin, si le tableau modifié était une propriété d'objet (variable d'instance), tu pourrais éviter l'utilisation de référence… c'est ce que j'en dis.

---

cat /dev/urandom >/dev/null 2>&1 #github

Mindiell

Re : /* Topic des codeurs [7] */

J'crois que sans bien connaître la SFML

N'hésite pas à poser des questions sur le forum directement, à Laurent ou ici à moi alors

---

Développeur indépendant

tshirtman

Re : /* Topic des codeurs [7] */

There are no references. What PHP calls references are really aliases; there’s nothing that’s a step back, like Perl’s references, and there’s no pass-by-object identity like in Python.
“Referenceness” infects a variable unlike anything else in the language. PHP is dynamically-typed, so variables generally have no type… except references, which adorn function definitions, variable syntax, and assignment. Once a variable is made a reference (which can happen anywhere), it’s stuck as a reference. There’s no obvious way to detect this and un-referencing requires nuking the variable entirely.

http://me.veekun.com/blog/2012/04/09/ph … ad-design/

Je vois pas ce qui te fait aimer le php, pas plus que ce qui te fait vomir en python, mais ça ressemble sérieusement a un manque de gout pour l'élégance ^^.

Dernière modification par tshirtman (Le 08/08/2012, à 16:55)

---

Le blog de tshirtman, du python, du shell, du libre, et d'autres choses.
Mon petit frère écrit des trucs biens!
Ultimate smash friends, un smash bros like, libre paquet natty!

Dr Le Rouge

Re : /* Topic des codeurs [7] */

Utiliser un DSL qui impose Microsoft Word en tant qu’IDE (c’est du vécu) ?

Qui a eu une idée pareille ?

---

C'est deux suites de Cauchy qui veulent aller à la soirée 'no limit'. Hélas, à l'entrée le videur leur dit : "désolé, c'est complet !".
mon site perso (π²/6.fr) et mon blog

grim7reaper

Re : /* Topic des codeurs [7] */

Eux, en plus c’était un peu buggé jeune leur produit, je leur ai remonté 4-5 trucs…
À la base c’est pour générer plus au moins automatiquement les trucs que personne ne lit (du coup, comme ça personne les rédige non plus ^^'), genre document de conception…
D’après la doc c’était livré avec des styles pour émuler un semblant de coloration syntaxique dans Word, je les ai jamais trouvé…
Le principe, tu fais un fichier Word avec le langage dedans. Déjà rien que là c’est conceptuel : si je met le code en gras et en rouge, le code va te générer du texte gras et rouge :]
Après tu passes ça dans leur moulinette et ça te génère un beau fichier Word (à moins que tu ais fait une merde immonde ça « compileras » toujours). Après, là tu ouvres ton fichier et si tu as une couille quelque part Word te dit « Fichier corrombu, balise trucmuche à la ligne 1354543 blabla ». Et tu débug ça comment après ? ^^'

Après, honnêtement leur truc pour faire de la génération de code est pas mal foutu. Par contre, le truc pour la génération de document ça part d’un bon sentiment mais…

Dernière modification par grim7reaper (Le 08/08/2012, à 18:08)

---

Blog