--- trunk/src/io/ParamConstraint.hpp	2005/10/17 19:24:02	678
+++ trunk/src/io/ParamConstraint.hpp	2005/11/16 23:10:02	749
@@ -44,7 +44,7 @@
 #include <sstream>
 #include "utils/CaseConversion.hpp"
 #include "utils/StringTokenizer.hpp"
-
+namespace oopse {
 /**
   * 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
@@ -331,61 +331,42 @@ operator !( const ParamConstraintFacade<ConsT>& cons )
 }
 
 
-NotEmptyConstraint isNotEmpty() {
-    return NotEmptyConstraint();
-}
-
-ZeroConstraint isZero() {
-    return ZeroConstraint();
-}
+NotEmptyConstraint isNotEmpty();
+ZeroConstraint isZero();
 
-ParamConstraintFacade<NonZeroConstraint> isNonZero() {
-    return ParamConstraintFacade<NonZeroConstraint>();
-}
+ParamConstraintFacade<NonZeroConstraint> isNonZero();
+PositiveConstraint isPositive();
+NonPositiveConstraint isNonPositive();
 
-PositiveConstraint isPositive() {
-    return PositiveConstraint();
-}
-
-NonPositiveConstraint isNonPositive() {
-    return NonPositiveConstraint();
-}
+NegativeConstraint isNegative();
 
-NegativeConstraint isNegative() {
-    return NegativeConstraint();
-}
+NonNegativeConstraint isNonNegative();
 
-NonNegativeConstraint isNonNegative() {
-    return NonNegativeConstraint();
-}
-
 template<typename T>
-LessThanConstraint<T>isLessThan(T& v ) {
+inline LessThanConstraint<T>isLessThan(T& v ) {
     return LessThanConstraint<T>(v);
 }
 
 template<typename T>
-LessThanOrEqualToConstraint<T> isLessThanOrEqualTo(T& v ) {
+inline LessThanOrEqualToConstraint<T> isLessThanOrEqualTo(T& v ) {
     return ParamConstraintFacade<LessThanOrEqualToConstraint<T> >(v);
 }
 
 template<typename T>
-EqualConstraint<T> isEqual(T& v ) {
+inline EqualConstraint<T> isEqual(T& v ) {
     return EqualConstraint<T>(v);
 }
 
 template<typename T>
-GreaterThanConstraint<T> isGreaterThan(T& v ) {
+inline GreaterThanConstraint<T> isGreaterThan(T& v ) {
     return GreaterThanConstraint<T>(v);
 }
 
 template<typename T>
-GreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(T& v ) {
+inline GreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(T& v ) {
     return GreaterThanOrEqualTo<T>(v);
 }
 
-EqualIgnoreCaseConstraint isEqualIgnoreCase(std::string str) {
-    return EqualIgnoreCaseConstraint(str);
+EqualIgnoreCaseConstraint isEqualIgnoreCase(std::string str);
 }
-
 #endif