mdtools/interface_implementation/MakeStamps.cpp

#include <cstdlib>
#include <cstdio>

#include "MakeStamps.hpp"
#include "MoleculeStamp.hpp"

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

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

  if( mol_stamp != NULL ){
    
    if(!strcmp( mol_stamp->getID(), id )) return mol_stamp;
    
    if( next != NULL ) return next->match( id );
  }
  
  return NULL;
}

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

}

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

    fprintf( stderr,
             "There has been an overflow error in the hash key.");
    exit(0);
  }
  
  return key;
}

MoleculeStamp* MakeStamps::getMolecule( char* the_id ){
  int key;
  
  key = hash( the_id );
  if( my_mols[key] != NULL ){
    return my_mols[key]->match( 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 );
  linked_mol->setNext( my_mols[key] );

  my_mols[key] = 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:
    current_mol->assignString( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.sval );
    return 1;
    break;

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

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

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

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:
    current_atom->assignString( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.sval );
    return 1;
    break;

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

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