mdtools/generic_stamps/MoleculeStamp.cpp

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>

#include "MoleculeStamp.hpp"

MoleculeStamp::MoleculeStamp(){
  
  n_atoms = 0;
  n_bonds = 0;
  n_bends = 0;
  n_torsions = 0;

  unhandled = NULL;
  atoms = NULL;
  bonds = NULL;
  bends = NULL;
  torsions = NULL;

  have_name = 0;
  have_atoms = 0;
  have_bonds = 0;
  have_bends = 0;
  have_torsions = 0;

}

MoleculeStamp::~MoleculeStamp(){
  int i;
  
  if( unhandled != NULL) delete unhandled;

  if( atoms != NULL ){
    for( i=0; i<n_atoms; i++ ) delete atoms[i];
  }
  
  if( bonds != NULL ){
    for( i=0; i<n_bonds; i++ ) delete bonds[i];
  }
  
  if( bends != NULL ){
    for( i=0; i<n_bends; i++ ) delete bends[i];
  }
  
  if( torsions != NULL ){
    for( i=0; i<n_torsions; i++ ) delete torsions[i];
  }
  
}

char* MoleculeStamp::assignString( char* lhs, char* rhs ){
  
  if( !strcmp( lhs, "name" ) ){
    strcpy( name, rhs );
    have_name = 1;
  }
  else{
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
  return NULL;
}

char* MoleculeStamp::assignDouble( char* lhs, double rhs ){
  int i;

  if( !strcmp( lhs, "nAtoms" ) ){
    n_atoms = (int)rhs;
    
    if( have_atoms ){
      sprintf( errMsg,
               "MoleculeStamp error, n_atoms already declared"
               "for molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_atoms = 1;
    atoms = new AtomStamp*[n_atoms];
    for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nBonds" ) ){
    n_bonds = (int)rhs;

    if( have_bonds ){
      sprintf( errMsg,  
               "MoleculeStamp error, n_bonds already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_bonds = 1;
    bonds = new BondStamp*[n_bonds];
    for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nBends" ) ){
    n_bends = (int)rhs;

    if( have_bends ){
      sprintf( errMsg,
               "MoleculeStamp error, n_bends already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_bends = 1;
    bends = new BendStamp*[n_bends];
    for( i=0; i<n_bends; i++ ) bends[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nTorsions" ) ){
    n_torsions = (int)rhs;

    if( have_torsions ){
      sprintf( errMsg,
               "MoleculeStamp error, n_torsions already declared for"
               " molecule: %s\n",
               name );
      return strdup( errMsg );
    }
    have_torsions = 1;
    torsions = new TorsionStamp*[n_torsions];
    for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
  }
  else{
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
  return NULL;
}

char*  MoleculeStamp::assignInt( char* lhs, int rhs ){
  int i;
  
  if( !strcmp( lhs, "nAtoms" ) ){
    n_atoms = rhs;
    
    if( have_atoms ){
      sprintf( errMsg,
               "MoleculeStamp error, n_atoms already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_atoms = 1;
    atoms = new AtomStamp*[n_atoms];
    for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nBonds" ) ){
    n_bonds = rhs;

    if( have_bonds ){
      sprintf( errMsg,
               "MoleculeStamp error, n_bonds already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_bonds = 1;
    bonds = new BondStamp*[n_bonds];
    for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nBends" ) ){
    n_bends = rhs;

    if( have_bends ){
      sprintf( errMsg,
               "MoleculeStamp error, n_bends already declared for"
               " molecule: %s\n",
               name );
      return strdup( errMsg );
    }
    have_bends = 1;
    bends = new BendStamp*[n_bends];
    for( i=0; i<n_bends; i++ ) bends[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nTorsions" ) ){
    n_torsions = rhs;

    if( have_torsions ){
      sprintf( errMsg,
               "MoleculeStamp error, n_torsions already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_torsions = 1;
    torsions = new TorsionStamp*[n_torsions];
    for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
  }
  else{
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
  return NULL;
}

char* MoleculeStamp::addAtom( AtomStamp* the_atom, int atomIndex ){
  
  if( have_atoms && atomIndex < n_atoms ) atoms[atomIndex] = the_atom;
  else{
    if( have_atoms ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nAtoms range", 
               atomIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nAtoms not given before"
                       "first atom declaration." );
  }

  return NULL;
}

char* MoleculeStamp::addBond( BondStamp* the_bond, int bondIndex ){
  
  
  if( have_bonds && bondIndex < n_bonds ) bonds[bondIndex] = the_bond;
  else{
    if( have_bonds ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nBonds range", 
               bondIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nBonds not given before"
                       "first bond declaration." );
  }

  return NULL;
}

char* MoleculeStamp::addBend( BendStamp* the_bend, int bendIndex ){
  
  
  if( have_bends && bendIndex < n_bends ) bends[bendIndex] = the_bend;
  else{
    if( have_bends ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nBends range", 
               bendIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nBends not given before"
                       "first bend declaration." );
  }

  return NULL;
}

char* MoleculeStamp::addTorsion( TorsionStamp* the_torsion, int torsionIndex ){
  
  
  if( have_torsions && torsionIndex < n_torsions ) 
    torsions[torsionIndex] = the_torsion;
  else{
    if( have_torsions ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nTorsions range", 
               torsionIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nTorsions not given before"
                       "first torsion declaration." );
  }

  return NULL;
}

char* MoleculeStamp::checkMe( void ){
  
  int i;
  short int no_atom;
  
  if( !have_name || !have_atoms ){
    if( !have_name ) return strdup( "MoleculeStamp error. Molecule's name"
                                    " was not given.\n" );
    else return strdup( "MoleculeStamp error. Molecule contains no atoms." );
  }
  
  no_atom = 0;
  for( i=0; i<n_atoms; i++ ){
    if( atoms[i] == NULL ) no_atom = 1;
  }

  if( no_atom ){
    sprintf( errMsg, 
             "MoleculeStamp error. Not all of the atoms were"
             " declared in molecule \"%s\".\n", name );
    return strdup( errMsg );
  }

  return NULL;
}
Revision:	173
Committed:	Mon Nov 11 17:25:15 2002 UTC (21 years, 10 months ago) by mmeineke
File size:	6842 byte(s)
Log Message:	* empty log message *
#	User	Rev	Content
1	mmeineke	10	#include <cstdlib>
2			#include <cstdio>
3			#include <cstring>
4			#include <iostream>
5
6			#include "MoleculeStamp.hpp"
7
8			MoleculeStamp::MoleculeStamp(){
9
10			n_atoms = 0;
11			n_bonds = 0;
12			n_bends = 0;
13			n_torsions = 0;
14
15			unhandled = NULL;
16			atoms = NULL;
17			bonds = NULL;
18			bends = NULL;
19			torsions = NULL;
20
21			have_name = 0;
22			have_atoms = 0;
23			have_bonds = 0;
24			have_bends = 0;
25			have_torsions = 0;
26
27			}
28
29			MoleculeStamp::~MoleculeStamp(){
30			int i;
31
32			if( unhandled != NULL) delete unhandled;
33
34			if( atoms != NULL ){
35			for( i=0; i<n_atoms; i++ ) delete atoms[i];
36			}
37
38			if( bonds != NULL ){
39			for( i=0; i<n_bonds; i++ ) delete bonds[i];
40			}
41
42			if( bends != NULL ){
43			for( i=0; i<n_bends; i++ ) delete bends[i];
44			}
45
46			if( torsions != NULL ){
47			for( i=0; i<n_torsions; i++ ) delete torsions[i];
48			}
49
50			}
51
52	mmeineke	165	char* MoleculeStamp::assignString( char* lhs, char* rhs ){
53	mmeineke	10
54			if( !strcmp( lhs, "name" ) ){
55			strcpy( name, rhs );
56			have_name = 1;
57			}
58			else{
59			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
60			else unhandled->add( lhs, rhs );
61			have_extras = 1;
62			}
63	mmeineke	165	return NULL;
64	mmeineke	10	}
65
66	mmeineke	165	char* MoleculeStamp::assignDouble( char* lhs, double rhs ){
67	mmeineke	10	int i;
68
69			if( !strcmp( lhs, "nAtoms" ) ){
70			n_atoms = (int)rhs;
71
72			if( have_atoms ){
73	mmeineke	165	sprintf( errMsg,
74	mmeineke	160	"MoleculeStamp error, n_atoms already declared"
75			"for molecule: %s\n",
76			name);
77	mmeineke	165	return strdup( errMsg );
78	mmeineke	10	}
79			have_atoms = 1;
80			atoms = new AtomStamp*[n_atoms];
81			for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
82			}
83
84			else if( !strcmp( lhs, "nBonds" ) ){
85			n_bonds = (int)rhs;
86
87			if( have_bonds ){
88	mmeineke	165	sprintf( errMsg,
89	mmeineke	160	"MoleculeStamp error, n_bonds already declared for"
90			" molecule: %s\n",
91			name);
92	mmeineke	165	return strdup( errMsg );
93	mmeineke	10	}
94			have_bonds = 1;
95			bonds = new BondStamp*[n_bonds];
96			for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
97			}
98
99			else if( !strcmp( lhs, "nBends" ) ){
100			n_bends = (int)rhs;
101
102			if( have_bends ){
103	mmeineke	165	sprintf( errMsg,
104	mmeineke	160	"MoleculeStamp error, n_bends already declared for"
105			" molecule: %s\n",
106			name);
107	mmeineke	165	return strdup( errMsg );
108	mmeineke	10	}
109			have_bends = 1;
110			bends = new BendStamp*[n_bends];
111			for( i=0; i<n_bends; i++ ) bends[i] = NULL;
112			}
113
114			else if( !strcmp( lhs, "nTorsions" ) ){
115			n_torsions = (int)rhs;
116
117			if( have_torsions ){
118	mmeineke	165	sprintf( errMsg,
119	mmeineke	160	"MoleculeStamp error, n_torsions already declared for"
120			" molecule: %s\n",
121			name );
122	mmeineke	165	return strdup( errMsg );
123	mmeineke	10	}
124			have_torsions = 1;
125			torsions = new TorsionStamp*[n_torsions];
126			for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
127			}
128			else{
129			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
130			else unhandled->add( lhs, rhs );
131			have_extras = 1;
132			}
133	mmeineke	165	return NULL;
134	mmeineke	10	}
135
136	mmeineke	165	char* MoleculeStamp::assignInt( char* lhs, int rhs ){
137	mmeineke	10	int i;
138
139			if( !strcmp( lhs, "nAtoms" ) ){
140			n_atoms = rhs;
141
142			if( have_atoms ){
143	mmeineke	165	sprintf( errMsg,
144	mmeineke	160	"MoleculeStamp error, n_atoms already declared for"
145			" molecule: %s\n",
146			name);
147	mmeineke	165	return strdup( errMsg );
148	mmeineke	10	}
149			have_atoms = 1;
150			atoms = new AtomStamp*[n_atoms];
151			for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
152			}
153
154			else if( !strcmp( lhs, "nBonds" ) ){
155			n_bonds = rhs;
156
157			if( have_bonds ){
158	mmeineke	165	sprintf( errMsg,
159	mmeineke	160	"MoleculeStamp error, n_bonds already declared for"
160			" molecule: %s\n",
161			name);
162	mmeineke	165	return strdup( errMsg );
163	mmeineke	10	}
164			have_bonds = 1;
165			bonds = new BondStamp*[n_bonds];
166			for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
167			}
168
169			else if( !strcmp( lhs, "nBends" ) ){
170			n_bends = rhs;
171
172			if( have_bends ){
173	mmeineke	165	sprintf( errMsg,
174	mmeineke	160	"MoleculeStamp error, n_bends already declared for"
175			" molecule: %s\n",
176			name );
177	mmeineke	165	return strdup( errMsg );
178	mmeineke	10	}
179			have_bends = 1;
180			bends = new BendStamp*[n_bends];
181			for( i=0; i<n_bends; i++ ) bends[i] = NULL;
182			}
183
184			else if( !strcmp( lhs, "nTorsions" ) ){
185			n_torsions = rhs;
186
187			if( have_torsions ){
188	mmeineke	165	sprintf( errMsg,
189	mmeineke	160	"MoleculeStamp error, n_torsions already declared for"
190			" molecule: %s\n",
191			name);
192	mmeineke	165	return strdup( errMsg );
193	mmeineke	10	}
194			have_torsions = 1;
195			torsions = new TorsionStamp*[n_torsions];
196			for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
197			}
198			else{
199			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
200			else unhandled->add( lhs, rhs );
201			have_extras = 1;
202			}
203	mmeineke	165	return NULL;
204	mmeineke	10	}
205
206			char* MoleculeStamp::addAtom( AtomStamp* the_atom, int atomIndex ){
207
208			if( have_atoms && atomIndex < n_atoms ) atoms[atomIndex] = the_atom;
209			else{
210			if( have_atoms ){
211	mmeineke	173	sprintf( errMsg, "MoleculeStamp error, %d out of nAtoms range",
212	mmeineke	10	atomIndex );
213	mmeineke	173	return strdup( errMsg );
214	mmeineke	10	}
215			else return strdup("MoleculeStamp error, nAtoms not given before"
216			"first atom declaration." );
217			}
218
219			return NULL;
220			}
221
222			char* MoleculeStamp::addBond( BondStamp* the_bond, int bondIndex ){
223
224
225			if( have_bonds && bondIndex < n_bonds ) bonds[bondIndex] = the_bond;
226			else{
227			if( have_bonds ){
228	mmeineke	173	sprintf( errMsg, "MoleculeStamp error, %d out of nBonds range",
229	mmeineke	10	bondIndex );
230	mmeineke	173	return strdup( errMsg );
231	mmeineke	10	}
232			else return strdup("MoleculeStamp error, nBonds not given before"
233			"first bond declaration." );
234			}
235
236			return NULL;
237			}
238
239			char* MoleculeStamp::addBend( BendStamp* the_bend, int bendIndex ){
240
241
242			if( have_bends && bendIndex < n_bends ) bends[bendIndex] = the_bend;
243			else{
244			if( have_bends ){
245	mmeineke	173	sprintf( errMsg, "MoleculeStamp error, %d out of nBends range",
246	mmeineke	10	bendIndex );
247	mmeineke	173	return strdup( errMsg );
248	mmeineke	10	}
249			else return strdup("MoleculeStamp error, nBends not given before"
250			"first bend declaration." );
251			}
252
253			return NULL;
254			}
255
256			char* MoleculeStamp::addTorsion( TorsionStamp* the_torsion, int torsionIndex ){
257
258
259			if( have_torsions && torsionIndex < n_torsions )
260			torsions[torsionIndex] = the_torsion;
261			else{
262			if( have_torsions ){
263	mmeineke	173	sprintf( errMsg, "MoleculeStamp error, %d out of nTorsions range",
264	mmeineke	10	torsionIndex );
265	mmeineke	173	return strdup( errMsg );
266	mmeineke	10	}
267			else return strdup("MoleculeStamp error, nTorsions not given before"
268			"first torsion declaration." );
269			}
270
271			return NULL;
272			}
273
274			char* MoleculeStamp::checkMe( void ){
275
276			int i;
277			short int no_atom;
278
279			if( !have_name \|\| !have_atoms ){
280			if( !have_name ) return strdup( "MoleculeStamp error. Molecule's name"
281			" was not given.\n" );
282			else return strdup( "MoleculeStamp error. Molecule contains no atoms." );
283			}
284
285			no_atom = 0;
286			for( i=0; i<n_atoms; i++ ){
287			if( atoms[i] == NULL ) no_atom = 1;
288			}
289
290			if( no_atom ){
291	mmeineke	173	sprintf( errMsg,
292	mmeineke	10	"MoleculeStamp error. Not all of the atoms were"
293			" declared in molecule \"%s\".\n", name );
294	mmeineke	173	return strdup( errMsg );
295	mmeineke	10	}
296
297			return NULL;
298			}