tomasz.sowa/morm
1
0
Fork 0
Code Issues 2 Pull Requests Releases Activity

changed: some methods from ModelConnector moved to Model

Browse Source 
git-svn-id: svn://ttmath.org/publicrep/morm/trunk@1119 e52654a7-88a9-db11-a3e9-0013d4bc506e
This commit is contained in:
Tomasz Sowa
2018-07-04 11:34:49 +00:00
parent f85f03a889
commit 08cd621d41
5 changed files with 324 additions and 468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
src/model.h
View File

@@ -125,6 +125,7 @@ public:
virtual bool save(ModelData * model_data = nullptr);
virtual bool save(ModelData & model_data);
virtual void generate_select_columns(PT::TextStream & stream, const std::wstring & column_prefix);
// set object to default values
virtual void clear();
@@ -157,6 +158,10 @@ protected:
virtual int get_connector_mode();
// used by Finder
virtual void map_values_from_query();
/////////////////////////////////
void field(const wchar_t * field_name, char & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
@@ -259,21 +264,15 @@ protected:
field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
void field(const wchar_t * field_name, Model & field_model, bool insertable = true, bool updatable = true, bool is_primary_key = false)
void field(const wchar_t * field_name, Model & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
if( model_connector )
{
model_connector->field_model(field_name, field_name, field_model, insertable, updatable, is_primary_key, model_connector_mode);
}
field_model(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
template<typename ModelClass>
void field(const wchar_t * field_name, std::list<ModelClass> & field_list, bool insertable = true, bool updatable = true, bool is_primary_key = false)
void field(const wchar_t * field_name, std::list<ModelClass> & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
if( model_connector )
{
model_connector->field_list(field_name, field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode);
}
field_list(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
@@ -380,21 +379,15 @@ protected:
}
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, Model & field_model, bool insertable = true, bool updatable = true, bool is_primary_key = false)
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, Model & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
if( model_connector )
{
model_connector->field_model(db_field_name, flat_field_name, field_model, insertable, updatable, is_primary_key, model_connector_mode);
}
field_model(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
template<typename ModelClass>
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list<ModelClass> & field_list, bool insertable = true, bool updatable = true, bool is_primary_key = false)
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list<ModelClass> & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
if( model_connector )
{
model_connector->field_list(db_field_name, flat_field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode);
}
field_list(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
//////////////////////
@@ -402,54 +395,154 @@ protected:
protected:
template<typename FieldValue>
void field_generic(const wchar_t * field_name, FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key)
void field_generic(const wchar_t * db_field_name, const wchar_t * flat_field_name, FieldValue & field_value, bool insertable, bool updatable, bool is_primary_key)
{
if( model_connector )
{
model_connector->field_generic(field_name, field_name, field_value, insertable, updatable, is_primary_key, model_connector_mode);
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING )
{
FlatConnector * flat_connector = model_connector->get_flat_connector();
if( flat_connector )
{
FlatExpression * flat_expression = flat_connector->get_expression();
if( flat_expression && !is_empty_field(flat_field_name) )
{
// insertable, updatable and is_primary_key are ignored here
flat_expression->field(flat_field_name, field_value, insertable, updatable, is_primary_key);
}
}
}
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL )
{
DbConnector * db_connector = model_connector->get_db_connector();
if( db_connector )
{
DbExpression * db_expression = db_connector->get_expression();
if( db_expression && !is_empty_field(db_field_name) )
{
db_expression->field(db_field_name, field_value, insertable, updatable, is_primary_key);
}
}
}
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET )
{
DbConnector * db_connector = model_connector->get_db_connector();
if( db_connector )
{
if( !is_empty_field(db_field_name) )
db_connector->get_value_by_field_name(db_field_name, field_value);
}
}
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE )
{
DbConnector * db_connector = model_connector->get_db_connector();
if( db_connector )
{
// IMPROVE ME those clearing should be moved to a better place
db_connector->clear_value(field_value);
}
}
}
}
template<typename FieldValue>
void field_generic(const wchar_t * db_field_name, const wchar_t * flat_field_name, FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
template<typename ModelClass>
void field_list(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list<ModelClass> & field_list, bool insertable, bool updatable, bool is_primary_key)
{
// IMPLEMENTME what about db?
if( model_connector )
{
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING )
{
FlatConnector * flat_connector = model_connector->get_flat_connector();
if( flat_connector )
{
FlatExpression * flat_expression = flat_connector->get_expression();
if( flat_expression && !is_empty_field(flat_field_name) )
{
flat_expression->field_list(flat_field_name, field_list, insertable, updatable, is_primary_key, model_connector_mode);
}
}
}
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE )
{
field_list.clear();
}
// WILL BE REMOVED
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_SETTING_CONNECTOR_FOR_CHILDS )
{
// IMPROVE ME
// it would be better to set the connector when an operation is needed
}
}
}
template<typename ModelX>
void field_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, ModelX & field_model, bool insertable, bool updatable, bool is_primary_key)
{
if( model_connector )
{
model_connector->field_generic(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key, model_connector_mode);
// IMPLEMENTME what about db?
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING )
{
FlatConnector * flat_connector = model_connector->get_flat_connector();
if( flat_connector )
{
FlatExpression * flat_expression = flat_connector->get_expression();
if( flat_expression && !is_empty_field(flat_field_name) )
{
field_model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING;
flat_expression->field_model(flat_field_name, field_model, insertable, updatable, is_primary_key);
field_model.model_connector_mode = MORM_MODEL_CONNECTOR_MODE_NONE;
}
}
}
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE )
{
field_model.clear();
}
// WILL BE REMOVED
if( model_connector_mode == MORM_MODEL_CONNECTOR_MODE_SETTING_CONNECTOR_FOR_CHILDS )
{
field_model.set_connector(model_connector);
}
}
}
public:
/*
template<typename FieldValue>
void field_generic_textstream(const PT::TextStream & field_name, FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
if( model_connector )
{
model_connector->field(field_name, field_name, field_value, insertable, updatable, is_primary_key);
}
}
template<typename FieldValue>
void field_generic_textstream(const PT::TextStream & db_field_name, const PT::TextStream & flat_field_name, FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
{
if( model_connector )
{
model_connector->field(db_field_name, flat_field_name, field_value, insertable, updatable, is_primary_key);
}
}
*/
template<typename FieldValue>
void get_last_sequence(const wchar_t * sequence_table_name, FieldValue & field_value)
{
if( model_connector )
{
model_connector->get_last_sequence(sequence_table_name, field_value);
DbConnector * db_connector = model_connector->get_db_connector();
if( db_connector && !is_empty_field(sequence_table_name) )
{
db_connector->get_last_sequence(sequence_table_name, field_value);
}
}
}
@@ -461,22 +554,32 @@ public:
{
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_GENERATING_DB_SQL )
{
model_connector->add_field_for_select(new_column_expression, new_column_name, field_value, model_connector_mode);
DbConnector * db_connector = model_connector->get_db_connector();
if( db_connector )
{
DbExpression * db_expression = db_connector->get_expression();
if( db_expression && !is_empty_field(new_column_expression) )
{
db_expression->add_field_for_select(new_column_expression, new_column_name, field_value);
}
}
}
else
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_GENERATING_FLAT_STRING )
{
model_connector->field_generic(L"", flat_field_name, field_value, false, false, false, model_connector_mode);
field_generic(L"", flat_field_name, field_value, false, false, false);
}
else
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_READING_VALUE_FROM_DB_RESULTSET )
{
model_connector->field_generic(new_column_name, L"", field_value, false, false, false, model_connector_mode);
field_generic(new_column_name, L"", field_value, false, false, false);
}
else
if( get_connector_mode() == MORM_MODEL_CONNECTOR_MODE_CLEARING_VALUE )
{
model_connector->field_generic(L"", L"", field_value, false, false, false, model_connector_mode); // the names don't matter here
field_generic(L"", L"", field_value, false, false, false); // the names don't matter here
}
}
}
@@ -487,11 +590,17 @@ public:
add_field_for_select(new_column_expression, new_column_name, new_column_name, field_value);
}
template<typename ModelClass> friend class Finder;
friend class ModelConnector;
protected:
virtual bool is_empty_field(const wchar_t * value);
template<typename ModelClass> friend class Finder;
friend class BaseExpression;
// WILL BE REMOVED when ModelConnector::set_connector_for_childs(Model & model) will be removed
friend class ModelConnector;
};
} // namespace