src/selection/SelectionToken.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. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. 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.
 *
 * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
 * research, please cite the appropriate papers when you publish your
 * work.  Good starting points are:
 *                                                                      
 * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
 * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
 * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
 * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
 */

#ifndef SELECTION_TOKEN_HPP
#define SELECTION_TOKEN_HPP

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

namespace OpenMD {


  /**
   * @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 MyTok, int myIntValue, const boost::any& myValue) {
      this->tok = MyTok;
      this->intValue = myIntValue;
      this->value = myValue;
    }

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

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

    Token(int myTok,  const boost::any& myValue) {
      this->tok = myTok;
      this->value = myValue;
    }
        
    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 <<  11);
    const static int expressionCommand = (1 <<  12); // expression command
    const static int expression        = (1 << 13); /// 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 << 14);

    //expression involves coordinates which will change every frame, such as withins
    const static int dynamic        = (1 << 15);

    // every property is also valid in an expression context
    const static int atomproperty      = (1 << 16) | expression | negnums;
    // every predefined is also valid in an expression context
    const static int comparator        = (1 << 17) | expression;
    const static int predefinedset     = (1 << 18) | expression;
    const  static int embeddedExpression= (1 << 19); // embedded expression
    const static int index = (1 << 20) | 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 to           = 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 | dynamic | 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;
    const static int hull         = expression | dynamic | 12;
    // 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 x            = atomproperty | dynamic | 2;
    const static int y            = atomproperty | dynamic | 3;
    const static int z            = atomproperty | dynamic | 4;
    const static int r            = atomproperty | dynamic | 5;
        
    const static int opGT         = comparator |  dynamic | 0;
    const static int opGE         = comparator |  dynamic | 1;
    const static int opLE         = comparator |  dynamic | 2;
    const static int opLT         = comparator |  dynamic | 3;
    const static int opEQ         = comparator |  dynamic | 4;
    const static int opNE         = comparator |  dynamic | 5;
 
    static Token tokenExpressionBegin;
    static Token tokenExpressionEnd;

  };


}

#endif 
Revision:	1665
Committed:	Tue Nov 22 20:38:56 2011 UTC (13 years, 5 months ago) by gezelter
File size:	6649 byte(s)
Log Message:	updated copyright notices
#	User	Rev	Content
1	tim	770	/*
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	gezelter	1390	* 1. Redistributions of source code must retain the above copyright
10	tim	770	* notice, this list of conditions and the following disclaimer.
11			*
12	gezelter	1390	* 2. Redistributions in binary form must reproduce the above copyright
13	tim	770	* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the
15			* distribution.
16			*
17			* This software is provided "AS IS," without a warranty of any
18			* kind. All express or implied conditions, representations and
19			* warranties, including any implied warranty of merchantability,
20			* fitness for a particular purpose or non-infringement, are hereby
21			* excluded. The University of Notre Dame and its licensors shall not
22			* be liable for any damages suffered by licensee as a result of
23			* using, modifying or distributing the software or its
24			* derivatives. In no event will the University of Notre Dame or its
25			* licensors be liable for any lost revenue, profit or data, or for
26			* direct, indirect, special, consequential, incidental or punitive
27			* damages, however caused and regardless of the theory of liability,
28			* arising out of the use of or inability to use software, even if the
29			* University of Notre Dame has been advised of the possibility of
30			* such damages.
31	gezelter	1390	*
32			* SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your
33			* research, please cite the appropriate papers when you publish your
34			* work. Good starting points are:
35			*
36			* [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37			* [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38			* [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	gezelter	1665	* [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010).
40			* [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41	tim	770	*/
42
43			#ifndef SELECTION_TOKEN_HPP
44			#define SELECTION_TOKEN_HPP
45
46			#include <map>
47			#include <string>
48			#include <utility>
49			#include "utils/any.hpp"
50
51	gezelter	1390	namespace OpenMD {
52	tim	770
53
54			/**
55			* @class Token
56			* @todo document
57			* @note translate from jmol
58			*/
59			class Token {
60
61			public:
62
63
64			int tok;
65			boost::any value;
66			int intValue;
67
68			Token() { tok = unknown;}
69
70			Token(const Token& token) {
71			*this = token;
72			}
73
74			Token(int MyTok, int myIntValue, const boost::any& myValue) {
75			this->tok = MyTok;
76			this->intValue = myIntValue;
77			this->value = myValue;
78			}
79
80			Token(int myTok, int myIntValue) {
81			this->tok = myTok;
82			this->intValue = myIntValue;
83			}
84
85			Token(int myTok) {
86			this->tok = myTok;
87			}
88
89			Token(int myTok, const boost::any& myValue) {
90			this->tok = myTok;
91			this->value = myValue;
92			}
93
94			const static int nada = 0;
95			const static int identifier = 1;
96			const static int integer = 2;
97			const static int decimal = 3;
98			const static int string = 4;
99			const static int unknown = 5;
100			const static int keyword = 6;
101			const static int whitespace = 7;
102			const static int comment = 8;
103			const static int endofline = 9;
104			const static int endofstatement = 10;
105
106	gezelter	1629	const static int command = (1 << 11);
107			const static int expressionCommand = (1 << 12); // expression command
108			const static int expression = (1 << 13); /// expression term
109	tim	770
110			// generally, the minus sign is used to denote atom ranges
111			// this property is used for the few commands which allow negative integers
112	gezelter	1629	const static int negnums = (1 << 14);
113	tim	770
114			//expression involves coordinates which will change every frame, such as withins
115	gezelter	1629	const static int dynamic = (1 << 15);
116	tim	770
117			// every property is also valid in an expression context
118	gezelter	1629	const static int atomproperty = (1 << 16) \| expression \| negnums;
119	tim	770	// every predefined is also valid in an expression context
120	gezelter	1629	const static int comparator = (1 << 17) \| expression;
121			const static int predefinedset = (1 << 18) \| expression;
122			const static int embeddedExpression= (1 << 19); // embedded expression
123			const static int index = (1 << 20) \| expression;
124	tim	770	// rasmol commands
125			const static int define = command \| expressionCommand \|1;
126			const static int select = command \|expressionCommand \|2 ;
127
128			//predefine
129			//const static int selected = predefinedset \|0;
130
131			// atom expression operators
132			const static int leftparen = expression \| 0;
133			const static int rightparen = expression \| 1;
134	gezelter	1412	const static int to = expression \| 2;
135	tim	770	const static int opAnd = expression \| 3;
136			const static int opOr = expression \| 4;
137			const static int opNot = expression \| 5;
138			const static int within = expression \| dynamic \| 6;
139			const static int asterisk = expression \| 7;
140			const static int dot = expression \| 8;
141			const static int all = expression \| 9 ;
142	cli2	1360	const static int none = expression \| 10;
143			const static int name = expression \| 11;
144	gezelter	1412	const static int hull = expression \| dynamic \| 12;
145	tim	770	// miguel 2005 01 01
146			// these are used to demark the beginning and end of expressions
147			// they do not exist in the source code, but are emitted by the
148			// expression compiler
149			const static int expressionBegin = expression \| 100;
150			const static int expressionEnd = expression \| 101;
151
152			const static int mass = atomproperty \| 0;
153			const static int charge = atomproperty \| 1;
154	cli2	1360	const static int x = atomproperty \| dynamic \| 2;
155			const static int y = atomproperty \| dynamic \| 3;
156			const static int z = atomproperty \| dynamic \| 4;
157	gezelter	1629	const static int r = atomproperty \| dynamic \| 5;
158	tim	770
159	gezelter	1629	const static int opGT = comparator \| dynamic \| 0;
160			const static int opGE = comparator \| dynamic \| 1;
161			const static int opLE = comparator \| dynamic \| 2;
162			const static int opLT = comparator \| dynamic \| 3;
163			const static int opEQ = comparator \| dynamic \| 4;
164			const static int opNE = comparator \| dynamic \| 5;
165	tim	770
166			static Token tokenExpressionBegin;
167			static Token tokenExpressionEnd;
168
169			};
170
171
172			}
173
174			#endif