NumericFilter.h

Go to the documentation of this file.

#ifndef CARMA_DBMS_NUMERICFILTER_H
#define CARMA_DBMS_NUMERICFILTER_H

#include <string>
#include <sstream>
#include <typeinfo>
#include <limits>

#include "carma/dbms/filter/OneComponentFilter.h"
#include "carma/util/CommonExceptions.h"
#include "carma/util/compileTimeCheck.h"

namespace carma {
namespace dbms {

template < typename T >
class NumericFilter : public OneComponentFilter {
    public:
        typedef enum {
            GREATER_THAN,
            GREATER_THAN_OR_EQUAL_TO,
            EQUAL_TO,
            LESS_THAN,
            LESS_THAN_OR_EQUAL_TO
        } SearchType;
    
        NumericFilter( T value, SearchType searchType );
    
        virtual ~NumericFilter( );
    
        T getValue( ) const;
    
        SearchType getSearchType( ) const;
    
        virtual ::std::string
        toString( const ::std::string & tableName = "",
                  const ::std::string & columnName = "" ) const;

        virtual ::std::string name( ) const;
    
    protected:
        T                value_;
        const SearchType searchType_;
};


}  // namespace carma::dbms
}  // namespace carma


template< typename T >
carma::dbms::NumericFilter< T >::NumericFilter( const T          value,
                                                const SearchType searchType ) :
value_( value ),
searchType_(searchType ) {
    // This line prevents client code instantiating this
    // templated class using a non-numeric typename T
    
    util::compileTimeCheck< ::std::numeric_limits< T >::is_specialized >( );
}


template< typename T >
carma::dbms::NumericFilter< T >::~NumericFilter( ) {
}


template< typename T >
T
carma::dbms::NumericFilter< T >::getValue( ) const {
    return value_;
}


template< typename T >
typename carma::dbms::NumericFilter< T >::SearchType
carma::dbms::NumericFilter< T >::getSearchType( ) const {
    return searchType_;
}


template< typename T >
::std::string
carma::dbms::NumericFilter< T >::toString(
    const ::std::string & tableName,
    const ::std::string & columnName ) const
{
    ::std::ostringstream ss;
    
    ss << fullyQualifiedColumnName_( tableName, columnName );
    
    switch ( searchType_ ) {
        case GREATER_THAN:              ss << " > ";   break;
        case GREATER_THAN_OR_EQUAL_TO:  ss << " >= ";  break;
        case EQUAL_TO:                  ss << " = ";   break;
        case LESS_THAN:                 ss << " < ";   break;
        case LESS_THAN_OR_EQUAL_TO:     ss << " <= ";  break;
        
        default:
            {
                ::std::stringstream emsg;
                emsg << "Unhandled searchType value " << searchType_;
                throw CARMA_ERROR(emsg.str());
            }
            break;
    }

    ss << value_;

    return ss.str();
}


template< typename T >
::std::string
carma::dbms::NumericFilter< T >::name( ) const {
    return "NumericFilter<>";
}


#endif