| [33d0af] | 1 | /*
 | 
|---|
 | 2 |  * Ops_Validator_impl.hpp
 | 
|---|
 | 3 |  *
 | 
|---|
 | 4 |  *  Created on: May 9, 2012
 | 
|---|
 | 5 |  *      Author: ankele
 | 
|---|
 | 6 |  */
 | 
|---|
 | 7 | 
 | 
|---|
 | 8 | #ifndef OPS_VALIDATOR_IMPL_HPP_
 | 
|---|
 | 9 | #define OPS_VALIDATOR_IMPL_HPP_
 | 
|---|
 | 10 | 
 | 
|---|
 | 11 | 
 | 
|---|
 | 12 | 
 | 
|---|
 | 13 | // include config.h
 | 
|---|
 | 14 | #ifdef HAVE_CONFIG_H
 | 
|---|
 | 15 | #include <config.h>
 | 
|---|
 | 16 | #endif
 | 
|---|
 | 17 | 
 | 
|---|
 | 18 | #include "Validator.hpp"
 | 
|---|
 | 19 | 
 | 
|---|
 | 20 | /** Logical AND composition of two Validators.
 | 
|---|
 | 21 |  *
 | 
|---|
 | 22 |  */
 | 
|---|
 | 23 | template <class T>
 | 
|---|
 | 24 | class And_Validator : public Validator<T>
 | 
|---|
 | 25 | {
 | 
|---|
 | 26 | public:
 | 
|---|
 | 27 |   And_Validator(const Validator<T> &_a, const Validator<T> &_b) :
 | 
|---|
 | 28 |     a(_a.clone()), b(_b.clone())
 | 
|---|
 | 29 |   {}
 | 
|---|
 | 30 |   virtual ~And_Validator()
 | 
|---|
 | 31 |   {
 | 
|---|
 | 32 |     delete(a);
 | 
|---|
 | 33 |     delete(b);
 | 
|---|
 | 34 |   }
 | 
|---|
 | 35 | 
 | 
|---|
 | 36 |   bool isValid(const T & _value) const {
 | 
|---|
 | 37 |     return (*a)(_value) && (*b)(_value);
 | 
|---|
 | 38 |   }
 | 
|---|
 | 39 | 
 | 
|---|
 | 40 |   Validator<T>* clone() const
 | 
|---|
 | 41 |   { return new And_Validator(*a, *b);  }
 | 
|---|
 | 42 | 
 | 
|---|
 | 43 |   // comparator
 | 
|---|
 | 44 |   bool operator==(const Validator<T> &_instance) const
 | 
|---|
 | 45 |   {
 | 
|---|
 | 46 |     const And_Validator<T> *inst = dynamic_cast<const And_Validator<T> *>(&_instance);
 | 
|---|
 | 47 |     if (inst)
 | 
|---|
 | 48 |       return (*a == *inst->a) && (*b == *inst->b);
 | 
|---|
 | 49 |     return false;
 | 
|---|
 | 50 |   }
 | 
|---|
 | 51 | 
 | 
|---|
 | 52 | private:
 | 
|---|
 | 53 |   Validator<T> *a;
 | 
|---|
 | 54 |   Validator<T> *b;
 | 
|---|
 | 55 | };
 | 
|---|
 | 56 | 
 | 
|---|
 | 57 | /** Logical OR composition of two Validators.
 | 
|---|
 | 58 |  *
 | 
|---|
 | 59 |  */
 | 
|---|
 | 60 | template <class T>
 | 
|---|
 | 61 | class Or_Validator : public Validator<T>
 | 
|---|
 | 62 | {
 | 
|---|
 | 63 | public:
 | 
|---|
 | 64 |   Or_Validator(const Validator<T> &_a, const Validator<T> &_b) :
 | 
|---|
 | 65 |     a(_a.clone()), b(_b.clone())
 | 
|---|
 | 66 |   {}
 | 
|---|
 | 67 |   virtual ~Or_Validator()
 | 
|---|
 | 68 |   {
 | 
|---|
 | 69 |     delete(a);
 | 
|---|
 | 70 |     delete(b);
 | 
|---|
 | 71 |   }
 | 
|---|
 | 72 | 
 | 
|---|
 | 73 |   bool isValid(const T & _value) const {
 | 
|---|
 | 74 |     return (*a)(_value) || (*b)(_value);
 | 
|---|
 | 75 |   }
 | 
|---|
 | 76 | 
 | 
|---|
 | 77 |   Validator<T>* clone() const
 | 
|---|
 | 78 |   { return new Or_Validator(*a, *b);  }
 | 
|---|
 | 79 | 
 | 
|---|
 | 80 |   // comparator
 | 
|---|
 | 81 |   bool operator==(const Validator<T> &_instance) const
 | 
|---|
 | 82 |   {
 | 
|---|
 | 83 |     const Or_Validator<T> *inst = dynamic_cast<const Or_Validator<T> *>(&_instance);
 | 
|---|
 | 84 |     if (inst)
 | 
|---|
 | 85 |       return (*a == *inst->a) && (*b == *inst->b);
 | 
|---|
 | 86 |     return false;
 | 
|---|
 | 87 |   }
 | 
|---|
 | 88 | 
 | 
|---|
 | 89 | private:
 | 
|---|
 | 90 |   Validator<T> *a;
 | 
|---|
 | 91 |   Validator<T> *b;
 | 
|---|
 | 92 | };
 | 
|---|
 | 93 | 
 | 
|---|
 | 94 | /** Logical NOT composition of a Validator.
 | 
|---|
 | 95 |  *
 | 
|---|
 | 96 |  */
 | 
|---|
 | 97 | template <class T>
 | 
|---|
 | 98 | class Not_Validator : public Validator<T>
 | 
|---|
 | 99 | {
 | 
|---|
 | 100 | public:
 | 
|---|
 | 101 |   Not_Validator(const Validator<T> &_a) :
 | 
|---|
 | 102 |     a(_a.clone())
 | 
|---|
 | 103 |   {}
 | 
|---|
 | 104 |   virtual ~Not_Validator()
 | 
|---|
 | 105 |   {
 | 
|---|
 | 106 |     delete(a);
 | 
|---|
 | 107 |   }
 | 
|---|
 | 108 | 
 | 
|---|
 | 109 |   bool isValid(const T & _value) const {
 | 
|---|
 | 110 |     return !(*a)(_value);
 | 
|---|
 | 111 |   }
 | 
|---|
 | 112 | 
 | 
|---|
 | 113 |   Validator<T>* clone() const
 | 
|---|
 | 114 |   { return new Not_Validator(*a);  }
 | 
|---|
 | 115 | 
 | 
|---|
 | 116 |   // comparator
 | 
|---|
 | 117 |   bool operator==(const Validator<T> &_instance) const
 | 
|---|
 | 118 |   {
 | 
|---|
 | 119 |     const Not_Validator<T> *inst = dynamic_cast<const Not_Validator<T> *>(&_instance);
 | 
|---|
 | 120 |     if (inst)
 | 
|---|
 | 121 |       return (*a == *inst->a);
 | 
|---|
 | 122 |     return false;
 | 
|---|
 | 123 |   }
 | 
|---|
 | 124 | 
 | 
|---|
 | 125 | private:
 | 
|---|
 | 126 |   Validator<T> *a;
 | 
|---|
 | 127 | };
 | 
|---|
 | 128 | 
 | 
|---|
 | 129 | 
 | 
|---|
 | 130 | 
 | 
|---|
 | 131 | template <class T>
 | 
|---|
 | 132 | And_Validator<T> operator&&(const Validator<T> &a, const Validator<T> &b)
 | 
|---|
 | 133 | {
 | 
|---|
 | 134 |   return And_Validator<T>(a, b);
 | 
|---|
 | 135 | }
 | 
|---|
 | 136 | 
 | 
|---|
 | 137 | template <class T>
 | 
|---|
 | 138 | Or_Validator<T> operator||(const Validator<T> &a, const Validator<T> &b)
 | 
|---|
 | 139 | {
 | 
|---|
 | 140 |   return Or_Validator<T>(a, b);
 | 
|---|
 | 141 | }
 | 
|---|
 | 142 | 
 | 
|---|
 | 143 | template <class T>
 | 
|---|
 | 144 | Not_Validator<T> operator!(const Validator<T> &a)
 | 
|---|
 | 145 | {
 | 
|---|
 | 146 |   return Not_Validator<T>(a);
 | 
|---|
 | 147 | }
 | 
|---|
 | 148 | 
 | 
|---|
 | 149 | 
 | 
|---|
 | 150 | #endif /* OPS_VALIDATOR_IMPL_HPP_ */
 | 
|---|