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 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 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:	507
Committed:	Fri Apr 15 22:04:00 2005 UTC (20 years, 6 months ago) by gezelter
File size:	6158 byte(s)
Log Message:	xemacs has been drafted to perform our indentation services
#	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
153	const static int opGT = comparator \| 0;
154	const static int opGE = comparator \| 1;
155	const static int opLE = comparator \| 2;
156	const static int opLT = comparator \| 3;
157	const static int opEQ = comparator \| 4;
158	const static int opNE = comparator \| 5;
159
160	static Token tokenExpressionBegin;
161	static Token tokenExpressionEnd;
162
163	};
164
165
166	}
167
168	#endif