mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-08-06 06:26:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

solve errors and warnings

Browse Source 
Modified performance test and solve a problem caused by an enum type.
This commit is contained in:
MYLS 2016-07-19 21:18:41 +08:00
parent 78ca5ddd45
commit cf2d6f6721
2 changed files with 57 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
modules/core/perf/perf_io_base64.cpp
View File

@ -48,7 +48,7 @@ PERF_TEST_P(Size_Mat_StrType, fs_text,
remove(file_name.c_str());
SANITY_CHECK(dst, 1);
EXPECT_EQ( src, dst );
}
PERF_TEST_P(Size_Mat_StrType, fs_base64,
@ -83,5 +83,6 @@ PERF_TEST_P(Size_Mat_StrType, fs_base64,
}
remove(file_name.c_str());
SANITY_CHECK(dst, 1);
EXPECT_EQ( src, dst );
}

117
modules/core/src/persistence.cpp
View File

@ -187,12 +187,15 @@ namespace base64
{
class Base64Writer;
enum Base64State
namespace fs
{
Uncertain,
NotUse,
InUse,
};
enum State
{
Uncertain,
NotUse,
InUse,
};
}
}
#define CV_XML_OPENING_TAG 1
@ -254,7 +257,7 @@ typedef struct CvFileStorage
base64::Base64Writer * base64_writer;
bool is_default_using_base64;
base64::Base64State state_of_writing_base64; /**< used in WriteRawData only */
base64::fs::State state_of_writing_base64; /**< used in WriteRawData only */
bool is_write_struct_delayed;
char* delayed_struct_key;
@ -1104,7 +1107,7 @@ static bool is_param_exist( const std::vector<std::string> & params, const std::
return std::find(params.begin(), params.end(), param) != params.end();
}
static void switch_to_Base64_state( CvFileStorage* fs, base64::Base64State state )
static void switch_to_Base64_state( CvFileStorage* fs, base64::fs::State state )
{
const char * err_unkonwn_state = "Unexpected error, unable to determine the Base64 state.";
const char * err_unable_to_switch = "Unexpected error, unable to switch to this state.";
@ -1112,30 +1115,30 @@ static void switch_to_Base64_state( CvFileStorage* fs, base64::Base64State state
/* like a finite state machine */
switch (fs->state_of_writing_base64)
{
case base64::Base64State::Uncertain:
case base64::fs::Uncertain:
switch (state)
{
case base64::Base64State::InUse:
case base64::fs::InUse:
CV_DbgAssert( fs->base64_writer == 0 );
fs->base64_writer = new base64::Base64Writer( fs );
break;
case base64::Base64State::Uncertain:
case base64::fs::Uncertain:
break;
case base64::Base64State::NotUse:
case base64::fs::NotUse:
break;
default:
CV_Error( CV_StsError, err_unkonwn_state );
break;
}
break;
case base64::Base64State::InUse:
case base64::fs::InUse:
switch (state)
{
case base64::Base64State::InUse:
case base64::Base64State::NotUse:
case base64::fs::InUse:
case base64::fs::NotUse:
CV_Error( CV_StsError, err_unable_to_switch );
break;
case base64::Base64State::Uncertain:
case base64::fs::Uncertain:
delete fs->base64_writer;
fs->base64_writer = 0;
break;
@ -1144,14 +1147,14 @@ static void switch_to_Base64_state( CvFileStorage* fs, base64::Base64State state
break;
}
break;
case base64::Base64State::NotUse:
case base64::fs::NotUse:
switch (state)
{
case base64::Base64State::InUse:
case base64::Base64State::NotUse:
case base64::fs::InUse:
case base64::fs::NotUse:
CV_Error( CV_StsError, err_unable_to_switch );
break;
case base64::Base64State::Uncertain:
case base64::fs::Uncertain:
break;
default:
CV_Error( CV_StsError, err_unkonwn_state );
@ -1200,16 +1203,16 @@ static void check_if_write_struct_is_delayed( CvFileStorage* fs, bool change_typ
if ( change_type_to_base64 )
{
fs->start_write_struct( fs, struct_key, struct_flags, "binary");
if ( fs->state_of_writing_base64 != base64::Base64State::Uncertain )
switch_to_Base64_state( fs, base64::Base64State::Uncertain );
switch_to_Base64_state( fs, base64::Base64State::InUse );
if ( fs->state_of_writing_base64 != base64::fs::Uncertain )
switch_to_Base64_state( fs, base64::fs::Uncertain );
switch_to_Base64_state( fs, base64::fs::InUse );
}
else
{
fs->start_write_struct( fs, struct_key, struct_flags, type_name);
if ( fs->state_of_writing_base64 != base64::Base64State::Uncertain )
switch_to_Base64_state( fs, base64::Base64State::Uncertain );
switch_to_Base64_state( fs, base64::Base64State::NotUse );
if ( fs->state_of_writing_base64 != base64::fs::Uncertain )
switch_to_Base64_state( fs, base64::fs::Uncertain );
switch_to_Base64_state( fs, base64::fs::NotUse );
}
delete struct_key;
@ -1841,11 +1844,11 @@ static void
icvYMLWrite( CvFileStorage* fs, const char* key, const char* data )
{
check_if_write_struct_is_delayed( fs );
if ( fs->state_of_writing_base64 == base64::Base64State::Uncertain )
if ( fs->state_of_writing_base64 == base64::fs::Uncertain )
{
switch_to_Base64_state( fs, base64::Base64State::NotUse );
switch_to_Base64_state( fs, base64::fs::NotUse );
}
else if ( fs->state_of_writing_base64 == base64::Base64State::InUse )
else if ( fs->state_of_writing_base64 == base64::fs::InUse )
{
CV_Error( CV_StsError, "At present, output Base64 data only." );
}
@ -2993,11 +2996,11 @@ static void
icvXMLWriteScalar( CvFileStorage* fs, const char* key, const char* data, int len )
{
check_if_write_struct_is_delayed( fs );
if ( fs->state_of_writing_base64 == base64::Base64State::Uncertain )
if ( fs->state_of_writing_base64 == base64::fs::Uncertain )
{
switch_to_Base64_state( fs, base64::Base64State::NotUse );
switch_to_Base64_state( fs, base64::fs::NotUse );
}
else if ( fs->state_of_writing_base64 == base64::Base64State::InUse )
else if ( fs->state_of_writing_base64 == base64::fs::InUse )
{
CV_Error( CV_StsError, "Currently only Base64 data is allowed." );
}
@ -3334,7 +3337,7 @@ cvOpenFileStorage( const char* query, CvMemStorage* dststorage, int flags, const
fs->base64_writer = 0;
fs->is_default_using_base64 = write_base64;
fs->state_of_writing_base64 = base64::Base64State::Uncertain;
fs->state_of_writing_base64 = base64::fs::Uncertain;
fs->is_write_struct_delayed = false;
fs->delayed_struct_key = 0;
@ -3516,10 +3519,10 @@ cvStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
{
CV_CHECK_OUTPUT_FILE_STORAGE(fs);
check_if_write_struct_is_delayed( fs );
if ( fs->state_of_writing_base64 == base64::Base64State::NotUse )
switch_to_Base64_state( fs, base64::Base64State::Uncertain );
if ( fs->state_of_writing_base64 == base64::fs::NotUse )
switch_to_Base64_state( fs, base64::fs::Uncertain );
if ( fs->state_of_writing_base64 == base64::Base64State::Uncertain
if ( fs->state_of_writing_base64 == base64::fs::Uncertain
&&
CV_NODE_IS_SEQ(struct_flags)
&&
@ -3536,26 +3539,26 @@ cvStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags,
/* Must output Base64 data */
if ( !CV_NODE_IS_SEQ(struct_flags) )
CV_Error( CV_StsBadArg, "must set 'struct_flags |= CV_NODE_SEQ' if using Base64.");
else if ( fs->state_of_writing_base64 != base64::Base64State::Uncertain )
else if ( fs->state_of_writing_base64 != base64::fs::Uncertain )
CV_Error( CV_StsError, "function \'cvStartWriteStruct\' calls cannot be nested if using Base64.");
fs->start_write_struct( fs, key, struct_flags, type_name );
if ( fs->state_of_writing_base64 != base64::Base64State::Uncertain )
switch_to_Base64_state( fs, base64::Base64State::Uncertain );
switch_to_Base64_state( fs, base64::Base64State::InUse );
if ( fs->state_of_writing_base64 != base64::fs::Uncertain )
switch_to_Base64_state( fs, base64::fs::Uncertain );
switch_to_Base64_state( fs, base64::fs::InUse );
}
else
{
/* Won't output Base64 data */
if ( fs->state_of_writing_base64 == base64::Base64State::InUse )
if ( fs->state_of_writing_base64 == base64::fs::InUse )
CV_Error( CV_StsError, "At the end of the output Base64, `cvEndWriteStruct` is needed.");
fs->start_write_struct( fs, key, struct_flags, type_name );
if ( fs->state_of_writing_base64 != base64::Base64State::Uncertain )
switch_to_Base64_state( fs, base64::Base64State::Uncertain );
switch_to_Base64_state( fs, base64::Base64State::NotUse );
if ( fs->state_of_writing_base64 != base64::fs::Uncertain )
switch_to_Base64_state( fs, base64::fs::Uncertain );
switch_to_Base64_state( fs, base64::fs::NotUse );
}
}
@ -3566,8 +3569,8 @@ cvEndWriteStruct( CvFileStorage* fs )
CV_CHECK_OUTPUT_FILE_STORAGE(fs);
check_if_write_struct_is_delayed( fs );
if ( fs->state_of_writing_base64 != base64::Base64State::Uncertain )
switch_to_Base64_state( fs, base64::Base64State::Uncertain );
if ( fs->state_of_writing_base64 != base64::fs::Uncertain )
switch_to_Base64_state( fs, base64::fs::Uncertain );
fs->end_write_struct( fs );
}
@ -3747,14 +3750,14 @@ CV_IMPL void
cvWriteRawData( CvFileStorage* fs, const void* _data, int len, const char* dt )
{
if (fs->is_default_using_base64 ||
fs->state_of_writing_base64 == base64::Base64State::InUse )
fs->state_of_writing_base64 == base64::fs::InUse )
{
base64::cvWriteRawDataBase64( fs, _data, len, dt );
return;
}
else if ( fs->state_of_writing_base64 == base64::Base64State::Uncertain )
else if ( fs->state_of_writing_base64 == base64::fs::Uncertain )
{
switch_to_Base64_state( fs, base64::Base64State::NotUse );
switch_to_Base64_state( fs, base64::fs::NotUse );
}
const char* data0 = (const char*)_data;
@ -7341,11 +7344,11 @@ void base64::cvWriteRawDataBase64(::CvFileStorage* fs, const void* _data, int le
check_if_write_struct_is_delayed( fs, true );
if ( fs->state_of_writing_base64 == base64::Base64State::Uncertain )
if ( fs->state_of_writing_base64 == base64::fs::Uncertain )
{
switch_to_Base64_state( fs, base64::Base64State::InUse );
switch_to_Base64_state( fs, base64::fs::InUse );
}
else if ( fs->state_of_writing_base64 != base64::Base64State::InUse )
else if ( fs->state_of_writing_base64 != base64::fs::InUse )
{
CV_Error( CV_StsError, "Base64 should not be used at present." );
}
@ -7392,18 +7395,6 @@ void base64::cvWriteMat_Base64(::CvFileStorage * fs, const char * name, ::cv::Ma
* Interface
***************************************************************************/
void cvWriteMatBase64(::CvFileStorage* fs, const char* name, const ::CvMat* mat)
{
::cv::Mat holder = ::cv::cvarrToMat(mat);
::base64::cvWriteMat_Base64(fs, name, holder);
}
void cvWriteMatNDBase64(::CvFileStorage* fs, const char* name, const ::CvMatND* mat)
{
::cv::Mat holder = ::cv::cvarrToMat(mat);
::base64::cvWriteMat_Base64(fs, name, holder);
}
CV_IMPL void cvWriteRawDataBase64(::CvFileStorage* fs, const void* _data, int len, const char* dt)
{
::base64::cvWriteRawDataBase64(fs, _data, len, dt);