Re: C++ implementation question
"Dilip" <rdilipk@lycos.com> wrote in message
news:1174319505.063751.74880@e65g2000hsc.googlegroups.com...
I was wondering if you guys can help me out with a design issue I am
running into.
I have a class that needs to maintain a mapping between a table name
and its corresponding list of columns.
The column class is defined thusly:
struct Column
{
enum Type
{
BOOL = 1,
INT = 2,
FLOAT = 3
// etc. and so on
};
Type type(); // returns the type of the column
};
There is also an API that gives me the value of a column given a
column pointer. Its overloaded for various types like:
APIPtr->get(Column* c, <overloads_for_various_types>& colvalue);
/*
APIPtr->get(Column* c, int& value);
APIPtr->get(Column* c, char*& value);
// etc
*/
I went down this direction:
class TableHandler
{
std::map<std::string, std::vector<Column*> > Table2ColumnMap;
Table2ColumnMap table2Col_; // this map is set at construction time
public:
TableHandler()
{
Column* c1 = APIPtr->getColDetailsFromSomewhere("COLNAME1");
Column* c2 = APIPtr->getColDetailsFromSomewhere("COLNAME2");
Column* c3 = APIPtr->getColDetailsFromSomewhere("COLNAME3");
vector<Column*> colvec;
colvec.push_back(c1);
colvec.push_back(c2);
colvec.push_back(c3);
tale2Col_.insert(std::make_pair("TABLE1", colvec));
}
};
I was wondering if there is a way to write a method in TableHandler
that can give iteratively extract the values of all the columns given
a table name (using that APIPtr->get() thingy).
So I came all the way here:
void TableHandler::ExtractColValues(std::string const& tablename)
{
// 1. drill into map; 2. locate associated vector of columns
// 3. IT is at this point I am a little confused
}
As I noted in (3), each Column* already maintains an enum that is
indicative of its type. I want to write a clean mechanism to extract
the value of that column using APIPtr->get() and somehow using its
type. I just am not able to translate it into code.
Can someone point me in the right direction? Just a hint would be
appreciated -- I can expand it from there.
I just did it this way. I'm not saying if it's good or bad, it's just the
way I handled it.
class CField
{
public:
CField( const std::string& Name, const std::string Type, const bool /*
Null */, const bool /* PriKey */, const std::string& Default, const
std::string& /* Extra */);
void operator=( const std::string& Value ) { Value_ = Value; Set_ =
true; }
void operator=( const int& Value ) { Value_ = jml::StrmConvert( Value );
Set_ = true; }
void operator=( const unsigned int& Value ) { Value_ =
jml::StrmConvert( Value ); Set_ = true; }
void operator=( const bool& Value ) { Value_ = Value ? "true" : "false";
Set_ = true;}
void operator=( const short int& Value ) { Value_ = jml::StrmConvert(
Value ); Set_ = true; }
void operator=( const unsigned short int& Value ) { Value_ =
jml::StrmConvert( Value ); Set_ = true; }
void operator=( const float& Value ) { Value_ = jml::StrmConvert(
Value ); Set_ = true; }
void operator=( const double& Value ) { Value_ = jml::StrmConvert(
Value ); Set_ = true; }
std::string Value() const { return Value_; }
std::string Name() const { return Name_; }
void Reset() { Set_ = false; Value_ = ""; }
bool Set() const { return Set_; }
void Set( bool Value ) { Set_ = Value; }
ESQL_FieldTypes FieldType() { return FieldType_; }
std::string EscapeString( MYSQL* Sock ) const;
private:
std::string Value_;
bool Set_;
std::string Name_;
std::string Default_;
ESQL_FieldTypes FieldType_;
unsigned short int FieldLength_;
};
I was mainly worrying about setting the value. If I wanted to think about
getting the value I would of added oeprator int, operator float, etc...
operator int() { if ( Set_ && FieldType_ == SQL_FieldType_Int || FieldType_
== SQL_FieldType_UnsignedInt /* ... */ ) { return jml::StrmConvert<int>(
Value_ ) else return 0 /* or throw */; }
operator std::string() ( if ( Set_ ) return Value_ else return ""; // or
throw */ }
operator bool { if ( Set_ } { if ( Value == "TRUE" } return true; else
return false; } else return false /* or throw */; }
etc...
I really can't tell you why I dont' have those operator int's etc.. in there
now, or how I'm getting the values since it wound up being a lot of
dependant classes that is pretty much a nightmare to maintain right now.
I'm going to have to go through and refactor it all. I made it, and started
using it but don't like it right now. I think it could be better.