src/visitors/OtherVisitor.hpp

#ifndef _OTHERVISITOR_H_
#define _OTHERVISITOR_H_
#include <set>
#include <string>
#include <vector>

#include "visitors/BaseVisitor.hpp"
#include "primitives/StuntDouble.hpp"
#include "visitors/AtomData.hpp"

using namespace std;

namespace oopse {

//IgnoreVisitor will turn on the ignoring flag of the stuntdouble
class IgnoreVisitor : public BaseVisitor{
  public:
    IgnoreVisitor() : BaseVisitor() {visitorName = "IgnoreVisitor";}

    virtual void visit(Atom* atom);
    virtual void visit(DirectionalAtom* datom);
    virtual void visit(RigidBody* rb);
    
    virtual const string toString();

    void addIgnoreType(const string& type) {itList.insert(type);}
    
  protected:
    bool isIgnoreType(const string& name);
    void internalVisit(StuntDouble* sd);
    set<string> itList; //ignore type list;
};


class WrappingVisitor : public BaseVisitor{
  public:
    WrappingVisitor(SimInfo* info) : BaseVisitor() {
      this->info = info;
      visitorName = "WrappingVisitor";
    }
    virtual void visit(Atom* atom);
    virtual void visit(DirectionalAtom* datom);
    virtual void visit(RigidBody* rb);

    virtual const string toString();

  protected:
    void internalVisit(StuntDouble* sd);
    SimInfo* info;
};


class IntVec3 {
  public:
    IntVec3(){}
    IntVec3(int i, int j, int k){
      vec[0] = i;
      vec[1] = j;
      vec[2] = k;
    }
    
    int vec[3];
    int& operator[](int index) {return vec[index];}  
};

class ReplicateVisitor : public BaseVisitor{
  public:
    ReplicateVisitor(SimInfo* info, IntVec3 opt);
    virtual void visit(Atom* atom);
    virtual void visit(DirectionalAtom* datom);
    virtual void visit(RigidBody* rb);

    virtual const string toString();
  protected:
    void internalVisit(StuntDouble* sd);
    void replicate(vector<AtomInfo*>& infoList,  AtomData* data, double boxM[3][3]);
    
  private:
    vector<IntVec3> dir;
    SimInfo* info;
    IntVec3 replicateOpt;
};

class XYZVisitor : public BaseVisitor{
  public:
    XYZVisitor(SimInfo* info, bool printDipole = true);
    
    virtual void visit(Atom* atom);
    virtual void visit(DirectionalAtom* datom);
    virtual void visit(RigidBody* rb);

    virtual const string toString();
    
    void writeFrame(ostream& outStream);    
    void clear() {frame.clear();}
    
  protected:
    void internalVisit(StuntDouble* sd);
    bool isIgnore(StuntDouble* sd);

  private:  
    SimInfo* info;
    vector<string> frame;
    bool printDipole;
};


class PrepareVisitor : public BaseVisitor{
  public:
    PrepareVisitor() : BaseVisitor() {visitorName = "prepareVisitor";}

    virtual void visit(Atom* atom) {internalVisit(atom);}
    virtual void visit(DirectionalAtom* datom) {internalVisit((Atom*)datom);}
    virtual void visit(RigidBody* rb) {internalVisit(rb);}

    virtual const string toString();

  protected:
    void internalVisit(Atom* atom);
    void internalVisit(RigidBody* rb);
};

class WaterTypeVisitor : public BaseVisitor{
  public:
    WaterTypeVisitor() ;
    virtual void visit(Atom* atom) {}
    virtual void visit(DirectionalAtom* datom) {}
    virtual void visit(RigidBody* rb);

    virtual const string toString();
    
  private:
    void replaceType(string& atomType);
      
    set<string> waterTypeList;
};


}//namespace oopse
#endif //_OTHERVISITOR_H_
Revision:	1625
Committed:	Thu Oct 21 16:22:01 2004 UTC (19 years, 8 months ago) by tim
File size:	3325 byte(s)
Log Message:	replace old GebericData with new GenericData
#	Content
1	#ifndef _OTHERVISITOR_H_
2	#define _OTHERVISITOR_H_
3	#include <set>
4	#include <string>
5	#include <vector>
6
7	#include "visitors/BaseVisitor.hpp"
8	#include "primitives/StuntDouble.hpp"
9	#include "visitors/AtomData.hpp"
10
11	using namespace std;
12
13	namespace oopse {
14
15	//IgnoreVisitor will turn on the ignoring flag of the stuntdouble
16	class IgnoreVisitor : public BaseVisitor{
17	public:
18	IgnoreVisitor() : BaseVisitor() {visitorName = "IgnoreVisitor";}
19
20	virtual void visit(Atom* atom);
21	virtual void visit(DirectionalAtom* datom);
22	virtual void visit(RigidBody* rb);
23
24	virtual const string toString();
25
26	void addIgnoreType(const string& type) {itList.insert(type);}
27
28	protected:
29	bool isIgnoreType(const string& name);
30	void internalVisit(StuntDouble* sd);
31	set<string> itList; //ignore type list;
32	};
33
34
35	class WrappingVisitor : public BaseVisitor{
36	public:
37	WrappingVisitor(SimInfo* info) : BaseVisitor() {
38	this->info = info;
39	visitorName = "WrappingVisitor";
40	}
41	virtual void visit(Atom* atom);
42	virtual void visit(DirectionalAtom* datom);
43	virtual void visit(RigidBody* rb);
44
45	virtual const string toString();
46
47	protected:
48	void internalVisit(StuntDouble* sd);
49	SimInfo* info;
50	};
51
52
53	class IntVec3 {
54	public:
55	IntVec3(){}
56	IntVec3(int i, int j, int k){
57	vec[0] = i;
58	vec[1] = j;
59	vec[2] = k;
60	}
61
62	int vec[3];
63	int& operator[](int index) {return vec[index];}
64	};
65
66	class ReplicateVisitor : public BaseVisitor{
67	public:
68	ReplicateVisitor(SimInfo* info, IntVec3 opt);
69	virtual void visit(Atom* atom);
70	virtual void visit(DirectionalAtom* datom);
71	virtual void visit(RigidBody* rb);
72
73	virtual const string toString();
74	protected:
75	void internalVisit(StuntDouble* sd);
76	void replicate(vector<AtomInfo>& infoList, AtomData data, double boxM[3][3]);
77
78	private:
79	vector<IntVec3> dir;
80	SimInfo* info;
81	IntVec3 replicateOpt;
82	};
83
84	class XYZVisitor : public BaseVisitor{
85	public:
86	XYZVisitor(SimInfo* info, bool printDipole = true);
87
88	virtual void visit(Atom* atom);
89	virtual void visit(DirectionalAtom* datom);
90	virtual void visit(RigidBody* rb);
91
92	virtual const string toString();
93
94	void writeFrame(ostream& outStream);
95	void clear() {frame.clear();}
96
97	protected:
98	void internalVisit(StuntDouble* sd);
99	bool isIgnore(StuntDouble* sd);
100
101	private:
102	SimInfo* info;
103	vector<string> frame;
104	bool printDipole;
105	};
106
107
108	class PrepareVisitor : public BaseVisitor{
109	public:
110	PrepareVisitor() : BaseVisitor() {visitorName = "prepareVisitor";}
111
112	virtual void visit(Atom* atom) {internalVisit(atom);}
113	virtual void visit(DirectionalAtom* datom) {internalVisit((Atom*)datom);}
114	virtual void visit(RigidBody* rb) {internalVisit(rb);}
115
116	virtual const string toString();
117
118	protected:
119	void internalVisit(Atom* atom);
120	void internalVisit(RigidBody* rb);
121	};
122
123	class WaterTypeVisitor : public BaseVisitor{
124	public:
125	WaterTypeVisitor() ;
126	virtual void visit(Atom* atom) {}
127	virtual void visit(DirectionalAtom* datom) {}
128	virtual void visit(RigidBody* rb);
129
130	virtual const string toString();
131
132	private:
133	void replaceType(string& atomType);
134
135	set<string> waterTypeList;
136	};
137
138
139	}//namespace oopse
140	#endif //_OTHERVISITOR_H_