src/selection/Token.hpp

 /*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Acknowledgement of the program authors must be made in any
 *    publication of scientific results based in part on use of the
 *    program.  An acceptable form of acknowledgement is citation of
 *    the article in which the program was described (Matthew
 *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
 *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
 *    Parallel Simulation Engine for Molecular Dynamics,"
 *    J. Comput. Chem. 26, pp. 252-271 (2005))
 *
 * 2. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 3. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 */

#ifndef SELECTION_TOKEN_HPP
#define SELECTION_TOKEN_HPP

#include <map>
#include <string>
#include <utility>
#include "utils/any.hpp"

namespace oopse {


/**
 * @class Token
 * @todo document
 * @note translate from jmol
 */
class Token {

    public:


        int tok;
        boost::any value;
        int intValue;

        Token() { tok = unknown;}

        Token(const Token& token) {
            *this = token;
        }
        
        Token(int tok, int intValue, const boost::any& value) {
            this->tok = tok;
            this->intValue = intValue;
            this->value = value;
        }

        Token(int tok, int intValue) {
        this->tok = tok;
        this->intValue = intValue;
        }

        Token(int tok) {
            this->tok = tok;
        }

        Token(int tok,  const boost::any& value) {
            this->tok = tok;
            this->value = value;
        }
        
        const static int nada              =  0;
        const static int identifier        =  1;
        const static int integer           =  2;
        const static int decimal           =  3;
        const static int string            =  4;
        const static int unknown           =  5;
        const static int keyword           =  6;
        const static int whitespace        =  7;
        const static int comment           =  8;
        const static int endofline         = 9;
        const static int endofstatement    = 10;

        const static int command           = (1 <<  8);
        const static int expressionCommand = (1 <<  9); // expression command
        const static int expression        = (1 << 10); /// expression term

        // generally, the minus sign is used to denote atom ranges
        // this property is used for the few commands which allow negative integers
        const static int negnums      = (1 << 11);

        // every property is also valid in an expression context
        const static int atomproperty      = (1 << 12) | expression | negnums;
        // every predefined is also valid in an expression context
        const static int comparator        = (1 << 13) | expression;
        const static int predefinedset     = (1 << 14) | expression;
        const  static int embeddedExpression= (1 << 15); // embedded expression
        
        // rasmol commands
        const static int define       = command | expressionCommand |1;
        const static int select       = command |expressionCommand |2 ;

        //predefine
        //const static int selected    = predefinedset |0;

        // atom expression operators
        const static int leftparen    = expression |  0;
        const static int rightparen   = expression |  1;
        const static int hyphen       = expression |  2;
        const static int opAnd        = expression |  3;
        const static int opOr         = expression |  4;
        const static int opNot        = expression |  5;
        const static int within       = expression |  6;
        const static int asterisk     = expression |  7;
        const static int dot          = expression | 8;
        const static int all          = expression | 9 ; 
        const static int none      = expression | 10;
        const static int name            =  expression |11;

        // miguel 2005 01 01
        // these are used to demark the beginning and end of expressions
        // they do not exist in the source code, but are emitted by the
        // expression compiler
        const static int expressionBegin = expression | 100;
        const static int expressionEnd   = expression | 101;

        const static int mass         = atomproperty | 0;
        const static int charge       = atomproperty | 1;
        const static int dipole       = atomproperty | 2;
        
        const static int opGT         = comparator |  0;
        const static int opGE         = comparator |  1;
        const static int opLE         = comparator |  2;
        const static int opLT         = comparator |  3;
        const static int opEQ         = comparator |  4;
        const static int opNE         = comparator |  5;
 
        static Token tokenExpressionBegin;
        static Token tokenExpressionEnd;

};


}

#endif 
Revision:	1967
Committed:	Thu Feb 3 23:14:05 2005 UTC (19 years, 5 months ago) by tim
File size:	6318 byte(s)
Log Message:	more work in selection library
#	User	Rev	Content
1	tim	1961	/*
2			* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3			*
4			* The University of Notre Dame grants you ("Licensee") a
5			* non-exclusive, royalty free, license to use, modify and
6			* redistribute this software in source and binary code form, provided
7			* that the following conditions are met:
8			*
9			* 1. Acknowledgement of the program authors must be made in any
10			* publication of scientific results based in part on use of the
11			* program. An acceptable form of acknowledgement is citation of
12			* the article in which the program was described (Matthew
13			* A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14			* J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15			* Parallel Simulation Engine for Molecular Dynamics,"
16			* J. Comput. Chem. 26, pp. 252-271 (2005))
17			*
18			* 2. Redistributions of source code must retain the above copyright
19			* notice, this list of conditions and the following disclaimer.
20			*
21			* 3. Redistributions in binary form must reproduce the above copyright
22			* notice, this list of conditions and the following disclaimer in the
23			* documentation and/or other materials provided with the
24			* distribution.
25			*
26			* This software is provided "AS IS," without a warranty of any
27			* kind. All express or implied conditions, representations and
28			* warranties, including any implied warranty of merchantability,
29			* fitness for a particular purpose or non-infringement, are hereby
30			* excluded. The University of Notre Dame and its licensors shall not
31			* be liable for any damages suffered by licensee as a result of
32			* using, modifying or distributing the software or its
33			* derivatives. In no event will the University of Notre Dame or its
34			* licensors be liable for any lost revenue, profit or data, or for
35			* direct, indirect, special, consequential, incidental or punitive
36			* damages, however caused and regardless of the theory of liability,
37			* arising out of the use of or inability to use software, even if the
38			* University of Notre Dame has been advised of the possibility of
39			* such damages.
40			*/
41
42			#ifndef SELECTION_TOKEN_HPP
43			#define SELECTION_TOKEN_HPP
44
45	tim	1965	#include <map>
46			#include <string>
47			#include <utility>
48			#include "utils/any.hpp"
49	tim	1961
50			namespace oopse {
51
52
53			/**
54			* @class Token
55			* @todo document
56	tim	1962	* @note translate from jmol
57	tim	1961	*/
58			class Token {
59
60			public:
61
62	tim	1965
63	tim	1961	int tok;
64	tim	1965	boost::any value;
65			int intValue;
66	tim	1962
67	tim	1965	Token() { tok = unknown;}
68
69			Token(const Token& token) {
70			*this = token;
71	tim	1962	}
72	tim	1965
73			Token(int tok, int intValue, const boost::any& value) {
74			this->tok = tok;
75			this->intValue = intValue;
76			this->value = value;
77			}
78	tim	1962
79			Token(int tok, int intValue) {
80	tim	1965	this->tok = tok;
81			this->intValue = intValue;
82	tim	1962	}
83
84			Token(int tok) {
85	tim	1965	this->tok = tok;
86	tim	1962	}
87
88	tim	1965	Token(int tok, const boost::any& value) {
89			this->tok = tok;
90			this->value = value;
91	tim	1962	}
92	tim	1961
93			const static int nada = 0;
94			const static int identifier = 1;
95			const static int integer = 2;
96			const static int decimal = 3;
97			const static int string = 4;
98	tim	1962	const static int unknown = 5;
99			const static int keyword = 6;
100			const static int whitespace = 7;
101			const static int comment = 8;
102			const static int endofline = 9;
103			const static int endofstatement = 10;
104	tim	1961
105			const static int command = (1 << 8);
106			const static int expressionCommand = (1 << 9); // expression command
107	tim	1962	const static int expression = (1 << 10); /// expression term
108	tim	1961
109	tim	1965	// generally, the minus sign is used to denote atom ranges
110			// this property is used for the few commands which allow negative integers
111			const static int negnums = (1 << 11);
112
113	tim	1961	// every property is also valid in an expression context
114	tim	1965	const static int atomproperty = (1 << 12) \| expression \| negnums;
115	tim	1961	// every predefined is also valid in an expression context
116	tim	1965	const static int comparator = (1 << 13) \| expression;
117			const static int predefinedset = (1 << 14) \| expression;
118			const static int embeddedExpression= (1 << 15); // embedded expression
119
120	tim	1961	// rasmol commands
121			const static int define = command \| expressionCommand \|1;
122			const static int select = command \|expressionCommand \|2 ;
123
124	tim	1965	//predefine
125	tim	1967	//const static int selected = predefinedset \|0;
126	tim	1965
127	tim	1961	// atom expression operators
128			const static int leftparen = expression \| 0;
129			const static int rightparen = expression \| 1;
130			const static int hyphen = expression \| 2;
131			const static int opAnd = expression \| 3;
132			const static int opOr = expression \| 4;
133			const static int opNot = expression \| 5;
134			const static int within = expression \| 6;
135	tim	1962	const static int asterisk = expression \| 7;
136			const static int dot = expression \| 8;
137	tim	1967	const static int all = expression \| 9 ;
138			const static int none = expression \| 10;
139			const static int name = expression \|11;
140
141	tim	1961	// miguel 2005 01 01
142			// these are used to demark the beginning and end of expressions
143			// they do not exist in the source code, but are emitted by the
144			// expression compiler
145			const static int expressionBegin = expression \| 100;
146			const static int expressionEnd = expression \| 101;
147
148	tim	1965	const static int mass = atomproperty \| 0;
149			const static int charge = atomproperty \| 1;
150			const static int dipole = atomproperty \| 2;
151
152	tim	1961	const static int opGT = comparator \| 0;
153			const static int opGE = comparator \| 1;
154			const static int opLE = comparator \| 2;
155			const static int opLT = comparator \| 3;
156			const static int opEQ = comparator \| 4;
157			const static int opNE = comparator \| 5;
158
159	tim	1965	static Token tokenExpressionBegin;
160			static Token tokenExpressionEnd;
161	tim	1961
162	tim	1962	};
163	tim	1961
164
165			}
166
167	tim	1962	#endif