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"
File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 
Note: See TracChangeset for help on using the changeset viewer.