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. 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 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 <<  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);

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

    // 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
    const static int index = (1 << 16) | 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;
    // 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 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:	1360
Committed:	Mon Sep 7 16:31:51 2009 UTC (15 years, 8 months ago) by cli2
Original Path:	*trunk/src/selection/SelectionToken.hpp*
File size:	6351 byte(s)
Log Message:	Added new restraint infrastructure Added MolecularRestraints Added ObjectRestraints Added RestraintStamp Updated thermodynamic integration to use ObjectRestraints Added Quaternion mathematics for twist swing decompositions Significantly updated RestWriter and RestReader to use dump-like files Added selections for x, y, and z coordinates of atoms Removed monolithic Restraints class Fixed a few bugs in gradients of Euler angles in DirectionalAtom and RigidBody Added some rotational capabilities to prinicpalAxisCalculator
#	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			* 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			#include <map>
46			#include <string>
47			#include <utility>
48			#include "utils/any.hpp"
49
50			namespace oopse {
51
52
53			/**
54			* @class Token
55			* @todo document
56			* @note translate from jmol
57			*/
58			class Token {
59
60			public:
61
62
63			int tok;
64			boost::any value;
65			int intValue;
66
67			Token() { tok = unknown;}
68
69			Token(const Token& token) {
70			*this = token;
71			}
72
73			Token(int MyTok, int myIntValue, const boost::any& myValue) {
74			this->tok = MyTok;
75			this->intValue = myIntValue;
76			this->value = myValue;
77			}
78
79			Token(int myTok, int myIntValue) {
80			this->tok = myTok;
81			this->intValue = myIntValue;
82			}
83
84			Token(int myTok) {
85			this->tok = myTok;
86			}
87
88			Token(int myTok, const boost::any& myValue) {
89			this->tok = myTok;
90			this->value = myValue;
91			}
92
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			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
105			const static int command = (1 << 8);
106			const static int expressionCommand = (1 << 9); // expression command
107			const static int expression = (1 << 10); /// expression term
108
109			// 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			//expression involves coordinates which will change every frame, such as withins
114			const static int dynamic = (1 << 12);
115
116			// every property is also valid in an expression context
117			const static int atomproperty = (1 << 12) \| expression \| negnums;
118			// every predefined is also valid in an expression context
119			const static int comparator = (1 << 13) \| expression;
120			const static int predefinedset = (1 << 14) \| expression;
121			const static int embeddedExpression= (1 << 15); // embedded expression
122			const static int index = (1 << 16) \| expression;
123			// rasmol commands
124			const static int define = command \| expressionCommand \|1;
125			const static int select = command \|expressionCommand \|2 ;
126
127			//predefine
128			//const static int selected = predefinedset \|0;
129
130			// atom expression operators
131			const static int leftparen = expression \| 0;
132			const static int rightparen = expression \| 1;
133	cli2	1360	const static int to = expression \| 2;
134	tim	770	const static int opAnd = expression \| 3;
135			const static int opOr = expression \| 4;
136			const static int opNot = expression \| 5;
137			const static int within = expression \| dynamic \| 6;
138			const static int asterisk = expression \| 7;
139			const static int dot = expression \| 8;
140			const static int all = expression \| 9 ;
141	cli2	1360	const static int none = expression \| 10;
142			const static int name = expression \| 11;
143	tim	770	// miguel 2005 01 01
144			// these are used to demark the beginning and end of expressions
145			// they do not exist in the source code, but are emitted by the
146			// expression compiler
147			const static int expressionBegin = expression \| 100;
148			const static int expressionEnd = expression \| 101;
149
150			const static int mass = atomproperty \| 0;
151			const static int charge = atomproperty \| 1;
152	cli2	1360	const static int x = atomproperty \| dynamic \| 2;
153			const static int y = atomproperty \| dynamic \| 3;
154			const static int z = atomproperty \| dynamic \| 4;
155	tim	770
156			const static int opGT = comparator \| 0;
157			const static int opGE = comparator \| 1;
158			const static int opLE = comparator \| 2;
159			const static int opLT = comparator \| 3;
160			const static int opEQ = comparator \| 4;
161			const static int opNE = comparator \| 5;
162
163			static Token tokenExpressionBegin;
164			static Token tokenExpressionEnd;
165
166			};
167
168
169			}
170
171			#endif