rw_value.h

Go to the documentation of this file.

 
#ifndef RW_VALUE_H_INCLUDED
#define RW_VALUE_H_INCLUDED
 
#include <rw_testdefs.h>
#include <rw_alg_test.h>         // for conv_to_bool
 
 
struct UserData
{
    int       val_;       // object's value
};
 
 
struct _TEST_EXPORT UserPOD
{
    UserData data_;
 
    static UserPOD
    from_char (char c)
    {
        UserPOD x;
        x.data_.val_ = c;
        return x;
    }
 
    // construct an array of objects of type UserPOD each initialized
    // from the corresponding element of the character array
    // when the last argument is true and the character array
    // is not sorted in ascending order the function fails by
    // returning 0
    static UserPOD*
    from_char (const char*, _RWSTD_SIZE_T = _RWSTD_SIZE_MAX,
               bool = false);
 
    // returns a pointer to the first element in the sequence of UserClass
    // whose value is not equal to the corresponding element of
    // the character string or 0 when no such element exists
    static const UserPOD* mismatch (const UserPOD*, const char*,
                                    _RWSTD_SIZE_T /* len */ = _RWSTD_SIZE_MAX);
};
 
 
// objects of class UserClass maintain a count of their instances in existence,
// the number of defaut and copy ctor calls, assignment operators, and
// the number of calls to operator==() and operator<()
struct _TEST_EXPORT UserClass
{
    UserData   data_;
 
    const int  id_;        // a unique non-zero id of the object
    int        origin_;    // id of the original object that this
                           // is a (perhaps indirect) copy of (id_
                           // when this is the original)
    int        src_id_;    // id of the object that this is a direct
                           // copy of (id_ when this the original)
 
    // number of times the object has been copied into another object,
    // regardless of whether the operation threw an exception or not
    _RWSTD_SIZE_T n_copy_ctor_;
 
    // number of times the object's assignment operator has been invoked,
    // regardless of whether the operation threw an exception or not
    _RWSTD_SIZE_T n_op_assign_;
 
    // number of times the object's operator+=() has been invoked,
    // regardless of whether the operation threw an exception or not
    _RWSTD_SIZE_T n_op_plus_assign_;
 
    // number of times the object's operator-=() has been invoked,
    // regardless of whether the operation threw an exception or not
    _RWSTD_SIZE_T n_op_minus_assign_;
 
    // number of times the object's operator*=() has been invoked,
    // regardless of whether the operation threw an exception or not
    _RWSTD_SIZE_T n_op_times_assign_;
 
    // number of times the object's operator/=() has been invoked,
    // regardless of whether the operation threw an exception or not
    _RWSTD_SIZE_T n_op_div_assign_;
 
    // number of times the object's operator== was invoked
    // regardless of whether the operation threw an exception
    _RWSTD_SIZE_T n_op_eq_;
 
    // number of times the object's operator< was invoked
    // regardless of whether the operation threw an exception
    _RWSTD_SIZE_T n_op_lt_;
 
    static _RWSTD_SIZE_T count_;   // number of objects in existence (>= 0)
    static int id_gen_;            // generates a unique non-zero id
    static int (*gen_)();          // extern "C++" int (*)()
 
    static _RWSTD_SIZE_T n_total_def_ctor_;    // number of default ctor calls
    static _RWSTD_SIZE_T n_total_copy_ctor_;   // ... copy ctors ...
    static _RWSTD_SIZE_T n_total_dtor_;        // ... dtors ...
    static _RWSTD_SIZE_T n_total_op_assign_;   // ... assignment operators ...
    static _RWSTD_SIZE_T n_total_op_plus_assign_;    // ... operator+=
    static _RWSTD_SIZE_T n_total_op_minus_assign_;   // ... operator-=
    static _RWSTD_SIZE_T n_total_op_times_assign_;   // ... operator*=
    static _RWSTD_SIZE_T n_total_op_div_assign_;     // ... operator/=
    static _RWSTD_SIZE_T n_total_op_eq_;       // ... equality operators ...
    static _RWSTD_SIZE_T n_total_op_lt_;       // ... operators <= ...
 
    // classes thrown from the respective functions
    struct Exception { int id_; };
    struct DefCtor: Exception { };
    struct CopyCtor: Exception { };
    struct Dtor: Exception { };
    struct OpAssign: Exception { };
    struct OpPlusAssign: Exception { };
    struct OpMinusAssign: Exception { };
    struct OpTimesAssign: Exception { };
    struct OpDivAssign: Exception { };
    struct OpEq: Exception { };
    struct OpLt: Exception { };
 
    // throw object's `id' wrapped in the appropriate struct when the
    // corresponding n_total_xxx_ counter reaches the value pointed to
    // by the respective pointer below
    static _RWSTD_SIZE_T* def_ctor_throw_ptr_;
    static _RWSTD_SIZE_T* copy_ctor_throw_ptr_;
    static _RWSTD_SIZE_T* dtor_throw_ptr_;
    static _RWSTD_SIZE_T* op_assign_throw_ptr_;
    static _RWSTD_SIZE_T* op_plus_assign_throw_ptr_;
    static _RWSTD_SIZE_T* op_minus_assign_throw_ptr_;
    static _RWSTD_SIZE_T* op_times_assign_throw_ptr_;
    static _RWSTD_SIZE_T* op_div_assign_throw_ptr_;
    static _RWSTD_SIZE_T* op_eq_throw_ptr_;
    static _RWSTD_SIZE_T* op_lt_throw_ptr_;
 
    // objects to which the pointers above initally point
    static _RWSTD_SIZE_T def_ctor_throw_count_;
    static _RWSTD_SIZE_T copy_ctor_throw_count_;
    static _RWSTD_SIZE_T dtor_throw_count_;
    static _RWSTD_SIZE_T op_assign_throw_count_;
    static _RWSTD_SIZE_T op_plus_assign_throw_count_;
    static _RWSTD_SIZE_T op_minus_assign_throw_count_;
    static _RWSTD_SIZE_T op_times_assign_throw_count_;
    static _RWSTD_SIZE_T op_div_assign_throw_count_;
    static _RWSTD_SIZE_T op_eq_throw_count_;
    static _RWSTD_SIZE_T op_lt_throw_count_;
 
    UserClass ();
 
    UserClass (const UserClass&);
 
    ~UserClass ();
 
    UserClass& operator= (const UserClass&);
    UserClass& operator+= (const UserClass&);
    UserClass& operator-= (const UserClass&);
    UserClass& operator*= (const UserClass&);
    UserClass& operator/= (const UserClass&);
 
    bool operator== (const UserClass&) const;
    bool operator< (const UserClass&) const;
 
    // the following operators are not declared or defined in order
    // to detect any unwarranted assumptions made in algorithms
    //    bool operator!= (const UserClass &rhs) const;
    //    bool operator> (const UserClass &rhs) const;
    //    bool operator>= (const UserClass &rhs) const;
    //    bool operator<= (const UserClass &rhs) const;
    //    UserClass operator- () const;
    //    UserClass operator+ () const;
    
    bool
    is_count (_RWSTD_SIZE_T copy_ctor,
              _RWSTD_SIZE_T op_assign,
              _RWSTD_SIZE_T op_eq,
              _RWSTD_SIZE_T op_lt) const;
 
    static bool
    is_total (_RWSTD_SIZE_T count,
              _RWSTD_SIZE_T n_def_ctor,
              _RWSTD_SIZE_T n_copy_ctor,
              _RWSTD_SIZE_T n_op_assign,
              _RWSTD_SIZE_T n_op_eq,
              _RWSTD_SIZE_T n_op_lt);
 
    // returns a pointer to the first element in the sequence whose value
    // is less than the value of the immediately preceding element, or 0
    // when no such element exists
    static const UserClass*
    first_less (const UserClass*, _RWSTD_SIZE_T);
 
    static void reset_totals ();
 
    static UserClass
    from_char (char c)
    {
        UserClass x;
        x.data_.val_ = c;
        return x;
    }
 
    // construct an array of objects of type UserClass each initialized
    // from the corresponding element of the character array
    // when the last argument is true and the character array
    // is not sorted in ascending order the function fails by
    // returning 0
    static UserClass*
    from_char (const char*, _RWSTD_SIZE_T = _RWSTD_SIZE_MAX,
               bool = false);
 
    // returns -1 when less, 0 when same, or +1 when the array
    // of UserClass objects is greater than the character string
    static int compare (const UserClass*, const char*,
                        _RWSTD_SIZE_T = _RWSTD_SIZE_MAX);
    static int compare (const char*, const UserClass*,
                        _RWSTD_SIZE_T = _RWSTD_SIZE_MAX);
 
    // returns -1 when less, 0 when same, or +1 when the first
    // array of UserClass objects is greater than the second array
    static int compare (const UserClass*, const UserClass*, _RWSTD_SIZE_T);
 
    // returns a pointer to the first element in the sequence of UserClass
    // whose value is not equal to the corresponding element of
    // the character string or 0 when no such element exists
    static const UserClass* mismatch (const UserClass*, const char*,
                                      _RWSTD_SIZE_T);
 
    struct Less;
 
private:
 
    enum assign_op {
        op_assign, op_plus_assign, op_minus_assign,
        op_times_assign, op_div_assign
    };
 
    void assign (assign_op, const UserClass&);
};
 
 
struct _TEST_EXPORT UnaryPredicate
{
    // total number of times operator() was invoked
    static _RWSTD_SIZE_T n_total_op_fcall_;
 
    UnaryPredicate ();
 
    UnaryPredicate (const UnaryPredicate&);
 
    UnaryPredicate& operator= (const UnaryPredicate&);
 
    virtual ~UnaryPredicate ();
 
    virtual conv_to_bool operator()(const UserClass&) const;
};
 
 
struct _TEST_EXPORT BinaryPredicate
{
    // total number of times operator() was invoked
    static _RWSTD_SIZE_T n_total_op_fcall_;
 
    enum binary_op {
        op_equals,
        op_not_equals,
        op_less,
        op_less_equal,
        op_greater,
        op_greater_equal
    };
 
    BinaryPredicate (binary_op);
 
    virtual ~BinaryPredicate ();
 
    virtual conv_to_bool operator()(const UserClass&,
                                    const UserClass&) /* non-const */;
 
private:
 
    // not assignable
    void operator= (const BinaryPredicate&);
 
    binary_op op_;
};
 
 
struct UserClass::Less: BinaryPredicate
{
    // dummy arguments provided to prevent the class from being
    // default constructible and implicit conversion from int
    Less (int /* dummy */, int /* dummy */)
        : BinaryPredicate (BinaryPredicate::op_less) { /* no-op */ }
};
 
 
static const struct _TEST_EXPORT UserClassFmatInit {
    UserClassFmatInit ();
} _rw_user_class_fmat_init;
 
 
#endif   // RW_VALUE_H_INCLUDED