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:	3520
Committed:	Mon Sep 7 16:31:51 2009 UTC (15 years, 7 months ago) by cli2
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
#	Content
1	/*
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	const static int to = expression \| 2;
134	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	const static int none = expression \| 10;
142	const static int name = expression \| 11;
143	// 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	const static int x = atomproperty \| dynamic \| 2;
153	const static int y = atomproperty \| dynamic \| 3;
154	const static int z = atomproperty \| dynamic \| 4;
155
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