src/utils/Predicate.hpp

//  Boost string_algo library classification.hpp header file  ---------------------------//

//  Copyright Pavol Droba 2002-2003. Use, modification and
//  distribution is subject to the Boost Software License, Version
//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for updates, documentation, and revision history.
 #ifndef UTILS_PREDICATE_HPP
 #define UTILS_PREDICATE_HPP
#include <locale>


#if defined(__SUNPRO_CC)
#  define USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0))
#else
#  define USE_FACET(Type, loc) std::use_facet< Type >(loc)
#endif

namespace OpenMD {

template<typename Derived>
struct PredFacade{};

struct CharClassification: public PredFacade<CharClassification> {

    CharClassification(std::ctype_base::mask type, std::locale const & loc = std::locale()) :
        type_(type), loc_(loc) {}

    template<typename CharT>
    bool operator()( CharT c ) const {
        return USE_FACET(std::ctype<CharT>, loc_).is( type_, c );
    }

    private:
    const std::ctype_base::mask type_;
    const std::locale loc_;
};

template<typename CharT>
struct FromRangeFunctor : public PredFacade< FromRangeFunctor<CharT> > {

    FromRangeFunctor( CharT from, CharT to ) : from_(from), to_(to) {}
    
    template<typename Char2T>
    bool operator()( Char2T c ) const {
        return ( from_ <= c ) && ( c <= to_ ); 
    }

private:
    CharT from_;
    CharT to_;
};

template<typename Pred1T, typename Pred2T>
struct PredAndFunctor : public PredFacade< PredAndFunctor<Pred1T,Pred2T> > {
public:

    PredAndFunctor( Pred1T pred1, Pred2T pred2 ) : pred1_(pred1), pred2_(pred2) {}

    template<typename CharT>
    bool operator()( CharT c ) const {
        return pred1_(c) && pred2_(c);
    }

private:
    Pred1T pred1_;
    Pred2T pred2_;
};

template<typename Pred1T, typename Pred2T>
struct PredOrFunctor : public PredFacade< PredOrFunctor<Pred1T,Pred2T> > {
public:

    PredOrFunctor( Pred1T pred1, Pred2T pred2 ) : pred1_(pred1), pred2_(pred2) {}

    template<typename CharT>
    bool operator()( CharT c ) const {
        return pred1_(c) || pred2_(c);
    }

private:
    Pred1T pred1_;
    Pred2T pred2_;
};

template< typename PredT >
struct PredNotFunctor : public PredFacade< PredNotFunctor<PredT> > {
public:

    PredNotFunctor( PredT pred ) : pred_(pred) {}

    template<typename CharT>
    bool operator()( CharT c ) const {
        return !pred_(c);
    }

private:
    PredT pred_;
};
       
 inline CharClassification isSpace(const std::locale& loc=std::locale()){
    return CharClassification(std::ctype_base::space, loc);
 }

 inline CharClassification isAlnum(const std::locale& loc=std::locale()){
    return CharClassification(std::ctype_base::alnum, loc);
 }

 inline CharClassification isAlpha(const std::locale& loc=std::locale()){
    return CharClassification(std::ctype_base::alpha, loc);
 }

inline CharClassification isCntrl(const std::locale& loc=std::locale()) {
    return CharClassification(std::ctype_base::cntrl, loc);
}

inline CharClassification isDigit(const std::locale& loc=std::locale()) {
    return CharClassification(std::ctype_base::digit, loc);
}

inline CharClassification isGraph(const std::locale& loc=std::locale()) {
    return CharClassification(std::ctype_base::graph, loc);
}

inline CharClassification isLower(const std::locale& loc=std::locale()) {
    return CharClassification(std::ctype_base::lower, loc);
}

inline CharClassification isPrint(const std::locale& loc=std::locale()) {
    return CharClassification(std::ctype_base::print, loc);
}

inline CharClassification isPunct(const std::locale& loc=std::locale()) {
    return CharClassification(std::ctype_base::punct, loc);
}      

inline CharClassification isUpper(const std::locale& loc=std::locale()) {
    return CharClassification(std::ctype_base::upper, loc);
}    

inline CharClassification isXDigit(const std::locale& loc=std::locale()) {
    return CharClassification(std::ctype_base::xdigit, loc);
} 


template<typename CharT>
inline FromRangeFunctor<CharT> isFromRange(CharT from, CharT to) {
    return FromRangeFunctor<CharT>(from, to); 
}

template<typename Pred1T, typename Pred2T>
inline PredAndFunctor<Pred1T, Pred2T>
operator&&(const PredFacade<Pred1T>& Pred1, const PredFacade<Pred2T>& Pred2) {    
    // Doing the static_cast with the pointer instead of the reference
    // is a workaround for some compilers which have problems with
    // static_cast's of template references, i.e. CW8. /grafik/
    return PredAndFunctor<Pred1T,Pred2T>(
        *static_cast<const Pred1T*>(&Pred1), 
        *static_cast<const Pred2T*>(&Pred2) );
}


template<typename Pred1T, typename Pred2T>
inline PredOrFunctor<Pred1T, Pred2T> 
operator||( const PredFacade<Pred1T>& Pred1, const PredFacade<Pred2T>& Pred2 ) {    
    // Doing the static_cast with the pointer instead of the reference
    // is a workaround for some compilers which have problems with
    // static_cast's of template references, i.e. CW8. /grafik/
    return PredOrFunctor<Pred1T,Pred2T>(
        *static_cast<const Pred1T*>(&Pred1), 
        *static_cast<const Pred2T*>(&Pred2));
}

template<typename PredT>
inline PredNotFunctor<PredT>
operator!( const PredFacade<PredT>& Pred ) {
    // Doing the static_cast with the pointer instead of the reference
    // is a workaround for some compilers which have problems with
    // static_cast's of template references, i.e. CW8. /grafik/
    return PredNotFunctor<PredT>(*static_cast<const PredT*>(&Pred)); 
}

}

 #endif 
Revision:	1465
Committed:	Fri Jul 9 23:08:25 2010 UTC (14 years, 9 months ago) by chuckv
File size:	5595 byte(s)
Log Message:	Creating busticated version of OpenMD
#	User	Rev	Content
1	tim	515	// Boost string_algo library classification.hpp header file ---------------------------//
2
3			// Copyright Pavol Droba 2002-2003. Use, modification and
4			// distribution is subject to the Boost Software License, Version
5			// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
6			// http://www.boost.org/LICENSE_1_0.txt)
7
8			// See http://www.boost.org for updates, documentation, and revision history.
9			#ifndef UTILS_PREDICATE_HPP
10			#define UTILS_PREDICATE_HPP
11			#include <locale>
12
13	tim	816
14
15			#if defined(__SUNPRO_CC)
16			# define USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0))
17			#else
18			# define USE_FACET(Type, loc) std::use_facet< Type >(loc)
19			#endif
20
21	gezelter	1390	namespace OpenMD {
22	tim	515
23			template<typename Derived>
24			struct PredFacade{};
25
26			struct CharClassification: public PredFacade<CharClassification> {
27
28			CharClassification(std::ctype_base::mask type, std::locale const & loc = std::locale()) :
29			type_(type), loc_(loc) {}
30
31			template<typename CharT>
32			bool operator()( CharT c ) const {
33	tim	816	return USE_FACET(std::ctype<CharT>, loc_).is( type_, c );
34	tim	515	}
35
36			private:
37			const std::ctype_base::mask type_;
38			const std::locale loc_;
39			};
40
41			template<typename CharT>
42			struct FromRangeFunctor : public PredFacade< FromRangeFunctor<CharT> > {
43
44			FromRangeFunctor( CharT from, CharT to ) : from_(from), to_(to) {}
45
46			template<typename Char2T>
47			bool operator()( Char2T c ) const {
48			return ( from_ <= c ) && ( c <= to_ );
49			}
50
51			private:
52			CharT from_;
53			CharT to_;
54			};
55
56			template<typename Pred1T, typename Pred2T>
57			struct PredAndFunctor : public PredFacade< PredAndFunctor<Pred1T,Pred2T> > {
58			public:
59
60			PredAndFunctor( Pred1T pred1, Pred2T pred2 ) : pred1_(pred1), pred2_(pred2) {}
61
62			template<typename CharT>
63			bool operator()( CharT c ) const {
64			return pred1_(c) && pred2_(c);
65			}
66
67			private:
68			Pred1T pred1_;
69			Pred2T pred2_;
70			};
71
72			template<typename Pred1T, typename Pred2T>
73			struct PredOrFunctor : public PredFacade< PredOrFunctor<Pred1T,Pred2T> > {
74			public:
75
76			PredOrFunctor( Pred1T pred1, Pred2T pred2 ) : pred1_(pred1), pred2_(pred2) {}
77
78			template<typename CharT>
79			bool operator()( CharT c ) const {
80			return pred1_(c) \|\| pred2_(c);
81			}
82
83			private:
84			Pred1T pred1_;
85			Pred2T pred2_;
86			};
87
88			template< typename PredT >
89			struct PredNotFunctor : public PredFacade< PredNotFunctor<PredT> > {
90			public:
91
92			PredNotFunctor( PredT pred ) : pred_(pred) {}
93
94			template<typename CharT>
95			bool operator()( CharT c ) const {
96			return !pred_(c);
97			}
98
99			private:
100			PredT pred_;
101			};
102
103			inline CharClassification isSpace(const std::locale& loc=std::locale()){
104			return CharClassification(std::ctype_base::space, loc);
105			}
106
107			inline CharClassification isAlnum(const std::locale& loc=std::locale()){
108			return CharClassification(std::ctype_base::alnum, loc);
109			}
110
111			inline CharClassification isAlpha(const std::locale& loc=std::locale()){
112			return CharClassification(std::ctype_base::alpha, loc);
113			}
114
115			inline CharClassification isCntrl(const std::locale& loc=std::locale()) {
116			return CharClassification(std::ctype_base::cntrl, loc);
117			}
118
119			inline CharClassification isDigit(const std::locale& loc=std::locale()) {
120			return CharClassification(std::ctype_base::digit, loc);
121			}
122
123			inline CharClassification isGraph(const std::locale& loc=std::locale()) {
124			return CharClassification(std::ctype_base::graph, loc);
125			}
126
127			inline CharClassification isLower(const std::locale& loc=std::locale()) {
128			return CharClassification(std::ctype_base::lower, loc);
129			}
130
131			inline CharClassification isPrint(const std::locale& loc=std::locale()) {
132			return CharClassification(std::ctype_base::print, loc);
133			}
134
135			inline CharClassification isPunct(const std::locale& loc=std::locale()) {
136			return CharClassification(std::ctype_base::punct, loc);
137			}
138
139			inline CharClassification isUpper(const std::locale& loc=std::locale()) {
140			return CharClassification(std::ctype_base::upper, loc);
141			}
142
143			inline CharClassification isXDigit(const std::locale& loc=std::locale()) {
144			return CharClassification(std::ctype_base::xdigit, loc);
145			}
146
147
148			template<typename CharT>
149			inline FromRangeFunctor<CharT> isFromRange(CharT from, CharT to) {
150			return FromRangeFunctor<CharT>(from, to);
151			}
152
153			template<typename Pred1T, typename Pred2T>
154			inline PredAndFunctor<Pred1T, Pred2T>
155			operator&&(const PredFacade<Pred1T>& Pred1, const PredFacade<Pred2T>& Pred2) {
156			// Doing the static_cast with the pointer instead of the reference
157			// is a workaround for some compilers which have problems with
158			// static_cast's of template references, i.e. CW8. /grafik/
159			return PredAndFunctor<Pred1T,Pred2T>(
160			static_cast<const Pred1T>(&Pred1),
161			static_cast<const Pred2T>(&Pred2) );
162			}
163
164
165			template<typename Pred1T, typename Pred2T>
166			inline PredOrFunctor<Pred1T, Pred2T>
167			operator\|\|( const PredFacade<Pred1T>& Pred1, const PredFacade<Pred2T>& Pred2 ) {
168			// Doing the static_cast with the pointer instead of the reference
169			// is a workaround for some compilers which have problems with
170			// static_cast's of template references, i.e. CW8. /grafik/
171	chuckv	516	return PredOrFunctor<Pred1T,Pred2T>(
172	tim	515	static_cast<const Pred1T>(&Pred1),
173			static_cast<const Pred2T>(&Pred2));
174			}
175
176			template<typename PredT>
177			inline PredNotFunctor<PredT>
178			operator!( const PredFacade<PredT>& Pred ) {
179			// Doing the static_cast with the pointer instead of the reference
180			// is a workaround for some compilers which have problems with
181			// static_cast's of template references, i.e. CW8. /grafik/
182			return PredNotFunctor<PredT>(static_cast<const PredT>(&Pred));
183			}
184
185			}
186
187			#endif