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:	1790
Committed:	Thu Aug 30 17:18:22 2012 UTC (12 years, 8 months ago) by gezelter
File size:	5596 byte(s)
Log Message:	Various Windows compilation fixes
#	Content
1	// 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
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	namespace OpenMD {
22
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	return USE_FACET(std::ctype<CharT>, loc_).is( type_, c );
34	}
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	return PredOrFunctor<Pred1T,Pred2T>(
172	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