tType *Types_Register(const tType *Type)
{
DEBUG("(Type=%p)", Type);
DEBUG_NL("Type=");
IF_DEBUG( Types_Print(stdout, Type) );
DEBUG_S("\n");
tType **retp = bsearch(&Type, gpTypeCache, giTypeCacheSize, sizeof(void*), Types_Compare_I);
if(retp) {
assert(*retp);
DEBUG("RETURN %p (cached)", *retp);
return *retp;
}
gpTypeCache = realloc(gpTypeCache, (giTypeCacheSize+1)*sizeof(void*));
assert(gpTypeCache);
tType *ret = malloc( sizeof(tType) );
*ret = *Type;
gpTypeCache[giTypeCacheSize] = ret;
giTypeCacheSize ++;
qsort(gpTypeCache, giTypeCacheSize, sizeof(void*), Types_Compare_I);
DEBUG("RETURN %p (new)", ret);
return ret;
}
int Types_RegisterTypedef(const char *Name, size_t NameLen, const tType *Type)
{
DEBUG_NL("(Name=%.*s, Type=", (int)NameLen, Name);
IF_DEBUG( Types_Print(stdout, Type) );
DEBUG_S(")\n");
tTypedef **pnp = &gpTypedefs;
for( tTypedef *td = gpTypedefs; td; pnp = &td->Next, td = td->Next )
{
int cmp = strncmp(td->Name, Name, NameLen);
if( cmp > 0 )
break;
if( cmp == 0 && strlen(td->Name) == NameLen )
{
if( Types_Compare(td->Base, Type) != 0 ) {
// Error! Incompatible redefinition
return -1;
}
// Compatible redefinition
return 1;
}
}
tTypedef *td = malloc( sizeof(tTypedef) + NameLen + 1 );
td->Name = (char*)(td + 1);
memcpy(td+1, Name, NameLen);
((char*)(td+1))[NameLen] = 0;
td->Base = Type;
td->Next = *pnp;
*pnp = td;
return 0;
}
int mongoproxy_session_select_backend(mongoproxy_session_t * sess, int primary)
{
mongo_replset_t *replset = &(g_server.replset);
if (sess->backend_conn) { //already got a connection
if (sess->backend_conn->backend == replset->primary) {
return 0;
} else { //my conn is not to primary
if (primary) {
mongo_replset_release_conn(sess->backend_conn);
sess->backend_conn = NULL;
} else {
return 0;
}
}
}
DEBUG_S("we will use a new backend_conn, [primary:%d]", primary);
sess->backend_conn = mongo_replset_get_conn(replset, primary);
if (!sess->backend_conn) {
ERROR_S("get no connection");
return -1;
}
return 0;
}
static VALUE RUDL_at_exit(VALUE obj)
{
DEBUG_S("Reached RUDL_at_exit");
#ifdef HAVE_SDL_NET_H
quitNet();
#endif
quitJoystick();
#ifdef HAVE_SDL_MIXER_H
quitAudio();
#endif
quitVideo();
quitTTF();
DEBUG_S("Quitting the rest of it");
SDL_Quit();
return Qnil;
}
mongoproxy_session_t *mongoproxy_session_new()
{
mongoproxy_session_t *sess;
sess = malloc(sizeof(*sess));
if (!sess) {
ERROR("error on malloc");
return NULL;
}
memset(sess, 0, sizeof(*sess));
sess->proxy_state = SESSION_STATE_UNSET;
sess->buf = buffer_new(MONGOPROXY_DEFAULT_BUF_SIZE);
sess->sessionid = random();
sess->sessionid = sess->sessionid<<32 | random();
DEBUG_S("proxy_session new : %p", sess);
return sess;
}
static VALUE rb_pit_cross_lines(VALUE self, VALUE pa, VALUE pb, VALUE pc, VALUE pd)
{
double pax=array_get_x(pa);
double pbx=array_get_x(pb);
double pcx=array_get_x(pc);
double pdx=array_get_x(pd);
double pay=array_get_y(pa);
double pby=array_get_y(pb);
double pcy=array_get_y(pc);
double pdy=array_get_y(pd);
double xk, yk, a, b, c, d;
double tmp;
if(pax!=pbx && pcx!=pdx){ // check eerst even of geen van de lijnen vertikaal is
// De lijnpunten sorteren op x-coordinaat.
if(pax>pbx){
tmp=pax; pax=pbx; pbx=tmp;
tmp=pay; pay=pby; pby=tmp;
}
if(pcx>pdx){
tmp=pcx; pcx=pdx; pdx=tmp;
tmp=pcy; pcy=pdy; pdy=tmp;
}
a=(pby-pay)/(pbx-pax); // de helling van de eerste lijn
b=pay-a*pax; // het snijpunt van de eerste lijn met x=0
c=(pdy-pcy)/(pdx-pcx); // de helling van de tweede lijn
d=pcy-c*pcx; // het snijpunt van de tweede lijn met x=0
if(a==c){ // Are they parallel?
if(b==d){ // Are they the same line?
if(!(pbx<pcx || pax>pdx)){ // Are the sections the same?
// Calculate overlapping line section
double cx1, cy1, cx2, cy2;
DEBUG_S("overlap");
if(pax<pcx){
cx1=pcx;
cy1=pcy;
}else{
cx1=pax;
cy1=pay;
}
if(pbx<pdx){
cx2=pbx;
cy2=pby;
}else{
cx2=pdx;
cy2=pdy;
}
return rb_pit_cross_lines_retval(true, true, cx1, cy1, cx2, cy2);
}else{
return Qfalse;
}
}
}
xk=(d-b)/(a-c); // bereken de x-coordinaat van het snijpunt
yk=a*xk+b; // en de y-coordinaat
// de lijnen snijden als de x-coordinaat van het snijpunt tussen
// de begin- en eind-x-coordinaten van de lijnen ligt.
return rb_pit_cross_lines_retval(xk<=pbx && xk>=pax && xk<=pdx && xk>=pcx, false, xk, yk, 0, 0);
}else{ // wat als een van de lijnen vertikaal is?
// De lijnpunten sorteren op y-coordinaat.
if(pay>pby){
tmp=pax; pax=pbx; pbx=tmp;
tmp=pay; pay=pby; pby=tmp;
}
if(pcy>pdy){
tmp=pcx; pcx=pdx; pdx=tmp;
tmp=pcy; pcy=pdy; pdy=tmp;
}
if(pax==pbx){
if(pcx==pdx){ // Beide lijnen lopen verticaal
return rb_pit_cross_lines_retval((pax==pcx)&&!(pby<pcy || pay>pdy), true, pax, RUDL_MAX(pay, pcy), pax, RUDL_MIN(pby, pdy));
}else{ // alleen de eerste lijn loopt vertikaal
if((pcx<pax && pdx<pax)||(pcx>pax && pdx>pax)){
return rb_pit_cross_lines_retval(false, false, 0,0,0,0);
}
c=(pdy-pcy)/(pdx-pcx); // de helling van de tweede lijn berkenen
d=pcy-c*pcx; // het snijpunt van de tweede lijn met x=0 berekenen
yk=c*pax+d; // de y-coord van het snijpunt is dan
return rb_pit_cross_lines_retval(yk>=pay && yk<=pby, false, pax, yk, 0, 0);
}
}else{ // Alleen de tweede lijn loopt verticaal
if((pax<pcx && pbx<pcx)||(pax>pcx && pbx>pcx)){
return rb_pit_cross_lines_retval(false, false, 0,0,0,0);
}
c=(pby-pay)/(pbx-pax); // de helling van de eerste lijn berkenen
d=pay-c*pax; // het snijpunt van de tweede lijn met x=0 berekenen
yk=c*pcx+d; // de y-coord van het snijpunt is dan
return rb_pit_cross_lines_retval(yk>=pcy && yk<=pdy, false, pcx, yk, 0, 0);
}
}
}
DECKLSPECKL void Init_RUDL()
{
DEBUG_S("Init_RUDL()");
moduleRUDL=rb_define_module("RUDL");
rb_define_singleton_method(moduleRUDL, "at_exit", RUDL_at_exit, 0);
rb_define_singleton_method(moduleRUDL, "init_subsystem", RUDL_init, 1);
rb_define_singleton_method(moduleRUDL, "quit_subsystem", RUDL_quit, 1);
rb_define_singleton_method(moduleRUDL, "is_subsystem_init", RUDL_is_init, 1);
rb_define_singleton_method(moduleRUDL, "versions", RUDL_versions, 0);
/**
@class RUDL::SDLError
SDLError is the class that is thrown when SDL or RUDL find an SDL-specific
problem.
*/
classSDLError=rb_define_class("SDLError", rb_eStandardError);
/**
@class RUDL::Pit
The @Pit is where the things end up that don't fit anywhere else.
The methods are documented where they fit best.
*/
classPit=rb_define_class_under(moduleRUDL, "Pit", rb_cObject);
/**
@class RUDL::Version
@Version is the class used for version comparisons.
It defines four version levels: major, minor, patch and deepest.
*/
/**
@method initialize( major=0, minor=0, patch=0, deepest=0 )
Initializes a new Version object.
*/
/**
@method <( v )
Compares this version number with the one in @v.
Returns <code>true</code> if older.
*/
/**
@method to_s
Returns the version as a string: "major.minor.patch.deepest"
*/
rb_eval_string(
"module RUDL\n"
" class Version\n"
" attr_accessor :major, :minor, :patch, :deepest\n"
" def <(v)\n"
" (@major<v.major) or\n"
" (@major==v.major and @minor<v.minor) or\n"
" (@major==v.major and @minor==v.minor and @patch<v.patch) or\n"
" (@major==v.major and @minor==v.minor and @patch==v.patch and @deepest<v.deepest)\n"
" end\n"
" def initialize(major=0, minor=0, patch=0, deepest=0)\n"
" @major=major\n"
" @minor=minor\n"
" @patch=patch\n"
" @deepest=deepest\n"
" end\n"
" def to_s\n"
" \"#{major}.#{minor}.#{patch}.#{deepest}\"\n"
" end\n"
" end\n"
"end\n"
);
id_begin=rb_intern("begin");
id_end=rb_intern("end");
id_new=rb_intern("new");
id_clone=rb_intern("clone");
/**
@class RUDL::Constants
All for the hacked @init_subsystem and @quit_subsystem,
which should officially never be needed:
<code>INIT_TIMER, INIT_AUDIO, INIT_VIDEO, INIT_CDROM, INIT_JOYSTICK, INIT_NOPARACHUTE, INIT_EVERYTHING</code>
*/
moduleConstant=rb_define_module_under(moduleRUDL, "Constant");
DEC_CONST(INIT_TIMER);
DEC_CONST(INIT_AUDIO);
DEC_CONST(INIT_VIDEO);
DEC_CONST(INIT_CDROM);
DEC_CONST(INIT_JOYSTICK);
DEC_CONST(INIT_NOPARACHUTE);
DEC_CONST(INIT_EVERYTHING);
initAudioClasses();
initCDClasses();
initEventsClasses();
initTrueTypeFontClasses();
initJoystickClasses();
initKeyClasses();
initMouseClasses();
initTimerClasses();
initVideoClasses();
initSFontClasses();
initFLXClasses();
initNetClasses();
initSDL();
