OOPSE/libBASS/MakeStamps.cpp

#include <cstdlib>
#include <cstdio>

#include "MakeStamps.hpp"
#include "MoleculeStamp.hpp"
#include "simError.h"
#ifdef IS_MPI
#include "mpiBASS.h"
#endif // is_mpi

LinkedMolStamp::~LinkedMolStamp(){ 
  if( mol_stamp != NULL ) delete mol_stamp;
  if( next != NULL ) delete next; 
}

void LinkedMolStamp::add( LinkedMolStamp* newbie ){
  
  if( next != NULL ) next->add( newbie );
  else{
    next = newbie;
    next->setPrev( this );
  }
}

MoleculeStamp* LinkedMolStamp::match( char* id ){

  if( mol_stamp != NULL ){
    if(!strcmp( mol_stamp->getID(), id )){
      
      // make sure we aren't hiding somebody else with the same name
      if(next != NULL ){
        if( next->match( id ) != NULL){
          sprintf( painCave.errMsg,
                   "Molecule Stamp Error. Two separate of declarations of "
                   "%s present.\n",
                   id );
          painCave.isFatal = 1;
          simError();
#ifdef IS_MPI
          if( painCave.isEventLoop ){
            if( worldRank == 0 ) mpiInterfaceExit();
          }
#endif //is_mpi
        }
        else return mol_stamp;
      }
      else  return mol_stamp;
    }
  }
  
  if( next != NULL ) return next->match( id );
  
  return NULL;
}

LinkedMolStamp* LinkedMolStamp::extract( char* id ){

  if( mol_stamp != NULL ){
    if(!strcmp( mol_stamp->getID(), id )){
      
      // make sure we aren't hiding somebody else with the same name
      if(next != NULL ){
        if( next->match( id ) != NULL){
          sprintf( painCave.errMsg,
                   "Molecule Stamp Error. Two separate of declarations of "
                   "%s present.\n",
                   id );
          painCave.isFatal = 1;
          simError();
#ifdef IS_MPI
          if( painCave.isEventLoop ){
            if( worldRank == 0 ) mpiInterfaceExit();
          }
#endif //is_mpi
        }
      }
          
      prev->setNext( next );
      if( next != NULL ) next->setPrev( prev );
      return this;
    }
  }
  
  if( next != NULL ) return next->extract( id );
  
  return NULL;
}

MakeStamps::MakeStamps(){
  
  int i;
  
  my_mols = new LinkedMolStamp*[hash_size];
  for( i=0; i<hash_size; i++ ){
    my_mols[i] = new LinkedMolStamp();
  }

}

MakeStamps::~MakeStamps(){
  
  int i;

  for( i=0; i<hash_size; i++ ){
    if( my_mols[i] != NULL ) delete my_mols[i];
  }
  delete[] my_mols;
}

int MakeStamps::hash( char* text ){

  register unsigned short int i = 0; // loop counter
  int key = 0; // the hash key

  while( text[i] != '\0' ){

    key = ( ( key << hash_shift ) + text[i] ) % hash_size;
    
    i++;
  }
  
  if( key < 0 ){

    // if the key is less than zero, we've had an overflow error

    sprintf( painCave.errMsg,
             "There has been an overflow error in the MakeStamps hash key.");
    painCave.isFatal = 1;
    simError();
#ifdef IS_MPI
    if( painCave.isEventLoop ){
      if( worldRank == 0 ) mpiInterfaceExit();
    }
#endif //is_mpi
  }
  
  return key;
}

LinkedMolStamp* MakeStamps::extractMolStamp( char* the_id ){
  int key;
  
  key = hash( the_id );
  if( my_mols[key] != NULL ){
    return my_mols[key]->extract( the_id );
  }
  
  return NULL;
}

void MakeStamps::addMolStamp( MoleculeStamp* the_stamp ){

  int key;
  LinkedMolStamp* linked_mol;
  
  key = hash( the_stamp->getID() );

  linked_mol = new LinkedMolStamp;
  linked_mol->setStamp( the_stamp );

  my_mols[key]->add( linked_mol );

}


int MakeStamps::newMolecule( event* the_event ){
  
  current_mol = new MoleculeStamp;
  return 1;
}

int MakeStamps::moleculeAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    the_event->err_msg = current_mol->assignString( the_event->evt.asmt.lhs,
                                      the_event->evt.asmt.rhs.sval );
    break;

  case DOUBLE:
    the_event->err_msg = current_mol->assignDouble( the_event->evt.asmt.lhs,
                                      the_event->evt.asmt.rhs.dval );
    break;
    
  case INT:
    the_event->err_msg = current_mol->assignInt( the_event->evt.asmt.lhs,
                                   the_event->evt.asmt.rhs.ival );
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid molecule"
                                 " assignment type" );
    return 0;
    break;
  }
  if( the_event->err_msg != NULL ) return 0;
  return 1;
}

int MakeStamps::moleculeEnd( event* the_event ){

  the_event->err_msg = current_mol->checkMe();
  // if err_msg is set, then something is wrong
  if( the_event->err_msg != NULL ) return 0; 

  addMolStamp( current_mol );
  return 1;
}

int MakeStamps::newAtom( event* the_event ){
  
  current_atom = new AtomStamp;
  
  the_event->err_msg = current_mol->addAtom( current_atom,
                                             the_event->evt.blk_index );
  if( the_event->err_msg != NULL ) return 0;
  return 1;
}

int MakeStamps::atomPosition( event* the_event ){
  
  current_atom->setPosition( the_event->evt.pos.x,
                             the_event->evt.pos.y,
                             the_event->evt.pos.z );
  return 1;
}


int MakeStamps::atomOrientation( event* the_event ){
  
  current_atom->setOrientation( the_event->evt.ornt.x,
                                the_event->evt.ornt.y,
                                the_event->evt.ornt.z );
  return 1;
}

int MakeStamps::atomAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    the_event->err_msg = 
      current_atom->assignString( the_event->evt.asmt.lhs,
                                  the_event->evt.asmt.rhs.sval );
    if( the_event->err_msg != NULL ) return 0;
    return 1;
    break;

  case DOUBLE:
    the_event->err_msg = 
      current_atom->assignDouble( the_event->evt.asmt.lhs,
                                  the_event->evt.asmt.rhs.dval );
    if( the_event->err_msg != NULL ) return 0;
    return 1;    
    break;

  case INT:
    the_event->err_msg = 
      current_atom->assignInt( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.ival );
    if( the_event->err_msg != NULL ) return 0;
    return 1;
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid atom"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int MakeStamps::atomEnd( event* the_event ){

  the_event->err_msg = current_atom->checkMe();
  if( the_event->err_msg != NULL ) return 0;
  
  return 1;
}

int MakeStamps::newBond( event* the_event ){
  
  current_bond = new BondStamp;
  
  the_event->err_msg = current_mol->addBond( current_bond,
                                             the_event->evt.blk_index );
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int MakeStamps::bondAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    current_bond->assignString( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.sval );
    return 1;
    break;

  case DOUBLE:
    current_bond->assignDouble( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.dval );
    return 1;
    break;

  case INT:
    current_bond->assignInt( the_event->evt.asmt.lhs,
                            the_event->evt.asmt.rhs.ival );
    return 1;
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid bond"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int MakeStamps::bondMember( event* the_event ){

  current_bond->members( the_event->evt.mbr.a,
                         the_event->evt.mbr.b );
  return 1;
}

int MakeStamps::bondConstraint( event* the_event ){

  current_bond->constrain( the_event->evt.cnstr );
  return 1;
}

int MakeStamps::bondEnd( event* the_event ){

  the_event->err_msg = current_bond->checkMe();
  if( the_event->err_msg != NULL ) return 0;
  
  return 1;
}

int MakeStamps::newBend( event* the_event ){
  
  current_bend = new BendStamp;
  
  the_event->err_msg = current_mol->addBend( current_bend,
                                             the_event->evt.blk_index );
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int MakeStamps::bendAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    current_bend->assignString( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.sval );
    return 1;
    break;

  case DOUBLE:
    current_bend->assignDouble( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.dval );
    return 1;
    break;

  case INT:
    current_bend->assignInt( the_event->evt.asmt.lhs,
                            the_event->evt.asmt.rhs.ival );
    return 1;
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid bend"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int MakeStamps::bendMember( event* the_event ){

  current_bend->members( the_event->evt.mbr.a,
                         the_event->evt.mbr.b,
                         the_event->evt.mbr.c );
  return 1;
}

int MakeStamps::bendConstraint( event* the_event ){

  current_bend->constrain( the_event->evt.cnstr );
  return 1;
}

int MakeStamps::bendEnd( event* the_event ){

  the_event->err_msg = current_bend->checkMe();
  if( the_event->err_msg != NULL ) return 0;
  
  return 1;
}

int MakeStamps::newTorsion( event* the_event ){
  
  current_torsion = new TorsionStamp;
  
  the_event->err_msg = current_mol->addTorsion( current_torsion,
                                                the_event->evt.blk_index );
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int MakeStamps::torsionAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    current_torsion->assignString( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.sval );
    return 1;
    break;

  case DOUBLE:
    current_torsion->assignDouble( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.dval );
    return 1;
    break;

  case INT:
    current_torsion->assignInt( the_event->evt.asmt.lhs,
                            the_event->evt.asmt.rhs.ival );
    return 1;
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid torsion"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int MakeStamps::torsionMember( event* the_event ){

  current_torsion->members( the_event->evt.mbr.a,
                            the_event->evt.mbr.b,
                            the_event->evt.mbr.c,
                            the_event->evt.mbr.d );
  return 1;
}

int MakeStamps::torsionConstraint( event* the_event ){

  current_torsion->constrain( the_event->evt.cnstr );
  return 1;
}

int MakeStamps::torsionEnd( event* the_event ){

  the_event->err_msg = current_torsion->checkMe();
  if( the_event->err_msg != NULL ) return 0;
  
  return 1;
}
Revision:	378
Committed:	Fri Mar 21 17:42:12 2003 UTC (21 years, 3 months ago) by mmeineke
File size:	9980 byte(s)
Log Message:	This commit was generated by cvs2svn to compensate for changes in r377, which included commits to RCS files with non-trunk default branches.
#	User	Rev	Content
1	mmeineke	377	#include <cstdlib>
2			#include <cstdio>
3
4			#include "MakeStamps.hpp"
5			#include "MoleculeStamp.hpp"
6			#include "simError.h"
7			#ifdef IS_MPI
8			#include "mpiBASS.h"
9			#endif // is_mpi
10
11			LinkedMolStamp::~LinkedMolStamp(){
12			if( mol_stamp != NULL ) delete mol_stamp;
13			if( next != NULL ) delete next;
14			}
15
16			void LinkedMolStamp::add( LinkedMolStamp* newbie ){
17
18			if( next != NULL ) next->add( newbie );
19			else{
20			next = newbie;
21			next->setPrev( this );
22			}
23			}
24
25			MoleculeStamp* LinkedMolStamp::match( char* id ){
26
27			if( mol_stamp != NULL ){
28			if(!strcmp( mol_stamp->getID(), id )){
29
30			// make sure we aren't hiding somebody else with the same name
31			if(next != NULL ){
32			if( next->match( id ) != NULL){
33			sprintf( painCave.errMsg,
34			"Molecule Stamp Error. Two separate of declarations of "
35			"%s present.\n",
36			id );
37			painCave.isFatal = 1;
38			simError();
39			#ifdef IS_MPI
40			if( painCave.isEventLoop ){
41			if( worldRank == 0 ) mpiInterfaceExit();
42			}
43			#endif //is_mpi
44			}
45			else return mol_stamp;
46			}
47			else return mol_stamp;
48			}
49			}
50
51			if( next != NULL ) return next->match( id );
52
53			return NULL;
54			}
55
56			LinkedMolStamp* LinkedMolStamp::extract( char* id ){
57
58			if( mol_stamp != NULL ){
59			if(!strcmp( mol_stamp->getID(), id )){
60
61			// make sure we aren't hiding somebody else with the same name
62			if(next != NULL ){
63			if( next->match( id ) != NULL){
64			sprintf( painCave.errMsg,
65			"Molecule Stamp Error. Two separate of declarations of "
66			"%s present.\n",
67			id );
68			painCave.isFatal = 1;
69			simError();
70			#ifdef IS_MPI
71			if( painCave.isEventLoop ){
72			if( worldRank == 0 ) mpiInterfaceExit();
73			}
74			#endif //is_mpi
75			}
76			}
77
78			prev->setNext( next );
79			if( next != NULL ) next->setPrev( prev );
80			return this;
81			}
82			}
83
84			if( next != NULL ) return next->extract( id );
85
86			return NULL;
87			}
88
89			MakeStamps::MakeStamps(){
90
91			int i;
92
93			my_mols = new LinkedMolStamp*[hash_size];
94			for( i=0; i<hash_size; i++ ){
95			my_mols[i] = new LinkedMolStamp();
96			}
97
98			}
99
100			MakeStamps::~MakeStamps(){
101
102			int i;
103
104			for( i=0; i<hash_size; i++ ){
105			if( my_mols[i] != NULL ) delete my_mols[i];
106			}
107			delete[] my_mols;
108			}
109
110			int MakeStamps::hash( char* text ){
111
112			register unsigned short int i = 0; // loop counter
113			int key = 0; // the hash key
114
115			while( text[i] != '\0' ){
116
117			key = ( ( key << hash_shift ) + text[i] ) % hash_size;
118
119			i++;
120			}
121
122			if( key < 0 ){
123
124			// if the key is less than zero, we've had an overflow error
125
126			sprintf( painCave.errMsg,
127			"There has been an overflow error in the MakeStamps hash key.");
128			painCave.isFatal = 1;
129			simError();
130			#ifdef IS_MPI
131			if( painCave.isEventLoop ){
132			if( worldRank == 0 ) mpiInterfaceExit();
133			}
134			#endif //is_mpi
135			}
136
137			return key;
138			}
139
140			LinkedMolStamp* MakeStamps::extractMolStamp( char* the_id ){
141			int key;
142
143			key = hash( the_id );
144			if( my_mols[key] != NULL ){
145			return my_mols[key]->extract( the_id );
146			}
147
148			return NULL;
149			}
150
151			void MakeStamps::addMolStamp( MoleculeStamp* the_stamp ){
152
153			int key;
154			LinkedMolStamp* linked_mol;
155
156			key = hash( the_stamp->getID() );
157
158			linked_mol = new LinkedMolStamp;
159			linked_mol->setStamp( the_stamp );
160
161			my_mols[key]->add( linked_mol );
162
163			}
164
165
166			int MakeStamps::newMolecule( event* the_event ){
167
168			current_mol = new MoleculeStamp;
169			return 1;
170			}
171
172			int MakeStamps::moleculeAssign( event* the_event ){
173
174			switch( the_event->evt.asmt.asmt_type ){
175
176			case STRING:
177			the_event->err_msg = current_mol->assignString( the_event->evt.asmt.lhs,
178			the_event->evt.asmt.rhs.sval );
179			break;
180
181			case DOUBLE:
182			the_event->err_msg = current_mol->assignDouble( the_event->evt.asmt.lhs,
183			the_event->evt.asmt.rhs.dval );
184			break;
185
186			case INT:
187			the_event->err_msg = current_mol->assignInt( the_event->evt.asmt.lhs,
188			the_event->evt.asmt.rhs.ival );
189			break;
190
191			default:
192			the_event->err_msg = strdup( "MakeStamp error. Invalid molecule"
193			" assignment type" );
194			return 0;
195			break;
196			}
197			if( the_event->err_msg != NULL ) return 0;
198			return 1;
199			}
200
201			int MakeStamps::moleculeEnd( event* the_event ){
202
203			the_event->err_msg = current_mol->checkMe();
204			// if err_msg is set, then something is wrong
205			if( the_event->err_msg != NULL ) return 0;
206
207			addMolStamp( current_mol );
208			return 1;
209			}
210
211			int MakeStamps::newAtom( event* the_event ){
212
213			current_atom = new AtomStamp;
214
215			the_event->err_msg = current_mol->addAtom( current_atom,
216			the_event->evt.blk_index );
217			if( the_event->err_msg != NULL ) return 0;
218			return 1;
219			}
220
221			int MakeStamps::atomPosition( event* the_event ){
222
223			current_atom->setPosition( the_event->evt.pos.x,
224			the_event->evt.pos.y,
225			the_event->evt.pos.z );
226			return 1;
227			}
228
229
230			int MakeStamps::atomOrientation( event* the_event ){
231
232			current_atom->setOrientation( the_event->evt.ornt.x,
233			the_event->evt.ornt.y,
234			the_event->evt.ornt.z );
235			return 1;
236			}
237
238			int MakeStamps::atomAssign( event* the_event ){
239
240			switch( the_event->evt.asmt.asmt_type ){
241
242			case STRING:
243			the_event->err_msg =
244			current_atom->assignString( the_event->evt.asmt.lhs,
245			the_event->evt.asmt.rhs.sval );
246			if( the_event->err_msg != NULL ) return 0;
247			return 1;
248			break;
249
250			case DOUBLE:
251			the_event->err_msg =
252			current_atom->assignDouble( the_event->evt.asmt.lhs,
253			the_event->evt.asmt.rhs.dval );
254			if( the_event->err_msg != NULL ) return 0;
255			return 1;
256			break;
257
258			case INT:
259			the_event->err_msg =
260			current_atom->assignInt( the_event->evt.asmt.lhs,
261			the_event->evt.asmt.rhs.ival );
262			if( the_event->err_msg != NULL ) return 0;
263			return 1;
264			break;
265
266			default:
267			the_event->err_msg = strdup( "MakeStamp error. Invalid atom"
268			" assignment type" );
269			return 0;
270			break;
271			}
272			return 0;
273			}
274
275			int MakeStamps::atomEnd( event* the_event ){
276
277			the_event->err_msg = current_atom->checkMe();
278			if( the_event->err_msg != NULL ) return 0;
279
280			return 1;
281			}
282
283			int MakeStamps::newBond( event* the_event ){
284
285			current_bond = new BondStamp;
286
287			the_event->err_msg = current_mol->addBond( current_bond,
288			the_event->evt.blk_index );
289			if( the_event->err_msg != NULL ) return 0;
290
291			return 1;
292			}
293
294			int MakeStamps::bondAssign( event* the_event ){
295
296			switch( the_event->evt.asmt.asmt_type ){
297
298			case STRING:
299			current_bond->assignString( the_event->evt.asmt.lhs,
300			the_event->evt.asmt.rhs.sval );
301			return 1;
302			break;
303
304			case DOUBLE:
305			current_bond->assignDouble( the_event->evt.asmt.lhs,
306			the_event->evt.asmt.rhs.dval );
307			return 1;
308			break;
309
310			case INT:
311			current_bond->assignInt( the_event->evt.asmt.lhs,
312			the_event->evt.asmt.rhs.ival );
313			return 1;
314			break;
315
316			default:
317			the_event->err_msg = strdup( "MakeStamp error. Invalid bond"
318			" assignment type" );
319			return 0;
320			break;
321			}
322			return 0;
323			}
324
325			int MakeStamps::bondMember( event* the_event ){
326
327			current_bond->members( the_event->evt.mbr.a,
328			the_event->evt.mbr.b );
329			return 1;
330			}
331
332			int MakeStamps::bondConstraint( event* the_event ){
333
334			current_bond->constrain( the_event->evt.cnstr );
335			return 1;
336			}
337
338			int MakeStamps::bondEnd( event* the_event ){
339
340			the_event->err_msg = current_bond->checkMe();
341			if( the_event->err_msg != NULL ) return 0;
342
343			return 1;
344			}
345
346			int MakeStamps::newBend( event* the_event ){
347
348			current_bend = new BendStamp;
349
350			the_event->err_msg = current_mol->addBend( current_bend,
351			the_event->evt.blk_index );
352			if( the_event->err_msg != NULL ) return 0;
353
354			return 1;
355			}
356
357			int MakeStamps::bendAssign( event* the_event ){
358
359			switch( the_event->evt.asmt.asmt_type ){
360
361			case STRING:
362			current_bend->assignString( the_event->evt.asmt.lhs,
363			the_event->evt.asmt.rhs.sval );
364			return 1;
365			break;
366
367			case DOUBLE:
368			current_bend->assignDouble( the_event->evt.asmt.lhs,
369			the_event->evt.asmt.rhs.dval );
370			return 1;
371			break;
372
373			case INT:
374			current_bend->assignInt( the_event->evt.asmt.lhs,
375			the_event->evt.asmt.rhs.ival );
376			return 1;
377			break;
378
379			default:
380			the_event->err_msg = strdup( "MakeStamp error. Invalid bend"
381			" assignment type" );
382			return 0;
383			break;
384			}
385			return 0;
386			}
387
388			int MakeStamps::bendMember( event* the_event ){
389
390			current_bend->members( the_event->evt.mbr.a,
391			the_event->evt.mbr.b,
392			the_event->evt.mbr.c );
393			return 1;
394			}
395
396			int MakeStamps::bendConstraint( event* the_event ){
397
398			current_bend->constrain( the_event->evt.cnstr );
399			return 1;
400			}
401
402			int MakeStamps::bendEnd( event* the_event ){
403
404			the_event->err_msg = current_bend->checkMe();
405			if( the_event->err_msg != NULL ) return 0;
406
407			return 1;
408			}
409
410			int MakeStamps::newTorsion( event* the_event ){
411
412			current_torsion = new TorsionStamp;
413
414			the_event->err_msg = current_mol->addTorsion( current_torsion,
415			the_event->evt.blk_index );
416			if( the_event->err_msg != NULL ) return 0;
417
418			return 1;
419			}
420
421			int MakeStamps::torsionAssign( event* the_event ){
422
423			switch( the_event->evt.asmt.asmt_type ){
424
425			case STRING:
426			current_torsion->assignString( the_event->evt.asmt.lhs,
427			the_event->evt.asmt.rhs.sval );
428			return 1;
429			break;
430
431			case DOUBLE:
432			current_torsion->assignDouble( the_event->evt.asmt.lhs,
433			the_event->evt.asmt.rhs.dval );
434			return 1;
435			break;
436
437			case INT:
438			current_torsion->assignInt( the_event->evt.asmt.lhs,
439			the_event->evt.asmt.rhs.ival );
440			return 1;
441			break;
442
443			default:
444			the_event->err_msg = strdup( "MakeStamp error. Invalid torsion"
445			" assignment type" );
446			return 0;
447			break;
448			}
449			return 0;
450			}
451
452			int MakeStamps::torsionMember( event* the_event ){
453
454			current_torsion->members( the_event->evt.mbr.a,
455			the_event->evt.mbr.b,
456			the_event->evt.mbr.c,
457			the_event->evt.mbr.d );
458			return 1;
459			}
460
461			int MakeStamps::torsionConstraint( event* the_event ){
462
463			current_torsion->constrain( the_event->evt.cnstr );
464			return 1;
465			}
466
467			int MakeStamps::torsionEnd( event* the_event ){
468
469			the_event->err_msg = current_torsion->checkMe();
470			if( the_event->err_msg != NULL ) return 0;
471
472			return 1;
473			}