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

changed the way how we get a specific field value - now we do not use expressions (BaseExpression), to get the raw value we don't need an expression object:

Browse Source 
- removed MORM_WORK_MODE_GET_SPECIFIC_FIELD_VALUE from expression work mode
- removed: void BaseExpression::field(const wchar_t * field_name, void (Model::*getter_method)(pt::TextStream &), const FT & field_type, ModelEnv * model_env)
- removed from BaseExpression: template<typename FunInfoStreamType> void field(const wchar_t * field_name, void (Model::*fun)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type, ModelEnv * model_env)
- removed: void FlatConnector::to_text(const wchar_t * flat_field_name, pt::TextStream & stream, Model & model)
- renamed/changed: Model::put_field_value(...) -> Model::get_raw_value()

added classes:
class ModelWrapper - base wrapper class for a model or a model container
class ModelWrapperModel : public ModelWrapper - wrapper for a model
template<typename VectorType> class ModelWrapperVector : public ModelWrapper - wrapper for vector of models
template<typename ListType> class ModelWrapperList : public ModelWrapper - wrapper for list of models
ModelWrapper... classes are used by ezc library for iterating through child models and for iterating in [for...] statements

added to Model:
Model * get_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
ModelWrapper * get_model_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
This commit is contained in:
Tomasz Sowa
2021-06-16 14:01:07 +02:00
parent dd01fafa40
commit aeb02f82b1
11 changed files with 567 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
src/model.h
View File

@@ -48,6 +48,7 @@
#include "flatexpression.h"
#include "modelenv.h"
#include "ft.h"
#include "modelwrapper.h"
#ifdef MORM_HAS_EZC_LIBRARY
#include "funinfo.h"
@@ -81,11 +82,16 @@
#ifdef MORM_HAS_EZC_LIBRARY
#define MORM_MODEL_MEMBER_FIELD_EZC(ClassName) \
template<typename FunInfoStreamType> \
void field(const wchar_t * flat_field_name, void (ClassName::*method)(Ezc::FunInfo<FunInfoStreamType> &), const morm::FT & field_type = morm::FT::default_type) \
void field(const wchar_t * field_name, void (ClassName::*method)(Ezc::FunInfo<FunInfoStreamType> &), const morm::FT & field_type = morm::FT::default_type) \
{ \
field(field_name, field_name, method, field_type); \
} \
template<typename FunInfoStreamType> \
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (ClassName::*method)(Ezc::FunInfo<FunInfoStreamType> &), const morm::FT & field_type = morm::FT::default_type) \
{ \
typedef void (Model::*ModelMember)(Ezc::FunInfo<FunInfoStreamType> &); \
ModelMember model_member = static_cast<ModelMember>(method); \
field_member_ezc(flat_field_name, model_member, field_type); \
field_member_ezc(db_field_name, flat_field_name, model_member, field_type); \
}
#endif
@@ -216,16 +222,18 @@ public:
}
Model * get_field_model(const wchar_t * db_field_name, const wchar_t * flat_field_name);
Model * get_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
ModelWrapper * get_model_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
void put_field_value(const wchar_t * flat_field_name, pt::TextStream & stream, bool clear_stream = true);
void put_field_value(const wchar_t * flat_field_name, ModelData * model_data, pt::TextStream & stream, bool clear_stream = true);
void get_raw_value(const wchar_t * db_field_name, const wchar_t * flat_field_name, pt::TextStream & stream, bool clear_stream = true, bool put_log_if_not_found = true);
void get_raw_value(const wchar_t * db_field_name, const wchar_t * flat_field_name, ModelData * model_data, pt::TextStream & stream, bool clear_stream = true, bool put_log_if_not_found = true);
#ifdef MORM_HAS_EZC_LIBRARY
template<typename FunInfoStreamType>
void put_field_value(const wchar_t * flat_field_name, ModelData * model_data, Ezc::FunInfo<FunInfoStreamType> & fun_info, pt::TextStream & stream, bool clear_stream = true)
void get_raw_value(const wchar_t * db_field_name, const wchar_t * flat_field_name, ModelData * model_data,
Ezc::FunInfo<FunInfoStreamType> & fun_info, pt::TextStream & stream, bool clear_stream = true)
{
if( clear_stream )
{
@@ -236,28 +244,23 @@ public:
model_env = &model_env_local;
model_env->has_primary_key_set = has_primary_key_set;
model_env->model_work_mode = MORM_MODEL_WORK_MODE_GENERATING_FLAT_STRING;
model_env->model_work_mode = MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM;
model_env->db_field_name = db_field_name;
model_env->flat_field_name = flat_field_name;
model_env->model_data = model_data;
model_env->stream = &stream;
model_env->ezc_fun_info = &fun_info;
model_env->ezc_fun_info_typeinfo = &typeid(fun_info);
model_env->model = this;
if( model_connector )
try
{
FlatConnector * flat_connector = model_connector->get_flat_connector();
if( flat_connector )
{
try
{
flat_connector->to_text(flat_field_name, stream, *this);
}
catch(...)
{
model_env = nullptr;
throw;
}
}
fields();
}
catch(...)
{
model_env = nullptr;
throw;
}
model_env = nullptr;
@@ -433,15 +436,13 @@ protected:
template<typename ModelClass>
void field(const wchar_t * field_name, std::list<ModelClass> & field_value, const FT & field_type = FT::default_type)
{
ModelClass * list_model_null_pointer = nullptr;
field_list(field_name, field_name, field_value, list_model_null_pointer, field_type);
field_list(field_name, field_name, field_value, field_type);
}
template<typename ModelClass>
void field(const wchar_t * field_name, std::vector<ModelClass> & field_value, const FT & field_type = FT::default_type)
{
ModelClass * list_model_null_pointer = nullptr;
field_list(field_name, field_name, field_value, list_model_null_pointer, field_type);
field_vector(field_name, field_name, field_value, field_type);
}
@@ -555,15 +556,13 @@ protected:
template<typename ModelClass>
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list<ModelClass> & field_value, const FT & field_type = FT::default_type)
{
ModelClass * list_model_null_pointer = nullptr;
field_list(db_field_name, flat_field_name, field_value, list_model_null_pointer, field_type);
field_list(db_field_name, flat_field_name, field_value, field_type);
}
template<typename ModelClass>
void field(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::vector<ModelClass> & field_value, const FT & field_type = FT::default_type)
{
ModelClass * list_model_null_pointer = nullptr;
field_list(db_field_name, flat_field_name, field_value, list_model_null_pointer, field_type);
field_vector(db_field_name, flat_field_name, field_value, field_type);
}
@@ -702,6 +701,20 @@ protected:
}
template<typename FieldValue>
void field_generic_put_raw_value_to_stream(const wchar_t * db_field_name, const wchar_t * flat_field_name, FieldValue & field_value, const FT & field_type)
{
if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
{
if( model_env->stream )
{
(*model_env->stream) << field_value;
}
}
}
template<typename FieldValue>
void field_generic(const wchar_t * db_field_name, const wchar_t * flat_field_name, FieldValue & field_value, const FT & field_type)
{
@@ -741,6 +754,11 @@ protected:
{
field_generic_clear_value(field_value, field_type);
}
if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM )
{
field_generic_put_raw_value_to_stream(db_field_name, flat_field_name, field_value, field_type);
}
}
}
@@ -766,6 +784,12 @@ protected:
void (Model::*setter_method)(const char * input_str),
const FT & field_type);
void field_member_put_field_raw_value_to_stream(
const wchar_t * db_field_name,
const wchar_t * flat_field_name,
void (Model::*getter_method)(pt::TextStream &),
const FT & field_type);
void field_member_clear_value(
void (Model::*setter_method)(const char * input_str),
const FT & field_type);
@@ -781,29 +805,46 @@ protected:
#ifdef MORM_HAS_EZC_LIBRARY
template<typename FunInfoStreamType>
void field_member_ezc(const wchar_t * flat_field_name, void (Model::*method)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type)
void field_member_ezc(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (Model::*method)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type)
{
if( model_connector && model_env && model_env->ezc_fun_info && model_env->ezc_fun_info_typeinfo && model_env->model )
{
if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GENERATING_FLAT_STRING )
if( field_type.is_primary_key() )
{
field_fun_generate_flat_string(flat_field_name, method, field_type);
pt::Log * plog = model_connector->get_logger();
if( plog )
{
(*plog) << pt::Log::log1 << "Morm:: ezc methods cannot be used as a primary key" << pt::Log::logend;
}
}
if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_PUT_FIELD_RAW_VALUE_TO_STREAM )
{
field_member_ezc_put_field_value_to_stream(db_field_name, flat_field_name, method, field_type);
}
}
}
template<typename FunInfoStreamType>
void field_fun_generate_flat_string(const wchar_t * flat_field_name, void (Model::*method)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type)
void field_member_ezc_put_field_value_to_stream(const wchar_t * db_field_name, const wchar_t * flat_field_name, void (Model::*method)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type)
{
FlatConnector * flat_connector = model_connector->get_flat_connector();
if( flat_connector )
if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) )
{
FlatExpression * flat_expression = flat_connector->get_expression();
if( flat_expression && !is_empty_field(flat_field_name) )
if( typeid(Ezc::FunInfo<FunInfoStreamType>) == *model_env->ezc_fun_info_typeinfo )
{
flat_expression->field(flat_field_name, method, field_type, model_env);
Ezc::FunInfo<FunInfoStreamType> * ezc_fun_info = reinterpret_cast<Ezc::FunInfo<FunInfoStreamType>*>(model_env->ezc_fun_info);
(model_env->model->*method)(*ezc_fun_info);
}
else
{
pt::Log * plog = model_connector->get_logger();
if( plog )
{
(*plog) << pt::Log::log2 << "Morm: incorrect method type for field: " << flat_field_name << pt::Log::logend;
}
}
}
}
@@ -918,8 +959,52 @@ protected:
}
template<typename ModelClass>
void field_vector(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::vector<ModelClass> & field_value, const FT & field_type)
{
ModelClass * list_model_null_pointer = nullptr;
if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
{
if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) &&
!model_env->model_wrapper )
{
model_env->model_wrapper = new ModelWrapperVector(&field_value);
}
}
else
{
field_list_generic(db_field_name, flat_field_name, field_value, list_model_null_pointer, field_type);
}
}
template<typename ModelClass>
void field_list(const wchar_t * db_field_name, const wchar_t * flat_field_name, std::list<ModelClass> & field_value, const FT & field_type)
{
ModelClass * list_model_null_pointer = nullptr;
if( model_env->model_work_mode == MORM_MODEL_WORK_MODE_GET_MODEL_WRAPPER )
{
if( (is_empty_field(model_env->db_field_name) || is_the_same_field(db_field_name, model_env->db_field_name)) &&
(is_empty_field(model_env->flat_field_name) || is_the_same_field(flat_field_name, model_env->flat_field_name)) &&
!model_env->model_wrapper )
{
model_env->model_wrapper = new ModelWrapperList(&field_value);
}
}
else
{
field_list_generic(db_field_name, flat_field_name, field_value, list_model_null_pointer, field_type);
}
}
template<typename ModelContainer, typename ModelContainerType>
void field_list(const wchar_t * db_field_name, const wchar_t * flat_field_name, ModelContainer & field_container, ModelContainerType * model_container_type, const FT & field_type)
void field_list_generic(const wchar_t * db_field_name, const wchar_t * flat_field_name, ModelContainer & field_container, ModelContainerType * model_container_type, const FT & field_type)
{
if( model_connector && model_env )
{