/*************************************************************************** * * rw_value.h - defines a User Defined Class type and User Defined POD type * * $Id: rw_value.h 510970 2007-02-23 14:57:45Z faridz $ * *************************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or * implied. See the License for the specific language governing * permissions and limitations under the License. * * Copyright 1994-2005 Rogue Wave Software. * **************************************************************************/ #ifndef RW_VALUE_H_INCLUDED #define RW_VALUE_H_INCLUDED #include #include // 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