src/io/ParamConstraint.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 IO_PARAMCONSTRAINT_HPP
#define IO_PARAMCONSTRAINT_HPP
#include <sstream>
#include "utils/CaseConversion.hpp"
#include "utils/StringTokenizer.hpp"

/**
  * This class allows to recognize constraint predicates, so that they can be combined using
  * composition operators. Every constraint predicate must be derived from this class
  */
template<typename Derived>
struct ParamConstraintFacade {
    std::string getConstraintDescription() {return description_;}
    protected:
        std::string description_;
};

struct NotEmptyConstraint : public ParamConstraintFacade<NotEmptyConstraint>{

    NotEmptyConstraint() { description_= "nonempty";}
    bool operator()( const std::string data ) const {
        return !data.empty();
    }
};

struct ZeroConstraint : public ParamConstraintFacade<ZeroConstraint>{
    
    ZeroConstraint() {this->description_ = "zero";}
    template<typename DataType>
    bool operator()( DataType data ) const {
        return data == 0;
    }
};

struct NonZeroConstraint : public ParamConstraintFacade<NonZeroConstraint>{
    NonZeroConstraint() {this->description_ = "nonzero";}

    template<typename DataType>
    bool operator()( DataType data ) const {
        return data != 0;
    }
};

struct PositiveConstraint : public ParamConstraintFacade<PositiveConstraint>{
    PositiveConstraint() {this->description_ = "positive";}
    template<typename DataType>
    bool operator()( DataType data ) const
    {
        return data > 0;
    }
};

struct NonPositiveConstraint : public ParamConstraintFacade<NonPositiveConstraint>{
    NonPositiveConstraint() {this->description_ = "nonpositive";}
    template<typename DataType>
    bool operator()( DataType data ) const
    {
        return data <= 0;
    }
};

struct NegativeConstraint : public ParamConstraintFacade<NegativeConstraint>{
    NegativeConstraint() {this->description_ = "negative";}
    template<typename DataType>
    bool operator()( DataType data ) const
    {
        return data < 0;
    }
};

struct NonNegativeConstraint : public ParamConstraintFacade<NonNegativeConstraint>{
    NonNegativeConstraint() {this->description_ = "nonnegative";}
    template<typename DataType>
    bool operator()( DataType data ) const
    {
        return data >= 0;
    }
};

template<typename T>
struct LessThanConstraint : public ParamConstraintFacade<LessThanConstraint<T> > {
    
    LessThanConstraint(T rhs) : rhs_(rhs){
        std::stringstream iss;
        iss << "less than " << rhs;
        this->description_ = iss.str();
    }
    template<typename DataType>
    bool operator()( DataType data ) const {
        return data < rhs_; 
    }
    private:
        T rhs_;        
};

template<typename T>
struct LessThanOrEqualToConstraint : public ParamConstraintFacade<LessThanOrEqualToConstraint<T> > {
    
    LessThanOrEqualToConstraint(T rhs) : rhs_(rhs) {
        std::stringstream iss;
        iss << "less than or equal to" << rhs;
        this->description_ = iss.str();
    }
    
    template<typename DataType>
    bool operator()( DataType data ) const {
        return data <= rhs_; 
    }
    
    private:
        T rhs_;        
};

template<typename T>
struct EqualConstraint : public ParamConstraintFacade<EqualConstraint<T> > {
    
    EqualConstraint(T rhs) : rhs_(rhs){
        std::stringstream iss;
        iss << "equal to" << rhs;
        this->description_ = iss.str();

    }
    template<typename DataType>
    bool operator()( DataType data ) const {
        return data == rhs_; 
    }
    private:
        T rhs_;        
};

struct EqualIgnoreCaseConstraint : public ParamConstraintFacade<EqualIgnoreCaseConstraint> {
    
    EqualIgnoreCaseConstraint(std::string rhs) : rhs_(oopse::toUpperCopy(rhs)){
        std::stringstream iss;
        iss << "equal to (case insensitive) " << rhs;
        this->description_ = iss.str();
    }
    
    bool operator()( std::string data ) const {
        return oopse::toUpperCopy(data) == rhs_; 
    }
    
    private:
       std::string rhs_;        
};

struct ContainsConstraint :  public ParamConstraintFacade<EqualIgnoreCaseConstraint> {
    ContainsConstraint(std::string rhs) : rhs_(oopse::toUpperCopy(rhs)){
        std::stringstream iss;
        iss << "contains " << rhs;
        this->description_ = iss.str();
    }
    
    bool operator()( std::string data ) const {
        oopse::StringTokenizer tokenizer(oopse::toUpperCopy(data),  " ,;|\t\n\r");
        while (tokenizer.hasMoreTokens()) {
            if (tokenizer.nextToken() == rhs_) {
                return true;
            }
        }
        
        return  false; 
    }
    
    private:
       std::string rhs_;        

};

template<typename T>
struct GreaterThanConstraint : public ParamConstraintFacade<GreaterThanConstraint<T> > {
    
    GreaterThanConstraint(T rhs) : rhs_(rhs){
        std::stringstream iss;
        iss << "greater than" << rhs;
        this->description_ = iss.str();
    }
    template<typename DataType>
    bool operator()( DataType data ) const {
        return data > rhs_; 
    }
    private:
        T rhs_;        
};

template<typename T>
struct GreaterThanOrEqualTo : public ParamConstraintFacade<GreaterThanOrEqualTo<T> > {
    
    GreaterThanOrEqualTo(T rhs) : rhs_(rhs){
        std::stringstream iss;
        iss << "greater than or equal to" << rhs;
        this->description_ = iss.str();
    }
    template<typename DataType>
    bool operator()( DataType data ) const {
        return data >= rhs_; 
    }
    private:
        T rhs_;        
};

// class_and composition predicate
template<typename Cons1T, typename Cons2T>
struct AndParamConstraint: public ParamConstraintFacade< AndParamConstraint<Cons1T,Cons2T> > {
public:

    AndParamConstraint( Cons1T cons1, Cons2T cons2 ) : cons1_(cons1), cons2_(cons2) {
        std::stringstream iss;
        iss << "(" << cons1_.getConstraintDescription() << " and " << cons2_.getConstraintDescription() << ")"; 
        this->description_ = iss.str();        
    }

    template<typename DataType>
    bool operator()( DataType data ) const {
        return cons1_(data) && cons2_(data);
    }

private:
    Cons1T cons1_;
    Cons2T cons2_;
};


template<typename Cons1T, typename Cons2T>
struct OrParamConstraint: public ParamConstraintFacade< OrParamConstraint<Cons1T,Cons2T> > {
public:

    OrParamConstraint( Cons1T cons1, Cons2T cons2 ) : cons1_(cons1), cons2_(cons2) {
        std::stringstream iss;
        iss << cons1_.getConstraintDescription() << " or " << cons2_.getConstraintDescription() << ""; 
        this->description_ = iss.str(); 
     }

    template<typename DataType>
    bool operator()( DataType data ) const {
        return cons1_(data) || cons2_(data);
    }

private:
    Cons1T cons1_;
    Cons2T cons2_;
};

template<typename ConsT>
struct NotParamConstraint: public ParamConstraintFacade< NotParamConstraint<ConsT> > {
public:


    NotParamConstraint( ConsT cons) : cons_(cons) {
        std::stringstream iss;
        iss << "(not" << cons_.getConstraintDescription() << ")"; 
        this->description_ = iss.str(); 
    }

    template<typename DataType>
    bool operator()( DataType data ) const {
        return !cons_(data);
    }

private:
    ConsT cons_;
};    


template<typename Cons1T, typename Cons2T>
inline AndParamConstraint<Cons1T, Cons2T>
operator &&(const ParamConstraintFacade<Cons1T>& cons1,  const ParamConstraintFacade<Cons2T>& cons2 ) {    

    return AndParamConstraint<Cons1T,Cons2T>(
        *static_cast<const Cons1T*>(&cons1), 
        *static_cast<const Cons2T*>(&cons2) );
}

template<typename Cons1T, typename Cons2T>
inline OrParamConstraint<Cons1T, Cons2T>
operator ||( const ParamConstraintFacade<Cons1T>& cons1, const ParamConstraintFacade<Cons2T>& cons2 ) {    

    return OrParamConstraint<Cons1T,Cons2T>(
        *static_cast<const Cons1T*>(&cons1), 
        *static_cast<const Cons2T*>(&cons2) );
}


template<typename ConsT>
inline NotParamConstraint<ConsT>
operator !( const ParamConstraintFacade<ConsT>& cons ) {

    return NotParamConstraint<ConsT>(*static_cast<const ConsT*>(&cons)); 
}


NotEmptyConstraint isNotEmpty() {
    return NotEmptyConstraint();
}

ZeroConstraint isZero() {
    return ZeroConstraint();
}

ParamConstraintFacade<NonZeroConstraint> isNonZero() {
    return ParamConstraintFacade<NonZeroConstraint>();
}

PositiveConstraint isPositive() {
    return PositiveConstraint();
}

NonPositiveConstraint isNonPositive() {
    return NonPositiveConstraint();
}

NegativeConstraint isNegative() {
    return NegativeConstraint();
}

NonNegativeConstraint isNonNegative() {
    return NonNegativeConstraint();
}

template<typename T>
LessThanConstraint<T>isLessThan(T& v ) {
    return LessThanConstraint<T>(v);
}

template<typename T>
LessThanOrEqualToConstraint<T> isLessThanOrEqualTo(T& v ) {
    return ParamConstraintFacade<LessThanOrEqualToConstraint<T> >(v);
}

template<typename T>
EqualConstraint<T> isEqual(T& v ) {
    return EqualConstraint<T>(v);
}

template<typename T>
GreaterThanConstraint<T> isGreaterThan(T& v ) {
    return GreaterThanConstraint<T>(v);
}

template<typename T>
GreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(T& v ) {
    return GreaterThanOrEqualTo<T>(v);
}

EqualIgnoreCaseConstraint isEqualIgnoreCase(std::string str) {
    return EqualIgnoreCaseConstraint(str);
}

#endif
Revision:	678
Committed:	Mon Oct 17 19:24:02 2005 UTC (20 years ago) by tim
File size:	11450 byte(s)
Log Message:	Another bug fix
#	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 IO_PARAMCONSTRAINT_HPP
43	#define IO_PARAMCONSTRAINT_HPP
44	#include <sstream>
45	#include "utils/CaseConversion.hpp"
46	#include "utils/StringTokenizer.hpp"
47
48	/**
49	* This class allows to recognize constraint predicates, so that they can be combined using
50	* composition operators. Every constraint predicate must be derived from this class
51	*/
52	template<typename Derived>
53	struct ParamConstraintFacade {
54	std::string getConstraintDescription() {return description_;}
55	protected:
56	std::string description_;
57	};
58
59	struct NotEmptyConstraint : public ParamConstraintFacade<NotEmptyConstraint>{
60
61	NotEmptyConstraint() { description_= "nonempty";}
62	bool operator()( const std::string data ) const {
63	return !data.empty();
64	}
65	};
66
67	struct ZeroConstraint : public ParamConstraintFacade<ZeroConstraint>{
68
69	ZeroConstraint() {this->description_ = "zero";}
70	template<typename DataType>
71	bool operator()( DataType data ) const {
72	return data == 0;
73	}
74	};
75
76	struct NonZeroConstraint : public ParamConstraintFacade<NonZeroConstraint>{
77	NonZeroConstraint() {this->description_ = "nonzero";}
78
79	template<typename DataType>
80	bool operator()( DataType data ) const {
81	return data != 0;
82	}
83	};
84
85	struct PositiveConstraint : public ParamConstraintFacade<PositiveConstraint>{
86	PositiveConstraint() {this->description_ = "positive";}
87	template<typename DataType>
88	bool operator()( DataType data ) const
89	{
90	return data > 0;
91	}
92	};
93
94	struct NonPositiveConstraint : public ParamConstraintFacade<NonPositiveConstraint>{
95	NonPositiveConstraint() {this->description_ = "nonpositive";}
96	template<typename DataType>
97	bool operator()( DataType data ) const
98	{
99	return data <= 0;
100	}
101	};
102
103	struct NegativeConstraint : public ParamConstraintFacade<NegativeConstraint>{
104	NegativeConstraint() {this->description_ = "negative";}
105	template<typename DataType>
106	bool operator()( DataType data ) const
107	{
108	return data < 0;
109	}
110	};
111
112	struct NonNegativeConstraint : public ParamConstraintFacade<NonNegativeConstraint>{
113	NonNegativeConstraint() {this->description_ = "nonnegative";}
114	template<typename DataType>
115	bool operator()( DataType data ) const
116	{
117	return data >= 0;
118	}
119	};
120
121	template<typename T>
122	struct LessThanConstraint : public ParamConstraintFacade<LessThanConstraint<T> > {
123
124	LessThanConstraint(T rhs) : rhs_(rhs){
125	std::stringstream iss;
126	iss << "less than " << rhs;
127	this->description_ = iss.str();
128	}
129	template<typename DataType>
130	bool operator()( DataType data ) const {
131	return data < rhs_;
132	}
133	private:
134	T rhs_;
135	};
136
137	template<typename T>
138	struct LessThanOrEqualToConstraint : public ParamConstraintFacade<LessThanOrEqualToConstraint<T> > {
139
140	LessThanOrEqualToConstraint(T rhs) : rhs_(rhs) {
141	std::stringstream iss;
142	iss << "less than or equal to" << rhs;
143	this->description_ = iss.str();
144	}
145
146	template<typename DataType>
147	bool operator()( DataType data ) const {
148	return data <= rhs_;
149	}
150
151	private:
152	T rhs_;
153	};
154
155	template<typename T>
156	struct EqualConstraint : public ParamConstraintFacade<EqualConstraint<T> > {
157
158	EqualConstraint(T rhs) : rhs_(rhs){
159	std::stringstream iss;
160	iss << "equal to" << rhs;
161	this->description_ = iss.str();
162
163	}
164	template<typename DataType>
165	bool operator()( DataType data ) const {
166	return data == rhs_;
167	}
168	private:
169	T rhs_;
170	};
171
172	struct EqualIgnoreCaseConstraint : public ParamConstraintFacade<EqualIgnoreCaseConstraint> {
173
174	EqualIgnoreCaseConstraint(std::string rhs) : rhs_(oopse::toUpperCopy(rhs)){
175	std::stringstream iss;
176	iss << "equal to (case insensitive) " << rhs;
177	this->description_ = iss.str();
178	}
179
180	bool operator()( std::string data ) const {
181	return oopse::toUpperCopy(data) == rhs_;
182	}
183
184	private:
185	std::string rhs_;
186	};
187
188	struct ContainsConstraint : public ParamConstraintFacade<EqualIgnoreCaseConstraint> {
189	ContainsConstraint(std::string rhs) : rhs_(oopse::toUpperCopy(rhs)){
190	std::stringstream iss;
191	iss << "contains " << rhs;
192	this->description_ = iss.str();
193	}
194
195	bool operator()( std::string data ) const {
196	oopse::StringTokenizer tokenizer(oopse::toUpperCopy(data), " ,;\|\t\n\r");
197	while (tokenizer.hasMoreTokens()) {
198	if (tokenizer.nextToken() == rhs_) {
199	return true;
200	}
201	}
202
203	return false;
204	}
205
206	private:
207	std::string rhs_;
208
209	};
210
211	template<typename T>
212	struct GreaterThanConstraint : public ParamConstraintFacade<GreaterThanConstraint<T> > {
213
214	GreaterThanConstraint(T rhs) : rhs_(rhs){
215	std::stringstream iss;
216	iss << "greater than" << rhs;
217	this->description_ = iss.str();
218	}
219	template<typename DataType>
220	bool operator()( DataType data ) const {
221	return data > rhs_;
222	}
223	private:
224	T rhs_;
225	};
226
227	template<typename T>
228	struct GreaterThanOrEqualTo : public ParamConstraintFacade<GreaterThanOrEqualTo<T> > {
229
230	GreaterThanOrEqualTo(T rhs) : rhs_(rhs){
231	std::stringstream iss;
232	iss << "greater than or equal to" << rhs;
233	this->description_ = iss.str();
234	}
235	template<typename DataType>
236	bool operator()( DataType data ) const {
237	return data >= rhs_;
238	}
239	private:
240	T rhs_;
241	};
242
243	// class_and composition predicate
244	template<typename Cons1T, typename Cons2T>
245	struct AndParamConstraint: public ParamConstraintFacade< AndParamConstraint<Cons1T,Cons2T> > {
246	public:
247
248	AndParamConstraint( Cons1T cons1, Cons2T cons2 ) : cons1_(cons1), cons2_(cons2) {
249	std::stringstream iss;
250	iss << "(" << cons1_.getConstraintDescription() << " and " << cons2_.getConstraintDescription() << ")";
251	this->description_ = iss.str();
252	}
253
254	template<typename DataType>
255	bool operator()( DataType data ) const {
256	return cons1_(data) && cons2_(data);
257	}
258
259	private:
260	Cons1T cons1_;
261	Cons2T cons2_;
262	};
263
264
265
266	template<typename Cons1T, typename Cons2T>
267	struct OrParamConstraint: public ParamConstraintFacade< OrParamConstraint<Cons1T,Cons2T> > {
268	public:
269
270	OrParamConstraint( Cons1T cons1, Cons2T cons2 ) : cons1_(cons1), cons2_(cons2) {
271	std::stringstream iss;
272	iss << cons1_.getConstraintDescription() << " or " << cons2_.getConstraintDescription() << "";
273	this->description_ = iss.str();
274	}
275
276	template<typename DataType>
277	bool operator()( DataType data ) const {
278	return cons1_(data) \|\| cons2_(data);
279	}
280
281	private:
282	Cons1T cons1_;
283	Cons2T cons2_;
284	};
285
286	template<typename ConsT>
287	struct NotParamConstraint: public ParamConstraintFacade< NotParamConstraint<ConsT> > {
288	public:
289
290
291	NotParamConstraint( ConsT cons) : cons_(cons) {
292	std::stringstream iss;
293	iss << "(not" << cons_.getConstraintDescription() << ")";
294	this->description_ = iss.str();
295	}
296
297	template<typename DataType>
298	bool operator()( DataType data ) const {
299	return !cons_(data);
300	}
301
302	private:
303	ConsT cons_;
304	};
305
306
307	template<typename Cons1T, typename Cons2T>
308	inline AndParamConstraint<Cons1T, Cons2T>
309	operator &&(const ParamConstraintFacade<Cons1T>& cons1, const ParamConstraintFacade<Cons2T>& cons2 ) {
310
311	return AndParamConstraint<Cons1T,Cons2T>(
312	static_cast<const Cons1T>(&cons1),
313	static_cast<const Cons2T>(&cons2) );
314	}
315
316	template<typename Cons1T, typename Cons2T>
317	inline OrParamConstraint<Cons1T, Cons2T>
318	operator \|\|( const ParamConstraintFacade<Cons1T>& cons1, const ParamConstraintFacade<Cons2T>& cons2 ) {
319
320	return OrParamConstraint<Cons1T,Cons2T>(
321	static_cast<const Cons1T>(&cons1),
322	static_cast<const Cons2T>(&cons2) );
323	}
324
325
326	template<typename ConsT>
327	inline NotParamConstraint<ConsT>
328	operator !( const ParamConstraintFacade<ConsT>& cons ) {
329
330	return NotParamConstraint<ConsT>(static_cast<const ConsT>(&cons));
331	}
332
333
334	NotEmptyConstraint isNotEmpty() {
335	return NotEmptyConstraint();
336	}
337
338	ZeroConstraint isZero() {
339	return ZeroConstraint();
340	}
341
342	ParamConstraintFacade<NonZeroConstraint> isNonZero() {
343	return ParamConstraintFacade<NonZeroConstraint>();
344	}
345
346	PositiveConstraint isPositive() {
347	return PositiveConstraint();
348	}
349
350	NonPositiveConstraint isNonPositive() {
351	return NonPositiveConstraint();
352	}
353
354	NegativeConstraint isNegative() {
355	return NegativeConstraint();
356	}
357
358	NonNegativeConstraint isNonNegative() {
359	return NonNegativeConstraint();
360	}
361
362	template<typename T>
363	LessThanConstraint<T>isLessThan(T& v ) {
364	return LessThanConstraint<T>(v);
365	}
366
367	template<typename T>
368	LessThanOrEqualToConstraint<T> isLessThanOrEqualTo(T& v ) {
369	return ParamConstraintFacade<LessThanOrEqualToConstraint<T> >(v);
370	}
371
372	template<typename T>
373	EqualConstraint<T> isEqual(T& v ) {
374	return EqualConstraint<T>(v);
375	}
376
377	template<typename T>
378	GreaterThanConstraint<T> isGreaterThan(T& v ) {
379	return GreaterThanConstraint<T>(v);
380	}
381
382	template<typename T>
383	GreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(T& v ) {
384	return GreaterThanOrEqualTo<T>(v);
385	}
386
387	EqualIgnoreCaseConstraint isEqualIgnoreCase(std::string str) {
388	return EqualIgnoreCaseConstraint(str);
389	}
390
391	#endif