Changeset 1476


Ignore:
Timestamp:
06/23/08 11:44:56 (6 years ago)
Author:
jdsiiro
Message:

Type_Manager:

  • adding setDefaultForceExact() to allow the user to override whether to force_exact casts by default (default = true to conform with previous behavior)
    • this caused change in context_cast API.
    • context_cast is currently failing regression tests... looking into this.

Any:

  • minor API change (reference_same_data() -> references_same_data_as())
  • spelling correction
  • adding Any::Comparator for std::vector
    • this is a first step; additional STL comparators will be coming "soon"
Location:
utilib/trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • utilib/trunk/src/typemngr/utilib/Any.h

    r1475 r1476  
    211211          static_cast<void>(rhs); 
    212212          EXCEPTION_MNGR(any_not_comparable, "An object of type " 
    213                          << typeid(T).name() << " is within an Any that is being compared, but this type has not been registered as begin comparable."); 
     213                         << typeid(T).name() << " is within an Any that " 
     214                         "is being compared, but this type has not been " 
     215                         "registered as being comparable."); 
    214216          return false; 
    215217          } 
     
    219221          static_cast<void>(rhs); 
    220222          EXCEPTION_MNGR(any_not_comparable, "An object of type " 
    221                          << typeid(T).name() << " is within an Any that is being compared, but this type has not been registered as begin comparable."); 
     223                         << typeid(T).name() << " is within an Any that " 
     224                         "is being compared, but this type has not been " 
     225                         "registered as being comparable."); 
    222226          return false; 
    223227          } 
     
    672676 
    673677    /// Returns true if the rhs Any refers to the same Container 
    674     bool reference_same_data(const Any& rhs) const 
     678    bool references_same_data_as(const Any& rhs) const 
    675679      { return (( m_data != NULL ) && ( m_data == rhs.m_data )); } 
    676680 
     
    11801184 
    11811185 
    1182  
     1186//--------------------------------------------------------------------- 
     1187// Comparators (but not printers) for standard C++ STL classes 
     1188 
     1189namespace utilib { 
     1190 
     1191template<typename T> 
     1192class Any::Comparator<std::vector<T> >  
     1193{ 
     1194public: 
     1195   static bool isEqual(const std::vector<T>& lhs, const std::vector<T>& rhs) 
     1196   { 
     1197      typename std::vector<T>::const_iterator it1 = lhs.begin(); 
     1198      typename std::vector<T>::const_iterator it1_end = lhs.end(); 
     1199      typename std::vector<T>::const_iterator it2 = rhs.begin(); 
     1200      typename std::vector<T>::const_iterator it2_end = rhs.end(); 
     1201 
     1202      for( ; ( it1 != it1_end ) && ( it2 != it2_end ); ++it1, ++it2 ) 
     1203      { 
     1204         if ( ! Any::Comparator<T>::isEqual(*it1, *it2) ) 
     1205            return false; 
     1206      } 
     1207      return it1 == it1_end && it2 == it2_end; 
     1208   } 
     1209   static bool isLessThan(const std::vector<T>& lhs, const std::vector<T>& rhs) 
     1210   { 
     1211      typename std::vector<T>::const_iterator it1 = lhs.begin(); 
     1212      typename std::vector<T>::const_iterator it1_end = lhs.end(); 
     1213      typename std::vector<T>::const_iterator it2 = rhs.begin(); 
     1214      typename std::vector<T>::const_iterator it2_end = rhs.end(); 
     1215 
     1216      for( ; ( it1 != it1_end ) && ( it2 != it2_end ); ++it1, ++it2 ) 
     1217      { 
     1218         if ( Any::Comparator<T>::isLessThan(*it1, *it2) ) 
     1219            return true; 
     1220         if ( Any::Comparator<T>::isLessThan(*it2, *it1) ) 
     1221            return false; 
     1222      } 
     1223      return it1 == it1_end && it2 != it2_end; 
     1224   } 
     1225}; 
     1226 
     1227/* 
     1228We do NOT want to use the DefaultComparator because that will force ALL 
     1229types that are placed in a vector that is subsequently put into an Any 
     1230to support operator==() and operator<().  By re-defining the comparison 
     1231opperators for the STL classes, we can avoid this requirement. 
     1232 
     1233template<typename T> 
     1234class Any::Comparator<std::list<T> >  
     1235   : public Any::DefaultComparable<std::list<T> >  
     1236{}; 
     1237 
     1238template<typename T> 
     1239class Any::Comparator<std::deque<T> >  
     1240   : public Any::DefaultComparable<std::deque<T> >  
     1241{}; 
     1242 
     1243template<typename T> 
     1244class Any::Comparator<std::set<T> >  
     1245   : public Any::DefaultComparable<std::set<T> >  
     1246{}; 
     1247 
     1248template<typename T> 
     1249class Any::Comparator<std::multiset<T> >  
     1250   : public Any::DefaultComparable<std::multiset<T> >  
     1251{}; 
     1252 
     1253template<typename T, typename U> 
     1254class Any::Comparator<std::map<T,U> >  
     1255   : public Any::DefaultComparable<std::map<T,U> >  
     1256{}; 
     1257 
     1258template<typename T, typename U> 
     1259class Any::Comparator<std::multimap<T,U> >  
     1260   : public Any::DefaultComparable<std::multimap<T,U> >  
     1261{}; 
     1262*/ 
     1263} 
     1264 
     1265 
     1266 
     1267//--------------------------------------------------------------------- 
     1268 
     1269/// Provide generic output streaming for the Any class and Any derivatives 
    11831270std::ostream& operator<<( std::ostream& os,  
    11841271                          const utilib::AnyAntiCoercionWrapper& any ); 
  • utilib/trunk/src/typemngr/utilib/TypeManager.cpp

    r1474 r1476  
    170170    m_ctxTableRebuildNeeded(true), 
    171171    m_throwErrors(true), 
    172     m_throwWarnings(false) 
     172    m_throwWarnings(false), 
     173    m_forceExact(true) 
    173174  { 
    174175  // casts for static_casting between types 
  • utilib/trunk/src/typemngr/utilib/TypeManager.h

    r1474 r1476  
    191191 *  chain is available, it will then follow an inexact chain (unless the 
    192192 *  force_exact parameter to lexical_cast is set to true, in which case 
    193  *  the cast fails and an error is returned). 
     193 *  the cast fails and an error is returned).  If no value is provided 
     194 *  for the force_exact parameter, the Type_Manager will use its 
     195 *  internal default (which defaults to true, but may be overridden 
     196 *  through the setDefaultForceExact() method). 
    194197 * 
    195198 *  <B>Context casts</B> support modeling extensions to the cast system. 
     
    237240    int lastError() const 
    238241      { return m_lastError; } 
    239     /// set whether Errors generate exceptions 
     242    /// set whether Errors generate exceptions [default = true] 
    240243    void setErrorExceptions(bool value) 
    241244      { m_throwErrors = value; } 
    242     /// set whether Warnings generate exceptions 
     245    /// set whether Warnings generate exceptions [default = false] 
    243246    void setWarningExceptions(bool value) 
    244247      { m_throwWarnings = value; } 
     248    /// set default value for force_exact [default = true] 
     249    void setDefaultForceExact(bool value) 
     250      { m_forceExact = value; } 
    245251 
    246252    /// Perform a lexical_cast, converting src to the toType 
    247253    int lexical_cast( const Any& src, Any &dest, const std::type_info& toType,  
    248                       const bool force_exact = true ); 
     254                      const bool force_exact ); 
     255    /// Perform a lexical_cast, converting src to the toType 
     256    int lexical_cast( const Any& src, Any &dest, const std::type_info& toType)  
     257      { return lexical_cast(src, dest, toType, m_forceExact); } 
     258 
    249259    /// Convenience function for those too lazy to declare local Any's ;-) 
    250260    /** Ideally, I would do explicit specializations for Any dests, but 
     
    254264    template<typename TYPE> 
    255265    int lexical_cast( const Any& src, TYPE &dest,  
    256                       const bool force_exact = true ) 
     266                      const bool force_exact ) 
    257267      { 
    258268      type_t dest_type = getMainType(typeid(TYPE)); 
     
    275285      return lexical_cast(src, tmp, typeid(TYPE), force_exact); 
    276286      } 
     287    /// Convenience function for those too lazy to declare local Any's ;-) 
     288    template<typename TYPE> 
     289    int lexical_cast( const Any& src, TYPE &dest ) 
     290      { return lexical_cast<TYPE>(src, dest, m_forceExact); } 
    277291 
    278292    /// Delete all registered casts and reset the cast table 
     
    288302    bool lexical_castable( const std::type_info& srcType,  
    289303                           const std::type_info& destType, 
    290                            bool force_exact = true ); 
     304                           bool force_exact ); 
     305    /// returns true if cast path exists 
     306    bool lexical_castable( const std::type_info& srcType,  
     307                           const std::type_info& destType ) 
     308      { return lexical_castable(srcType, destType, m_forceExact); } 
    291309 
    292310    /// returns true if cast path exists (plus the cast length and "exactness") 
     
    313331                             const context_id_type fromContext,  
    314332                             const context_id_type toContext,  
    315                              const bool force_exact = true ) 
     333                             const std::type_info& toType = typeid(void) ) 
    316334      { return context_cast_impl( src, dest, fromContext, toContext,  
    317                                   force_exact, false, typeid(void) ); } 
    318     /// Perform a context_cast (context IDs), returning a "toType" result 
     335                                  m_forceExact, toType == typeid(void),  
     336                                  toType ); } 
     337    /// Perform a context_cast (context IDs), specifying force_exact 
    319338    inline int context_cast( const Any src,  
    320339                             Any &dest,  
    321340                             const context_id_type fromContext,  
    322341                             const context_id_type toContext,  
    323                              const std::type_info& toType,  
    324                              const bool force_exact = true ) 
     342                             const bool force_exact, 
     343                             const std::type_info& toType = typeid(void) ) 
    325344      { return context_cast_impl( src, dest, fromContext, toContext,  
    326                                   force_exact, true, toType ); } 
     345                                  force_exact, toType == typeid(void),  
     346                                  toType ); } 
    327347    /// Perform a context_cast (context names) 
    328348    inline int context_cast( const Any src,  
     
    330350                             const std::string &fromContext,  
    331351                             const std::string &toContext,  
    332                              const bool force_exact = true ) 
     352                             const std::type_info& toType = typeid(void) ) 
    333353      { return context_cast_impl( src, dest,  
    334354                                  contextID(fromContext), contextID(toContext), 
    335                                   force_exact, false, typeid(void) ); } 
    336     /// Perform a context_cast (context names), returning a "toType" result 
     355                                  m_forceExact, toType == typeid(void),  
     356                                  toType ); } 
     357    /// Perform a context_cast (context names), specifying force_exact 
    337358    inline int context_cast( const Any src,  
    338359                             Any &dest,  
    339360                             const std::string &fromContext,  
    340361                             const std::string &toContext,  
    341                              const std::type_info& toType,  
    342                              const bool force_exact = true ) 
     362                             const bool force_exact, 
     363                             const std::type_info& toType = typeid(void) ) 
    343364      { return context_cast_impl( src, dest,  
    344365                                  contextID(fromContext), contextID(toContext), 
    345                                   force_exact, true, toType ); } 
     366                                  force_exact, toType == typeid(void),  
     367                                  toType ); } 
    346368 
    347369    /// Convenience function for those too lazy to declare local Any's ;-) 
     
    350372                             const context_id_type fromContext,  
    351373                             const context_id_type toContext,  
    352                              const bool force_exact = true ) 
     374                             const bool force_exact ) 
    353375      { 
    354376      Any tmp(dest, true, true); 
     
    359381    template<typename TYPE> 
    360382    inline int context_cast( const Any src, TYPE &dest, 
     383                             const context_id_type fromContext,  
     384                             const context_id_type toContext ) 
     385      { return context_cast<TYPE>( src, dest, fromContext, toContext,  
     386                                   m_forceExact, true, typeid(TYPE) ); } 
     387    /// Convenience function for those too lazy to declare local Any's ;-) 
     388    template<typename TYPE> 
     389    inline int context_cast( const Any src, TYPE &dest, 
    361390                             const std::string fromContext,  
    362391                             const std::string toContext,  
    363                              const bool force_exact = true ) 
    364       { return context_cast( src, dest,  
    365                              contextID(fromContext), contextID(toContext), 
    366                              force_exact ); } 
     392                             const bool force_exact ) 
     393      { return context_cast<TYPE>( src, dest, contextID(fromContext),  
     394                                   contextID(toContext), 
     395                                   force_exact ); } 
     396    /// Convenience function for those too lazy to declare local Any's ;-) 
     397    template<typename TYPE> 
     398    inline int context_cast( const Any src, TYPE &dest, 
     399                             const std::string fromContext,  
     400                             const std::string toContext ) 
     401      { return context_cast<TYPE>( src, dest, fromContext, toContext,  
     402                                   m_forceExact ); } 
    367403 
    368404 
     
    558594    bool m_throwErrors;    ///< if true, errors will generate exceptions 
    559595    bool m_throwWarnings;  ///< if true, warnings will generate exceptions 
    560  
     596    bool m_forceExact;     ///< default value for cast's force_exact parameter 
    561597 
    562598    /// Perform a context_cast, possibly returning the result as a toType 
  • utilib/trunk/test/any.cpp

    r1447 r1476  
    309309     Any tmp3(j, true); 
    310310     Any tmp4(d, true); 
    311      cout << "  test i ref == i:  " << tmp1.reference_same_data(tmp1a) << endl; 
    312      cout << "  test i ref == &i: " << tmp1.reference_same_data(tmp2) << endl; 
     311     cout << "  test i ref == i:  " << tmp1.references_same_data_as(tmp1a) 
     312          << endl; 
     313     cout << "  test i ref == &i: " << tmp1.references_same_data_as(tmp2) 
     314          << endl; 
    313315     cout << "  test i == i:  " << (tmp1 == tmp1a) << endl; 
    314316     cout << "  test i == &i: " << (tmp1 == tmp2) << endl; 
  • utilib/trunk/test/typeManager.cpp

    r1438 r1476  
    4646do { \ 
    4747  int ans = TypeManager()->context_cast( src, dest, SRC, DEST, \ 
    48                                          typeid(D_TYPE), EXACT ); \ 
     48                                         EXACT, typeid(D_TYPE));        \ 
    4949  OUT << "result[" << NUM << "]: " << ans;  \ 
    5050  printSTL<S_TYPE >(QUOTE(S_TYPE), src);  \ 
     
    298298  src = (double)7.75; 
    299299  OUT << "result[6]: " << TypeManager()->context_cast 
    300       (src, dest, "Context A", "Context C", typeid(vector<double>), false); 
     300     (src, dest, "Context A", "Context C", false, typeid(vector<double>)); 
    301301  OUT << endl << "   double == " << src.expose<double>(); 
    302302  printSTL<vector<double> >("vector<double>", dest); 
     
    304304 
    305305  OUT << "result[7]: " << TypeManager()->context_cast 
    306       (src, dest, "Context A", "Context C", typeid(vector<double>), true); 
     306     (src, dest, "Context A", "Context C", true, typeid(vector<double>)); 
    307307  OUT << endl << "   double == " << src.expose<double>(); 
    308308  printSTL<vector<double> >("vector<double>", dest); 
Note: See TracChangeset for help on using the changeset viewer.