Split persistence.cpp into smaller pieces (#10788)
* Extracted base64 persistence functionality * Extracted YML persistence functionality * Extracted JSON persistence functionality * Extracted XML persistence functionality * Extracted public C and C++ interfaces implementation in persistence * Persistence: cleanup and fixes * fixup! Persistence: cleanup and fixespull/10856/head
Maksim Shabunin
7 years ago
committed by
Vadim Pisarevsky
parent
10e1de74d2
commit
e225850cc6
9 changed files with 7737 additions and 7886 deletions
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,325 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
|
||||
#ifndef SRC_PERSISTENCE_HPP |
||||
#define SRC_PERSISTENCE_HPP |
||||
|
||||
#include "opencv2/core/types_c.h" |
||||
#include <deque> |
||||
#include <deque> |
||||
#include <sstream> |
||||
#include <string> |
||||
#include <iterator> |
||||
|
||||
#define USE_ZLIB 1 |
||||
#if USE_ZLIB |
||||
# ifndef _LFS64_LARGEFILE |
||||
# define _LFS64_LARGEFILE 0 |
||||
# endif |
||||
# ifndef _FILE_OFFSET_BITS |
||||
# define _FILE_OFFSET_BITS 0 |
||||
# endif |
||||
# include <zlib.h> |
||||
#else |
||||
typedef void* gzFile; |
||||
#endif |
||||
|
||||
//=====================================================================================
|
||||
|
||||
static const size_t PARSER_BASE64_BUFFER_SIZE = 1024U * 1024U / 8U; |
||||
|
||||
namespace base64 { |
||||
|
||||
namespace fs { |
||||
enum State |
||||
{ |
||||
Uncertain, |
||||
NotUse, |
||||
InUse, |
||||
}; |
||||
} // fs::
|
||||
|
||||
static const size_t HEADER_SIZE = 24U; |
||||
static const size_t ENCODED_HEADER_SIZE = 32U; |
||||
|
||||
size_t base64_encode(uint8_t const * src, uint8_t * dst, size_t off, size_t cnt); |
||||
size_t base64_encode( char const * src, char * dst, size_t off = 0U, size_t cnt = 0U); |
||||
size_t base64_decode(uint8_t const * src, uint8_t * dst, size_t off, size_t cnt); |
||||
size_t base64_decode( char const * src, char * dst, size_t off = 0U, size_t cnt = 0U); |
||||
bool base64_valid (uint8_t const * src, size_t off, size_t cnt); |
||||
bool base64_valid ( char const * src, size_t off = 0U, size_t cnt = 0U); |
||||
size_t base64_encode_buffer_size(size_t cnt, bool is_end_with_zero = true); |
||||
size_t base64_decode_buffer_size(size_t cnt, bool is_end_with_zero = true); |
||||
size_t base64_decode_buffer_size(size_t cnt, char const * src, bool is_end_with_zero = true); |
||||
size_t base64_decode_buffer_size(size_t cnt, uchar const * src, bool is_end_with_zero = true); |
||||
std::string make_base64_header(const char * dt); |
||||
bool read_base64_header(std::vector<char> const & header, std::string & dt); |
||||
void make_seq(void * binary_data, int elem_cnt, const char * dt, CvSeq & seq); |
||||
void cvWriteRawDataBase64(::CvFileStorage* fs, const void* _data, int len, const char* dt); |
||||
|
||||
class Base64ContextEmitter; |
||||
|
||||
class Base64Writer |
||||
{ |
||||
public: |
||||
Base64Writer(::CvFileStorage * fs); |
||||
~Base64Writer(); |
||||
void write(const void* _data, size_t len, const char* dt); |
||||
template<typename _to_binary_convertor_t> void write(_to_binary_convertor_t & convertor, const char* dt); |
||||
|
||||
private: |
||||
void check_dt(const char* dt); |
||||
|
||||
private: |
||||
// disable copy and assignment
|
||||
Base64Writer(const Base64Writer &); |
||||
Base64Writer & operator=(const Base64Writer &); |
||||
|
||||
private: |
||||
|
||||
Base64ContextEmitter * emitter; |
||||
std::string data_type_string; |
||||
}; |
||||
|
||||
class Base64ContextParser |
||||
{ |
||||
public: |
||||
explicit Base64ContextParser(uchar * buffer, size_t size); |
||||
~Base64ContextParser(); |
||||
Base64ContextParser & read(const uchar * beg, const uchar * end); |
||||
bool flush(); |
||||
private: |
||||
static const size_t BUFFER_LEN = 120U; |
||||
uchar * dst_cur; |
||||
uchar * dst_end; |
||||
std::vector<uchar> base64_buffer; |
||||
uchar * src_beg; |
||||
uchar * src_cur; |
||||
uchar * src_end; |
||||
std::vector<uchar> binary_buffer; |
||||
}; |
||||
|
||||
} // base64::
|
||||
|
||||
//=====================================================================================
|
||||
|
||||
#define CV_FS_MAX_LEN 4096 |
||||
#define CV_FS_MAX_FMT_PAIRS 128 |
||||
|
||||
#define CV_FILE_STORAGE ('Y' + ('A' << 8) + ('M' << 16) + ('L' << 24)) |
||||
|
||||
#define CV_IS_FILE_STORAGE(fs) ((fs) != 0 && (fs)->flags == CV_FILE_STORAGE) |
||||
|
||||
#define CV_CHECK_FILE_STORAGE(fs) \ |
||||
{ \
|
||||
if( !CV_IS_FILE_STORAGE(fs) ) \
|
||||
CV_Error( (fs) ? CV_StsBadArg : CV_StsNullPtr, \
|
||||
"Invalid pointer to file storage" ); \
|
||||
} |
||||
|
||||
#define CV_CHECK_OUTPUT_FILE_STORAGE(fs) \ |
||||
{ \
|
||||
CV_CHECK_FILE_STORAGE(fs); \
|
||||
if( !fs->write_mode ) \
|
||||
CV_Error( CV_StsError, "The file storage is opened for reading" ); \
|
||||
} |
||||
|
||||
#define CV_PARSE_ERROR( errmsg ) \ |
||||
icvParseError( fs, CV_Func, (errmsg), __FILE__, __LINE__ ) |
||||
|
||||
typedef struct CvGenericHash |
||||
{ |
||||
CV_SET_FIELDS() |
||||
int tab_size; |
||||
void** table; |
||||
} |
||||
CvGenericHash; |
||||
typedef CvGenericHash CvStringHash; |
||||
|
||||
//typedef void (*CvParse)( struct CvFileStorage* fs );
|
||||
typedef void (*CvStartWriteStruct)( struct CvFileStorage* fs, const char* key, |
||||
int struct_flags, const char* type_name ); |
||||
typedef void (*CvEndWriteStruct)( struct CvFileStorage* fs ); |
||||
typedef void (*CvWriteInt)( struct CvFileStorage* fs, const char* key, int value ); |
||||
typedef void (*CvWriteReal)( struct CvFileStorage* fs, const char* key, double value ); |
||||
typedef void (*CvWriteString)( struct CvFileStorage* fs, const char* key, |
||||
const char* value, int quote ); |
||||
typedef void (*CvWriteComment)( struct CvFileStorage* fs, const char* comment, int eol_comment ); |
||||
typedef void (*CvStartNextStream)( struct CvFileStorage* fs ); |
||||
|
||||
typedef struct CvFileStorage |
||||
{ |
||||
int flags; |
||||
int fmt; |
||||
int write_mode; |
||||
int is_first; |
||||
CvMemStorage* memstorage; |
||||
CvMemStorage* dststorage; |
||||
CvMemStorage* strstorage; |
||||
CvStringHash* str_hash; |
||||
CvSeq* roots; |
||||
CvSeq* write_stack; |
||||
int struct_indent; |
||||
int struct_flags; |
||||
CvString struct_tag; |
||||
int space; |
||||
char* filename; |
||||
FILE* file; |
||||
gzFile gzfile; |
||||
char* buffer; |
||||
char* buffer_start; |
||||
char* buffer_end; |
||||
int wrap_margin; |
||||
int lineno; |
||||
int dummy_eof; |
||||
const char* errmsg; |
||||
char errmsgbuf[128]; |
||||
|
||||
CvStartWriteStruct start_write_struct; |
||||
CvEndWriteStruct end_write_struct; |
||||
CvWriteInt write_int; |
||||
CvWriteReal write_real; |
||||
CvWriteString write_string; |
||||
CvWriteComment write_comment; |
||||
CvStartNextStream start_next_stream; |
||||
|
||||
const char* strbuf; |
||||
size_t strbufsize, strbufpos; |
||||
std::deque<char>* outbuf; |
||||
|
||||
base64::Base64Writer * base64_writer; |
||||
bool is_default_using_base64; |
||||
base64::fs::State state_of_writing_base64; /**< used in WriteRawData only */ |
||||
|
||||
bool is_write_struct_delayed; |
||||
char* delayed_struct_key; |
||||
int delayed_struct_flags; |
||||
char* delayed_type_name; |
||||
|
||||
bool is_opened; |
||||
} |
||||
CvFileStorage; |
||||
|
||||
typedef struct CvFileMapNode |
||||
{ |
||||
CvFileNode value; |
||||
const CvStringHashNode* key; |
||||
struct CvFileMapNode* next; |
||||
} |
||||
CvFileMapNode; |
||||
|
||||
/****************************************************************************************\
|
||||
* Common macros and type definitions * |
||||
\****************************************************************************************/ |
||||
|
||||
#define cv_isprint(c) ((uchar)(c) >= (uchar)' ') |
||||
#define cv_isprint_or_tab(c) ((uchar)(c) >= (uchar)' ' || (c) == '\t') |
||||
|
||||
inline bool cv_isalnum(char c) |
||||
{ |
||||
return ('0' <= c && c <= '9') || ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'); |
||||
} |
||||
|
||||
inline bool cv_isalpha(char c) |
||||
{ |
||||
return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'); |
||||
} |
||||
|
||||
inline bool cv_isdigit(char c) |
||||
{ |
||||
return '0' <= c && c <= '9'; |
||||
} |
||||
|
||||
inline bool cv_isspace(char c) |
||||
{ |
||||
return (9 <= c && c <= 13) || c == ' '; |
||||
} |
||||
|
||||
inline char* cv_skip_BOM(char* ptr) |
||||
{ |
||||
if((uchar)ptr[0] == 0xef && (uchar)ptr[1] == 0xbb && (uchar)ptr[2] == 0xbf) //UTF-8 BOM
|
||||
{ |
||||
return ptr + 3; |
||||
} |
||||
return ptr; |
||||
} |
||||
|
||||
char* icv_itoa( int _val, char* buffer, int /*radix*/ ); |
||||
double icv_strtod( CvFileStorage* fs, char* ptr, char** endptr ); |
||||
char* icvFloatToString( char* buf, float value ); |
||||
char* icvDoubleToString( char* buf, double value ); |
||||
|
||||
char icvTypeSymbol(int depth); |
||||
void icvClose( CvFileStorage* fs, cv::String* out ); |
||||
void icvCloseFile( CvFileStorage* fs ); |
||||
void icvPuts( CvFileStorage* fs, const char* str ); |
||||
char* icvGets( CvFileStorage* fs, char* str, int maxCount ); |
||||
int icvEof( CvFileStorage* fs ); |
||||
void icvRewind( CvFileStorage* fs ); |
||||
char* icvFSFlush( CvFileStorage* fs ); |
||||
void icvFSCreateCollection( CvFileStorage* fs, int tag, CvFileNode* collection ); |
||||
char* icvFSResizeWriteBuffer( CvFileStorage* fs, char* ptr, int len ); |
||||
int icvCalcStructSize( const char* dt, int initial_size ); |
||||
int icvCalcElemSize( const char* dt, int initial_size ); |
||||
void icvParseError( CvFileStorage* fs, const char* func_name, const char* err_msg, const char* source_file, int source_line ); |
||||
char* icvEncodeFormat( int elem_type, char* dt ); |
||||
int icvDecodeFormat( const char* dt, int* fmt_pairs, int max_len ); |
||||
int icvDecodeSimpleFormat( const char* dt ); |
||||
void icvWriteFileNode( CvFileStorage* fs, const char* name, const CvFileNode* node ); |
||||
void icvWriteCollection( CvFileStorage* fs, const CvFileNode* node ); |
||||
void switch_to_Base64_state( CvFileStorage* fs, base64::fs::State state ); |
||||
void make_write_struct_delayed( CvFileStorage* fs, const char* key, int struct_flags, const char* type_name ); |
||||
void check_if_write_struct_is_delayed( CvFileStorage* fs, bool change_type_to_base64 = false ); |
||||
CvGenericHash* cvCreateMap( int flags, int header_size, int elem_size, CvMemStorage* storage, int start_tab_size ); |
||||
|
||||
//
|
||||
// XML
|
||||
//
|
||||
void icvXMLParse( CvFileStorage* fs ); |
||||
void icvXMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags, const char* type_name CV_DEFAULT(0)); |
||||
void icvXMLEndWriteStruct( CvFileStorage* fs ); |
||||
void icvXMLStartNextStream( CvFileStorage* fs ); |
||||
void icvXMLWriteScalar( CvFileStorage* fs, const char* key, const char* data, int len ); |
||||
void icvXMLWriteInt( CvFileStorage* fs, const char* key, int value ); |
||||
void icvXMLWriteReal( CvFileStorage* fs, const char* key, double value ); |
||||
void icvXMLWriteString( CvFileStorage* fs, const char* key, const char* str, int quote ); |
||||
void icvXMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment ); |
||||
|
||||
typedef struct CvXMLStackRecord |
||||
{ |
||||
CvMemStoragePos pos; |
||||
CvString struct_tag; |
||||
int struct_indent; |
||||
int struct_flags; |
||||
} |
||||
CvXMLStackRecord; |
||||
|
||||
//
|
||||
// YML
|
||||
//
|
||||
void icvYMLParse( CvFileStorage* fs ); |
||||
void icvYMLWrite( CvFileStorage* fs, const char* key, const char* data ); |
||||
void icvYMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags, const char* type_name CV_DEFAULT(0)); |
||||
void icvYMLEndWriteStruct( CvFileStorage* fs ); |
||||
void icvYMLStartNextStream( CvFileStorage* fs ); |
||||
void icvYMLWriteInt( CvFileStorage* fs, const char* key, int value ); |
||||
void icvYMLWriteReal( CvFileStorage* fs, const char* key, double value ); |
||||
void icvYMLWriteString( CvFileStorage* fs, const char* key, const char* str, int quote CV_DEFAULT(0)); |
||||
void icvYMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment ); |
||||
|
||||
//
|
||||
// JSON
|
||||
//
|
||||
void icvJSONParse( CvFileStorage* fs ); |
||||
void icvJSONWrite( CvFileStorage* fs, const char* key, const char* data ); |
||||
void icvJSONStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags, const char* type_name CV_DEFAULT(0)); |
||||
void icvJSONEndWriteStruct( CvFileStorage* fs ); |
||||
void icvJSONStartNextStream( CvFileStorage* fs ); |
||||
void icvJSONWriteInt( CvFileStorage* fs, const char* key, int value ); |
||||
void icvJSONWriteReal( CvFileStorage* fs, const char* key, double value ); |
||||
void icvJSONWriteString( CvFileStorage* fs, const char* key, const char* str, int quote CV_DEFAULT(0)); |
||||
void icvJSONWriteComment( CvFileStorage* fs, const char* comment, int eol_comment ); |
||||
|
||||
#endif // SRC_PERSISTENCE_HPP
|
||||
@ -0,0 +1,921 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
|
||||
#include "precomp.hpp" |
||||
#include "persistence.hpp" |
||||
|
||||
namespace base64 { |
||||
|
||||
typedef uchar uint8_t; |
||||
|
||||
#if CHAR_BIT != 8 |
||||
#error "`char` should be 8 bit." |
||||
#endif |
||||
|
||||
uint8_t const base64_mapping[] = |
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" |
||||
"abcdefghijklmnopqrstuvwxyz" |
||||
"0123456789+/"; |
||||
|
||||
uint8_t const base64_padding = '='; |
||||
|
||||
uint8_t const base64_demapping[] = { |
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||||
0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, |
||||
0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
||||
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, |
||||
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, |
||||
49, 50, 51, 0, 0, 0, 0, |
||||
}; |
||||
|
||||
/* `base64_demapping` above is generated in this way:
|
||||
* ````````````````````````````````````````````````````````````````````` |
||||
* std::string mapping((const char *)base64_mapping); |
||||
* for (auto ch = 0; ch < 127; ch++) { |
||||
* auto i = mapping.find(ch); |
||||
* printf("%3u, ", (i != std::string::npos ? i : 0)); |
||||
* } |
||||
* putchar('\n'); |
||||
* ````````````````````````````````````````````````````````````````````` |
||||
*/ |
||||
|
||||
size_t base64_encode(uint8_t const * src, uint8_t * dst, size_t off, size_t cnt) |
||||
{ |
||||
if (!src || !dst || !cnt) |
||||
return 0; |
||||
|
||||
/* initialize beginning and end */ |
||||
uint8_t * dst_beg = dst; |
||||
uint8_t * dst_cur = dst_beg; |
||||
|
||||
uint8_t const * src_beg = src + off; |
||||
uint8_t const * src_cur = src_beg; |
||||
uint8_t const * src_end = src_cur + cnt / 3U * 3U; |
||||
|
||||
/* integer multiples part */ |
||||
while (src_cur < src_end) { |
||||
uint8_t _2 = *src_cur++; |
||||
uint8_t _1 = *src_cur++; |
||||
uint8_t _0 = *src_cur++; |
||||
*dst_cur++ = base64_mapping[ _2 >> 2U]; |
||||
*dst_cur++ = base64_mapping[(_1 & 0xF0U) >> 4U | (_2 & 0x03U) << 4U]; |
||||
*dst_cur++ = base64_mapping[(_0 & 0xC0U) >> 6U | (_1 & 0x0FU) << 2U]; |
||||
*dst_cur++ = base64_mapping[ _0 & 0x3FU]; |
||||
} |
||||
|
||||
/* remainder part */ |
||||
size_t rst = src_beg + cnt - src_cur; |
||||
if (rst == 1U) { |
||||
uint8_t _2 = *src_cur++; |
||||
*dst_cur++ = base64_mapping[ _2 >> 2U]; |
||||
*dst_cur++ = base64_mapping[(_2 & 0x03U) << 4U]; |
||||
} else if (rst == 2U) { |
||||
uint8_t _2 = *src_cur++; |
||||
uint8_t _1 = *src_cur++; |
||||
*dst_cur++ = base64_mapping[ _2 >> 2U]; |
||||
*dst_cur++ = base64_mapping[(_2 & 0x03U) << 4U | (_1 & 0xF0U) >> 4U]; |
||||
*dst_cur++ = base64_mapping[(_1 & 0x0FU) << 2U]; |
||||
} |
||||
|
||||
/* padding */ |
||||
switch (rst) |
||||
{ |
||||
case 1U: *dst_cur++ = base64_padding; |
||||
case 2U: *dst_cur++ = base64_padding; |
||||
default: *dst_cur = 0; |
||||
break; |
||||
} |
||||
|
||||
return static_cast<size_t>(dst_cur - dst_beg); |
||||
} |
||||
|
||||
size_t base64_encode(char const * src, char * dst, size_t off, size_t cnt) |
||||
{ |
||||
if (cnt == 0U) |
||||
cnt = std::strlen(src); |
||||
|
||||
return base64_encode |
||||
( |
||||
reinterpret_cast<uint8_t const *>(src), |
||||
reinterpret_cast<uint8_t *>(dst), |
||||
off, |
||||
cnt |
||||
); |
||||
} |
||||
|
||||
size_t base64_decode(uint8_t const * src, uint8_t * dst, size_t off, size_t cnt) |
||||
{ |
||||
/* check parameters */ |
||||
if (!src || !dst || !cnt) |
||||
return 0U; |
||||
if (cnt & 0x3U) |
||||
return 0U; |
||||
|
||||
/* initialize beginning and end */ |
||||
uint8_t * dst_beg = dst; |
||||
uint8_t * dst_cur = dst_beg; |
||||
|
||||
uint8_t const * src_beg = src + off; |
||||
uint8_t const * src_cur = src_beg; |
||||
uint8_t const * src_end = src_cur + cnt; |
||||
|
||||
/* start decoding */ |
||||
while (src_cur < src_end) { |
||||
uint8_t d50 = base64_demapping[*src_cur++]; |
||||
uint8_t c50 = base64_demapping[*src_cur++]; |
||||
uint8_t b50 = base64_demapping[*src_cur++]; |
||||
uint8_t a50 = base64_demapping[*src_cur++]; |
||||
|
||||
uint8_t b10 = b50 & 0x03U; |
||||
uint8_t b52 = b50 & 0x3CU; |
||||
uint8_t c30 = c50 & 0x0FU; |
||||
uint8_t c54 = c50 & 0x30U; |
||||
|
||||
*dst_cur++ = (d50 << 2U) | (c54 >> 4U); |
||||
*dst_cur++ = (c30 << 4U) | (b52 >> 2U); |
||||
*dst_cur++ = (b10 << 6U) | (a50 >> 0U); |
||||
} |
||||
|
||||
*dst_cur = 0; |
||||
return size_t(dst_cur - dst_beg); |
||||
} |
||||
|
||||
size_t base64_decode(char const * src, char * dst, size_t off, size_t cnt) |
||||
{ |
||||
if (cnt == 0U) |
||||
cnt = std::strlen(src); |
||||
|
||||
return base64_decode |
||||
( |
||||
reinterpret_cast<uint8_t const *>(src), |
||||
reinterpret_cast<uint8_t *>(dst), |
||||
off, |
||||
cnt |
||||
); |
||||
} |
||||
|
||||
bool base64_valid(uint8_t const * src, size_t off, size_t cnt) |
||||
{ |
||||
/* check parameters */ |
||||
if (src == 0 || src + off == 0) |
||||
return false; |
||||
if (cnt == 0U) |
||||
cnt = std::strlen(reinterpret_cast<char const *>(src)); |
||||
if (cnt == 0U) |
||||
return false; |
||||
if (cnt & 0x3U) |
||||
return false; |
||||
|
||||
/* initialize beginning and end */ |
||||
uint8_t const * beg = src + off; |
||||
uint8_t const * end = beg + cnt; |
||||
|
||||
/* skip padding */ |
||||
if (*(end - 1U) == base64_padding) { |
||||
end--; |
||||
if (*(end - 1U) == base64_padding) |
||||
end--; |
||||
} |
||||
|
||||
/* find illegal characters */ |
||||
for (uint8_t const * iter = beg; iter < end; iter++) |
||||
if (*iter > 126U || (!base64_demapping[(uint8_t)*iter] && *iter != base64_mapping[0])) |
||||
return false; |
||||
|
||||
return true; |
||||
} |
||||
|
||||
bool base64_valid(char const * src, size_t off, size_t cnt) |
||||
{ |
||||
if (cnt == 0U) |
||||
cnt = std::strlen(src); |
||||
|
||||
return base64_valid(reinterpret_cast<uint8_t const *>(src), off, cnt); |
||||
} |
||||
|
||||
size_t base64_encode_buffer_size(size_t cnt, bool is_end_with_zero) |
||||
{ |
||||
size_t additional = static_cast<size_t>(is_end_with_zero == true); |
||||
return (cnt + 2U) / 3U * 4U + additional; |
||||
} |
||||
|
||||
size_t base64_decode_buffer_size(size_t cnt, bool is_end_with_zero) |
||||
{ |
||||
size_t additional = static_cast<size_t>(is_end_with_zero == true); |
||||
return cnt / 4U * 3U + additional; |
||||
} |
||||
|
||||
size_t base64_decode_buffer_size(size_t cnt, char const * src, bool is_end_with_zero) |
||||
{ |
||||
return base64_decode_buffer_size(cnt, reinterpret_cast<uchar const *>(src), is_end_with_zero); |
||||
} |
||||
|
||||
size_t base64_decode_buffer_size(size_t cnt, uchar const * src, bool is_end_with_zero) |
||||
{ |
||||
size_t padding_cnt = 0U; |
||||
for (uchar const * ptr = src + cnt - 1U; *ptr == base64_padding; ptr--) |
||||
padding_cnt ++; |
||||
return base64_decode_buffer_size(cnt, is_end_with_zero) - padding_cnt; |
||||
} |
||||
|
||||
/****************************************************************************
|
||||
* to_binary && binary_to |
||||
***************************************************************************/ |
||||
|
||||
template<typename _uint_t> inline size_t |
||||
to_binary(_uint_t val, uchar * cur) |
||||
{ |
||||
size_t delta = CHAR_BIT; |
||||
size_t cnt = sizeof(_uint_t); |
||||
while (cnt --> static_cast<size_t>(0U)) { |
||||
*cur++ = static_cast<uchar>(val); |
||||
val >>= delta; |
||||
} |
||||
return sizeof(_uint_t); |
||||
} |
||||
|
||||
template<> inline size_t to_binary(double val, uchar * cur) |
||||
{ |
||||
Cv64suf bit64; |
||||
bit64.f = val; |
||||
return to_binary(bit64.u, cur); |
||||
} |
||||
|
||||
template<> inline size_t to_binary(float val, uchar * cur) |
||||
{ |
||||
Cv32suf bit32; |
||||
bit32.f = val; |
||||
return to_binary(bit32.u, cur); |
||||
} |
||||
|
||||
template<typename _primitive_t> inline size_t |
||||
to_binary(uchar const * val, uchar * cur) |
||||
{ |
||||
return to_binary<_primitive_t>(*reinterpret_cast<_primitive_t const *>(val), cur); |
||||
} |
||||
|
||||
|
||||
template<typename _uint_t> inline size_t |
||||
binary_to(uchar const * cur, _uint_t & val) |
||||
{ |
||||
val = static_cast<_uint_t>(0); |
||||
for (size_t i = static_cast<size_t>(0U); i < sizeof(_uint_t); i++) |
||||
val |= (static_cast<_uint_t>(*cur++) << (i * CHAR_BIT)); |
||||
return sizeof(_uint_t); |
||||
} |
||||
|
||||
template<> inline size_t binary_to(uchar const * cur, double & val) |
||||
{ |
||||
Cv64suf bit64; |
||||
binary_to(cur, bit64.u); |
||||
val = bit64.f; |
||||
return sizeof(val); |
||||
} |
||||
|
||||
template<> inline size_t binary_to(uchar const * cur, float & val) |
||||
{ |
||||
Cv32suf bit32; |
||||
binary_to(cur, bit32.u); |
||||
val = bit32.f; |
||||
return sizeof(val); |
||||
} |
||||
|
||||
template<typename _primitive_t> inline size_t |
||||
binary_to(uchar const * cur, uchar * val) |
||||
{ |
||||
return binary_to<_primitive_t>(cur, *reinterpret_cast<_primitive_t *>(val)); |
||||
} |
||||
|
||||
/****************************************************************************
|
||||
* others |
||||
***************************************************************************/ |
||||
|
||||
std::string make_base64_header(const char * dt) |
||||
{ |
||||
std::ostringstream oss; |
||||
oss << dt << ' '; |
||||
std::string buffer(oss.str()); |
||||
CV_Assert(buffer.size() < HEADER_SIZE); |
||||
|
||||
buffer.reserve(HEADER_SIZE); |
||||
while (buffer.size() < HEADER_SIZE) |
||||
buffer += ' '; |
||||
|
||||
return buffer; |
||||
} |
||||
|
||||
bool read_base64_header(std::vector<char> const & header, std::string & dt) |
||||
{ |
||||
std::istringstream iss(header.data()); |
||||
return !!(iss >> dt);//the "std::basic_ios::operator bool" differs between C++98 and C++11. The "double not" syntax is portable and covers both cases with equivalent meaning
|
||||
} |
||||
|
||||
/****************************************************************************
|
||||
* Parser |
||||
***************************************************************************/ |
||||
|
||||
Base64ContextParser::Base64ContextParser(uchar * buffer, size_t size) |
||||
: dst_cur(buffer) |
||||
, dst_end(buffer + size) |
||||
, base64_buffer(BUFFER_LEN) |
||||
, src_beg(0) |
||||
, src_cur(0) |
||||
, src_end(0) |
||||
, binary_buffer(base64_encode_buffer_size(BUFFER_LEN)) |
||||
{ |
||||
src_beg = binary_buffer.data(); |
||||
src_cur = src_beg; |
||||
src_end = src_beg + BUFFER_LEN; |
||||
} |
||||
|
||||
Base64ContextParser::~Base64ContextParser() |
||||
{ |
||||
/* encode the rest binary data to base64 buffer */ |
||||
if (src_cur != src_beg) |
||||
flush(); |
||||
} |
||||
|
||||
Base64ContextParser & Base64ContextParser::read(const uchar * beg, const uchar * end) |
||||
{ |
||||
if (beg >= end) |
||||
return *this; |
||||
|
||||
while (beg < end) { |
||||
/* collect binary data and copy to binary buffer */ |
||||
size_t len = std::min(end - beg, src_end - src_cur); |
||||
std::memcpy(src_cur, beg, len); |
||||
beg += len; |
||||
src_cur += len; |
||||
|
||||
if (src_cur >= src_end) { |
||||
/* binary buffer is full. */ |
||||
/* decode it send result to dst */ |
||||
|
||||
CV_Assert(flush()); /* check for base64_valid */ |
||||
} |
||||
} |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
bool Base64ContextParser::flush() |
||||
{ |
||||
if ( !base64_valid(src_beg, 0U, src_cur - src_beg) ) |
||||
return false; |
||||
|
||||
if ( src_cur == src_beg ) |
||||
return true; |
||||
|
||||
uchar * buffer = binary_buffer.data(); |
||||
size_t len = base64_decode(src_beg, buffer, 0U, src_cur - src_beg); |
||||
src_cur = src_beg; |
||||
|
||||
/* unexpected error */ |
||||
CV_Assert(len != 0); |
||||
|
||||
/* buffer is full */ |
||||
CV_Assert(dst_cur + len < dst_end); |
||||
|
||||
if (dst_cur + len < dst_end) { |
||||
/* send data to dst */ |
||||
std::memcpy(dst_cur, buffer, len); |
||||
dst_cur += len; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
/****************************************************************************
|
||||
* Emitter |
||||
***************************************************************************/ |
||||
|
||||
/* A decorator for CvFileStorage
|
||||
* - no copyable |
||||
* - not safe for now |
||||
* - move constructor may be needed if C++11 |
||||
*/ |
||||
class Base64ContextEmitter |
||||
{ |
||||
public: |
||||
explicit Base64ContextEmitter(CvFileStorage * fs) |
||||
: file_storage(fs) |
||||
, binary_buffer(BUFFER_LEN) |
||||
, base64_buffer(base64_encode_buffer_size(BUFFER_LEN)) |
||||
, src_beg(0) |
||||
, src_cur(0) |
||||
, src_end(0) |
||||
{ |
||||
src_beg = binary_buffer.data(); |
||||
src_end = src_beg + BUFFER_LEN; |
||||
src_cur = src_beg; |
||||
|
||||
CV_CHECK_OUTPUT_FILE_STORAGE(fs); |
||||
|
||||
if ( fs->fmt == CV_STORAGE_FORMAT_JSON ) |
||||
{ |
||||
/* clean and break buffer */ |
||||
*fs->buffer++ = '\0'; |
||||
::icvPuts( fs, fs->buffer_start ); |
||||
fs->buffer = fs->buffer_start; |
||||
memset( file_storage->buffer_start, 0, static_cast<int>(file_storage->space) ); |
||||
::icvPuts( fs, "\"$base64$" ); |
||||
} |
||||
else |
||||
{ |
||||
::icvFSFlush(file_storage); |
||||
} |
||||
} |
||||
|
||||
~Base64ContextEmitter() |
||||
{ |
||||
/* cleaning */ |
||||
if (src_cur != src_beg) |
||||
flush(); /* encode the rest binary data to base64 buffer */ |
||||
|
||||
if ( file_storage->fmt == CV_STORAGE_FORMAT_JSON ) |
||||
{ |
||||
/* clean and break buffer */ |
||||
::icvPuts(file_storage, "\""); |
||||
file_storage->buffer = file_storage->buffer_start; |
||||
::icvFSFlush( file_storage ); |
||||
memset( file_storage->buffer_start, 0, static_cast<int>(file_storage->space) ); |
||||
file_storage->buffer = file_storage->buffer_start; |
||||
} |
||||
} |
||||
|
||||
Base64ContextEmitter & write(const uchar * beg, const uchar * end) |
||||
{ |
||||
if (beg >= end) |
||||
return *this; |
||||
|
||||
while (beg < end) { |
||||
/* collect binary data and copy to binary buffer */ |
||||
size_t len = std::min(end - beg, src_end - src_cur); |
||||
std::memcpy(src_cur, beg, len); |
||||
beg += len; |
||||
src_cur += len; |
||||
|
||||
if (src_cur >= src_end) { |
||||
/* binary buffer is full. */ |
||||
/* encode it to base64 and send result to fs */ |
||||
flush(); |
||||
} |
||||
} |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
/*
|
||||
* a convertor must provide : |
||||
* - `operator >> (uchar * & dst)` for writting current binary data to `dst` and moving to next data. |
||||
* - `operator bool` for checking if current loaction is valid and not the end. |
||||
*/ |
||||
template<typename _to_binary_convertor_t> inline |
||||
Base64ContextEmitter & write(_to_binary_convertor_t & convertor) |
||||
{ |
||||
static const size_t BUFFER_MAX_LEN = 1024U; |
||||
|
||||
std::vector<uchar> buffer(BUFFER_MAX_LEN); |
||||
uchar * beg = buffer.data(); |
||||
uchar * end = beg; |
||||
|
||||
while (convertor) { |
||||
convertor >> end; |
||||
write(beg, end); |
||||
end = beg; |
||||
} |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
bool flush() |
||||
{ |
||||
/* controll line width, so on. */ |
||||
size_t len = base64_encode(src_beg, base64_buffer.data(), 0U, src_cur - src_beg); |
||||
if (len == 0U) |
||||
return false; |
||||
|
||||
src_cur = src_beg; |
||||
{ |
||||
if ( file_storage->fmt == CV_STORAGE_FORMAT_JSON ) |
||||
{ |
||||
::icvPuts(file_storage, (const char*)base64_buffer.data()); |
||||
} |
||||
else |
||||
{ |
||||
const char newline[] = "\n"; |
||||
char space[80]; |
||||
int ident = file_storage->struct_indent; |
||||
memset(space, ' ', static_cast<int>(ident)); |
||||
space[ident] = '\0'; |
||||
|
||||
::icvPuts(file_storage, space); |
||||
::icvPuts(file_storage, (const char*)base64_buffer.data()); |
||||
::icvPuts(file_storage, newline); |
||||
::icvFSFlush(file_storage); |
||||
} |
||||
|
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
private: |
||||
/* because of Base64, we must keep its length a multiple of 3 */ |
||||
static const size_t BUFFER_LEN = 48U; |
||||
// static_assert(BUFFER_LEN % 3 == 0, "BUFFER_LEN is invalid");
|
||||
|
||||
private: |
||||
CvFileStorage * file_storage; |
||||
|
||||
std::vector<uchar> binary_buffer; |
||||
std::vector<uchar> base64_buffer; |
||||
uchar * src_beg; |
||||
uchar * src_cur; |
||||
uchar * src_end; |
||||
}; |
||||
|
||||
|
||||
class RawDataToBinaryConvertor |
||||
{ |
||||
public: |
||||
|
||||
RawDataToBinaryConvertor(const void* src, int len, const std::string & dt) |
||||
: beg(reinterpret_cast<const uchar *>(src)) |
||||
, cur(0) |
||||
, end(0) |
||||
{ |
||||
CV_Assert(src); |
||||
CV_Assert(!dt.empty()); |
||||
CV_Assert(len > 0); |
||||
|
||||
/* calc step and to_binary_funcs */ |
||||
make_to_binary_funcs(dt); |
||||
|
||||
end = beg; |
||||
cur = beg; |
||||
|
||||
step = ::icvCalcStructSize(dt.c_str(), 0); |
||||
end = beg + step * static_cast<size_t>(len); |
||||
} |
||||
|
||||
inline RawDataToBinaryConvertor & operator >>(uchar * & dst) |
||||
{ |
||||
CV_DbgAssert(*this); |
||||
|
||||
for (size_t i = 0U, n = to_binary_funcs.size(); i < n; i++) { |
||||
elem_to_binary_t & pack = to_binary_funcs[i]; |
||||
pack.func(cur + pack.offset, dst + pack.offset); |
||||
} |
||||
cur += step; |
||||
dst += step; |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
inline operator bool() const |
||||
{ |
||||
return cur < end; |
||||
} |
||||
|
||||
private: |
||||
typedef size_t(*to_binary_t)(const uchar *, uchar *); |
||||
struct elem_to_binary_t |
||||
{ |
||||
size_t offset; |
||||
to_binary_t func; |
||||
}; |
||||
|
||||
private: |
||||
void make_to_binary_funcs(const std::string &dt) |
||||
{ |
||||
size_t cnt = 0; |
||||
size_t offset = 0; |
||||
char type = '\0'; |
||||
|
||||
std::istringstream iss(dt); |
||||
while (!iss.eof()) { |
||||
if (!(iss >> cnt)) { |
||||
iss.clear(); |
||||
cnt = 1; |
||||
} |
||||
CV_Assert(cnt > 0U); |
||||
if (!(iss >> type)) |
||||
break; |
||||
|
||||
while (cnt-- > 0) |
||||
{ |
||||
elem_to_binary_t pack; |
||||
|
||||
size_t size = 0; |
||||
switch (type) |
||||
{ |
||||
case 'u': |
||||
case 'c': |
||||
size = sizeof(uchar); |
||||
pack.func = to_binary<uchar>; |
||||
break; |
||||
case 'w': |
||||
case 's': |
||||
size = sizeof(ushort); |
||||
pack.func = to_binary<ushort>; |
||||
break; |
||||
case 'i': |
||||
size = sizeof(uint); |
||||
pack.func = to_binary<uint>; |
||||
break; |
||||
case 'f': |
||||
size = sizeof(float); |
||||
pack.func = to_binary<float>; |
||||
break; |
||||
case 'd': |
||||
size = sizeof(double); |
||||
pack.func = to_binary<double>; |
||||
break; |
||||
case 'r': |
||||
default: { CV_Assert(!"type not support"); break; } |
||||
}; |
||||
|
||||
offset = static_cast<size_t>(cvAlign(static_cast<int>(offset), static_cast<int>(size))); |
||||
pack.offset = offset; |
||||
offset += size; |
||||
|
||||
to_binary_funcs.push_back(pack); |
||||
} |
||||
} |
||||
|
||||
CV_Assert(iss.eof()); |
||||
} |
||||
|
||||
private: |
||||
const uchar * beg; |
||||
const uchar * cur; |
||||
const uchar * end; |
||||
|
||||
size_t step; |
||||
std::vector<elem_to_binary_t> to_binary_funcs; |
||||
}; |
||||
|
||||
class BinaryToCvSeqConvertor |
||||
{ |
||||
public: |
||||
BinaryToCvSeqConvertor(const void* src, int len, const char* dt) |
||||
: cur(reinterpret_cast<const uchar *>(src)) |
||||
, beg(reinterpret_cast<const uchar *>(src)) |
||||
, end(reinterpret_cast<const uchar *>(src)) |
||||
{ |
||||
CV_Assert(src); |
||||
CV_Assert(dt); |
||||
CV_Assert(len >= 0); |
||||
|
||||
/* calc binary_to_funcs */ |
||||
make_funcs(dt); |
||||
functor_iter = binary_to_funcs.begin(); |
||||
|
||||
step = ::icvCalcStructSize(dt, 0); |
||||
end = beg + step * static_cast<size_t>(len); |
||||
} |
||||
|
||||
inline BinaryToCvSeqConvertor & operator >> (CvFileNode & dst) |
||||
{ |
||||
CV_DbgAssert(*this); |
||||
|
||||
/* get current data */ |
||||
union
|
||||
{ |
||||
uchar mem[sizeof(double)]; |
||||
uchar u; |
||||
char b; |
||||
ushort w; |
||||
short s; |
||||
int i; |
||||
float f; |
||||
double d; |
||||
} buffer; /* for GCC -Wstrict-aliasing */ |
||||
std::memset(buffer.mem, 0, sizeof(buffer)); |
||||
functor_iter->func(cur + functor_iter->offset, buffer.mem); |
||||
|
||||
/* set node::data */ |
||||
switch (functor_iter->cv_type) |
||||
{ |
||||
case CV_8U : { dst.data.i = cv::saturate_cast<int> (buffer.u); break;} |
||||
case CV_8S : { dst.data.i = cv::saturate_cast<int> (buffer.b); break;} |
||||
case CV_16U: { dst.data.i = cv::saturate_cast<int> (buffer.w); break;} |
||||
case CV_16S: { dst.data.i = cv::saturate_cast<int> (buffer.s); break;} |
||||
case CV_32S: { dst.data.i = cv::saturate_cast<int> (buffer.i); break;} |
||||
case CV_32F: { dst.data.f = cv::saturate_cast<double>(buffer.f); break;} |
||||
case CV_64F: { dst.data.f = cv::saturate_cast<double>(buffer.d); break;} |
||||
default: break; |
||||
} |
||||
|
||||
/* set node::tag */ |
||||
switch (functor_iter->cv_type) |
||||
{ |
||||
case CV_8U : |
||||
case CV_8S : |
||||
case CV_16U: |
||||
case CV_16S: |
||||
case CV_32S: { dst.tag = CV_NODE_INT; /*std::printf("%i,", dst.data.i);*/ break; } |
||||
case CV_32F: |
||||
case CV_64F: { dst.tag = CV_NODE_REAL; /*std::printf("%.1f,", dst.data.f);*/ break; } |
||||
default: break; |
||||
} |
||||
|
||||
/* check if end */ |
||||
if (++functor_iter == binary_to_funcs.end()) { |
||||
functor_iter = binary_to_funcs.begin(); |
||||
cur += step; |
||||
} |
||||
|
||||
return *this; |
||||
} |
||||
|
||||
inline operator bool() const |
||||
{ |
||||
return cur < end; |
||||
} |
||||
|
||||
private: |
||||
typedef size_t(*binary_to_t)(uchar const *, uchar *); |
||||
struct binary_to_filenode_t |
||||
{ |
||||
size_t cv_type; |
||||
size_t offset; |
||||
binary_to_t func; |
||||
}; |
||||
|
||||
private: |
||||
void make_funcs(const char* dt) |
||||
{ |
||||
size_t cnt = 0; |
||||
char type = '\0'; |
||||
size_t offset = 0; |
||||
|
||||
std::istringstream iss(dt); |
||||
while (!iss.eof()) { |
||||
if (!(iss >> cnt)) { |
||||
iss.clear(); |
||||
cnt = 1; |
||||
} |
||||
CV_Assert(cnt > 0U); |
||||
if (!(iss >> type)) |
||||
break; |
||||
|
||||
while (cnt-- > 0) |
||||
{ |
||||
binary_to_filenode_t pack; |
||||
|
||||
/* set func and offset */ |
||||
size_t size = 0; |
||||
switch (type) |
||||
{ |
||||
case 'u': |
||||
case 'c': |
||||
size = sizeof(uchar); |
||||
pack.func = binary_to<uchar>; |
||||
break; |
||||
case 'w': |
||||
case 's': |
||||
size = sizeof(ushort); |
||||
pack.func = binary_to<ushort>; |
||||
break; |
||||
case 'i': |
||||
size = sizeof(uint); |
||||
pack.func = binary_to<uint>; |
||||
break; |
||||
case 'f': |
||||
size = sizeof(float); |
||||
pack.func = binary_to<float>; |
||||
break; |
||||
case 'd': |
||||
size = sizeof(double); |
||||
pack.func = binary_to<double>; |
||||
break; |
||||
case 'r': |
||||
default: { CV_Assert(!"type not support"); break; } |
||||
}; // need a better way for outputting error.
|
||||
|
||||
offset = static_cast<size_t>(cvAlign(static_cast<int>(offset), static_cast<int>(size))); |
||||
pack.offset = offset; |
||||
offset += size; |
||||
|
||||
/* set type */ |
||||
switch (type) |
||||
{ |
||||
case 'u': { pack.cv_type = CV_8U ; break; } |
||||
case 'c': { pack.cv_type = CV_8S ; break; } |
||||
case 'w': { pack.cv_type = CV_16U; break; } |
||||
case 's': { pack.cv_type = CV_16S; break; } |
||||
case 'i': { pack.cv_type = CV_32S; break; } |
||||
case 'f': { pack.cv_type = CV_32F; break; } |
||||
case 'd': { pack.cv_type = CV_64F; break; } |
||||
case 'r': |
||||
default: { CV_Assert(!"type is not support"); break; } |
||||
} // need a better way for outputting error.
|
||||
|
||||
binary_to_funcs.push_back(pack); |
||||
} |
||||
} |
||||
|
||||
CV_Assert(iss.eof()); |
||||
CV_Assert(binary_to_funcs.size()); |
||||
} |
||||
|
||||
private: |
||||
|
||||
const uchar * cur; |
||||
const uchar * beg; |
||||
const uchar * end; |
||||
|
||||
size_t step; |
||||
std::vector<binary_to_filenode_t> binary_to_funcs; |
||||
std::vector<binary_to_filenode_t>::iterator functor_iter; |
||||
}; |
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Wrapper |
||||
***************************************************************************/ |
||||
|
||||
Base64Writer::Base64Writer(::CvFileStorage * fs) |
||||
: emitter(new Base64ContextEmitter(fs)) |
||||
, data_type_string() |
||||
{ |
||||
CV_CHECK_OUTPUT_FILE_STORAGE(fs); |
||||
} |
||||
|
||||
void Base64Writer::write(const void* _data, size_t len, const char* dt) |
||||
{ |
||||
check_dt(dt); |
||||
RawDataToBinaryConvertor convertor(_data, static_cast<int>(len), data_type_string); |
||||
emitter->write(convertor); |
||||
} |
||||
|
||||
template<typename _to_binary_convertor_t> inline |
||||
void Base64Writer::write(_to_binary_convertor_t & convertor, const char* dt) |
||||
{ |
||||
check_dt(dt); |
||||
emitter->write(convertor); |
||||
} |
||||
|
||||
Base64Writer::~Base64Writer() |
||||
{ |
||||
delete emitter; |
||||
} |
||||
|
||||
void Base64Writer::check_dt(const char* dt) |
||||
{ |
||||
if ( dt == 0 ) |
||||
CV_Error( CV_StsBadArg, "Invalid \'dt\'." ); |
||||
else if (data_type_string.empty()) { |
||||
data_type_string = dt; |
||||
|
||||
/* output header */ |
||||
std::string buffer = make_base64_header(dt); |
||||
const uchar * beg = reinterpret_cast<const uchar *>(buffer.data()); |
||||
const uchar * end = beg + buffer.size(); |
||||
|
||||
emitter->write(beg, end); |
||||
} else if ( data_type_string != dt ) |
||||
CV_Error( CV_StsBadArg, "\'dt\' does not match." ); |
||||
} |
||||
|
||||
|
||||
void make_seq(void * binary, int elem_cnt, const char * dt, ::CvSeq & seq) |
||||
{ |
||||
::CvFileNode node; |
||||
node.info = 0; |
||||
BinaryToCvSeqConvertor convertor(binary, elem_cnt, dt); |
||||
while (convertor) { |
||||
convertor >> node; |
||||
cvSeqPush(&seq, &node); |
||||
} |
||||
} |
||||
|
||||
} // base64::
|
||||
|
||||
/****************************************************************************
|
||||
* Interface |
||||
***************************************************************************/ |
||||
|
||||
CV_IMPL void cvWriteRawDataBase64(::CvFileStorage* fs, const void* _data, int len, const char* dt) |
||||
{ |
||||
CV_Assert(fs); |
||||
CV_CHECK_OUTPUT_FILE_STORAGE(fs); |
||||
|
||||
check_if_write_struct_is_delayed( fs, true ); |
||||
|
||||
if ( fs->state_of_writing_base64 == base64::fs::Uncertain ) |
||||
{ |
||||
switch_to_Base64_state( fs, base64::fs::InUse ); |
||||
} |
||||
else if ( fs->state_of_writing_base64 != base64::fs::InUse ) |
||||
{ |
||||
CV_Error( CV_StsError, "Base64 should not be used at present." ); |
||||
} |
||||
|
||||
fs->base64_writer->write(_data, len, dt); |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,669 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
|
||||
#include "precomp.hpp" |
||||
#include "persistence.hpp" |
||||
|
||||
///////////////////////// new C++ interface for CvFileStorage ///////////////////////////
|
||||
|
||||
namespace cv |
||||
{ |
||||
|
||||
static void getElemSize( const String& fmt, size_t& elemSize, size_t& cn ) |
||||
{ |
||||
const char* dt = fmt.c_str(); |
||||
cn = 1; |
||||
if( cv_isdigit(dt[0]) ) |
||||
{ |
||||
cn = dt[0] - '0'; |
||||
dt++; |
||||
} |
||||
char c = dt[0]; |
||||
elemSize = cn*(c == 'u' || c == 'c' ? sizeof(uchar) : c == 'w' || c == 's' ? sizeof(ushort) : |
||||
c == 'i' ? sizeof(int) : c == 'f' ? sizeof(float) : c == 'd' ? sizeof(double) : |
||||
c == 'r' ? sizeof(void*) : (size_t)0); |
||||
} |
||||
|
||||
FileStorage::FileStorage() |
||||
{ |
||||
state = UNDEFINED; |
||||
} |
||||
|
||||
FileStorage::FileStorage(const String& filename, int flags, const String& encoding) |
||||
{ |
||||
state = UNDEFINED; |
||||
open( filename, flags, encoding ); |
||||
} |
||||
|
||||
FileStorage::FileStorage(CvFileStorage* _fs, bool owning) |
||||
{ |
||||
if (owning) fs.reset(_fs); |
||||
else fs = Ptr<CvFileStorage>(Ptr<CvFileStorage>(), _fs); |
||||
|
||||
state = _fs ? NAME_EXPECTED + INSIDE_MAP : UNDEFINED; |
||||
} |
||||
|
||||
FileStorage::~FileStorage() |
||||
{ |
||||
while( structs.size() > 0 ) |
||||
{ |
||||
cvEndWriteStruct(fs); |
||||
structs.pop_back(); |
||||
} |
||||
} |
||||
|
||||
bool FileStorage::open(const String& filename, int flags, const String& encoding) |
||||
{ |
||||
CV_INSTRUMENT_REGION() |
||||
|
||||
release(); |
||||
fs.reset(cvOpenFileStorage( filename.c_str(), 0, flags, |
||||
!encoding.empty() ? encoding.c_str() : 0)); |
||||
bool ok = isOpened(); |
||||
state = ok ? NAME_EXPECTED + INSIDE_MAP : UNDEFINED; |
||||
return ok; |
||||
} |
||||
|
||||
bool FileStorage::isOpened() const |
||||
{ |
||||
return fs && fs->is_opened; |
||||
} |
||||
|
||||
void FileStorage::release() |
||||
{ |
||||
fs.release(); |
||||
structs.clear(); |
||||
state = UNDEFINED; |
||||
} |
||||
|
||||
String FileStorage::releaseAndGetString() |
||||
{ |
||||
String buf; |
||||
if( fs && fs->outbuf ) |
||||
icvClose(fs, &buf); |
||||
|
||||
release(); |
||||
return buf; |
||||
} |
||||
|
||||
FileNode FileStorage::root(int streamidx) const |
||||
{ |
||||
return isOpened() ? FileNode(fs, cvGetRootFileNode(fs, streamidx)) : FileNode(); |
||||
} |
||||
|
||||
int FileStorage::getFormat() const |
||||
{ |
||||
CV_Assert(!fs.empty()); |
||||
return fs->fmt & FORMAT_MASK; |
||||
} |
||||
|
||||
FileStorage& operator << (FileStorage& fs, const String& str) |
||||
{ |
||||
CV_TRACE_REGION_VERBOSE(); |
||||
|
||||
enum { NAME_EXPECTED = FileStorage::NAME_EXPECTED, |
||||
VALUE_EXPECTED = FileStorage::VALUE_EXPECTED, |
||||
INSIDE_MAP = FileStorage::INSIDE_MAP }; |
||||
const char* _str = str.c_str(); |
||||
if( !fs.isOpened() || !_str ) |
||||
return fs; |
||||
if( *_str == '}' || *_str == ']' ) |
||||
{ |
||||
if( fs.structs.empty() ) |
||||
CV_Error_( CV_StsError, ("Extra closing '%c'", *_str) ); |
||||
if( (*_str == ']' ? '[' : '{') != fs.structs.back() ) |
||||
CV_Error_( CV_StsError, |
||||
("The closing '%c' does not match the opening '%c'", *_str, fs.structs.back())); |
||||
fs.structs.pop_back(); |
||||
fs.state = fs.structs.empty() || fs.structs.back() == '{' ? |
||||
INSIDE_MAP + NAME_EXPECTED : VALUE_EXPECTED; |
||||
cvEndWriteStruct( *fs ); |
||||
fs.elname = String(); |
||||
} |
||||
else if( fs.state == NAME_EXPECTED + INSIDE_MAP ) |
||||
{ |
||||
if (!cv_isalpha(*_str) && *_str != '_') |
||||
CV_Error_( CV_StsError, ("Incorrect element name %s", _str) ); |
||||
fs.elname = str; |
||||
fs.state = VALUE_EXPECTED + INSIDE_MAP; |
||||
} |
||||
else if( (fs.state & 3) == VALUE_EXPECTED ) |
||||
{ |
||||
if( *_str == '{' || *_str == '[' ) |
||||
{ |
||||
fs.structs.push_back(*_str); |
||||
int flags = *_str++ == '{' ? CV_NODE_MAP : CV_NODE_SEQ; |
||||
fs.state = flags == CV_NODE_MAP ? INSIDE_MAP + |
||||
NAME_EXPECTED : VALUE_EXPECTED; |
||||
if( *_str == ':' ) |
||||
{ |
||||
flags |= CV_NODE_FLOW; |
||||
_str++; |
||||
} |
||||
cvStartWriteStruct( *fs, fs.elname.size() > 0 ? fs.elname.c_str() : 0, |
||||
flags, *_str ? _str : 0 ); |
||||
fs.elname = String(); |
||||
} |
||||
else |
||||
{ |
||||
write( fs, fs.elname, (_str[0] == '\\' && (_str[1] == '{' || _str[1] == '}' || |
||||
_str[1] == '[' || _str[1] == ']')) ? String(_str+1) : str ); |
||||
if( fs.state == INSIDE_MAP + VALUE_EXPECTED ) |
||||
fs.state = INSIDE_MAP + NAME_EXPECTED; |
||||
} |
||||
} |
||||
else |
||||
CV_Error( CV_StsError, "Invalid fs.state" ); |
||||
return fs; |
||||
} |
||||
|
||||
|
||||
void FileStorage::writeRaw( const String& fmt, const uchar* vec, size_t len ) |
||||
{ |
||||
if( !isOpened() ) |
||||
return; |
||||
size_t elemSize, cn; |
||||
getElemSize( fmt, elemSize, cn ); |
||||
CV_Assert( len % elemSize == 0 ); |
||||
cvWriteRawData( fs, vec, (int)(len/elemSize), fmt.c_str()); |
||||
} |
||||
|
||||
|
||||
void FileStorage::writeObj( const String& name, const void* obj ) |
||||
{ |
||||
if( !isOpened() ) |
||||
return; |
||||
cvWrite( fs, name.size() > 0 ? name.c_str() : 0, obj ); |
||||
} |
||||
|
||||
void FileStorage::write( const String& name, double val ) |
||||
{ |
||||
*this << name << val; |
||||
} |
||||
|
||||
void FileStorage::write( const String& name, const String& val ) |
||||
{ |
||||
*this << name << val; |
||||
} |
||||
|
||||
void FileStorage::write( const String& name, InputArray val ) |
||||
{ |
||||
*this << name << val.getMat(); |
||||
} |
||||
|
||||
void FileStorage::writeComment( const String& comment, bool append ) |
||||
{ |
||||
cvWriteComment(fs, comment.c_str(), append ? 1 : 0); |
||||
} |
||||
|
||||
String FileStorage::getDefaultObjectName(const String& _filename) |
||||
{ |
||||
static const char* stubname = "unnamed"; |
||||
const char* filename = _filename.c_str(); |
||||
const char* ptr2 = filename + _filename.size(); |
||||
const char* ptr = ptr2 - 1; |
||||
cv::AutoBuffer<char> name_buf(_filename.size()+1); |
||||
|
||||
while( ptr >= filename && *ptr != '\\' && *ptr != '/' && *ptr != ':' ) |
||||
{ |
||||
if( *ptr == '.' && (!*ptr2 || strncmp(ptr2, ".gz", 3) == 0) ) |
||||
ptr2 = ptr; |
||||
ptr--; |
||||
} |
||||
ptr++; |
||||
if( ptr == ptr2 ) |
||||
CV_Error( CV_StsBadArg, "Invalid filename" ); |
||||
|
||||
char* name = name_buf; |
||||
|
||||
// name must start with letter or '_'
|
||||
if( !cv_isalpha(*ptr) && *ptr!= '_' ){ |
||||
*name++ = '_'; |
||||
} |
||||
|
||||
while( ptr < ptr2 ) |
||||
{ |
||||
char c = *ptr++; |
||||
if( !cv_isalnum(c) && c != '-' && c != '_' ) |
||||
c = '_'; |
||||
*name++ = c; |
||||
} |
||||
*name = '\0'; |
||||
name = name_buf; |
||||
if( strcmp( name, "_" ) == 0 ) |
||||
strcpy( name, stubname ); |
||||
return String(name); |
||||
} |
||||
|
||||
FileNode FileStorage::operator[](const String& nodename) const |
||||
{ |
||||
return FileNode(fs, cvGetFileNodeByName(fs, 0, nodename.c_str())); |
||||
} |
||||
|
||||
FileNode FileStorage::operator[](const char* nodename) const |
||||
{ |
||||
return FileNode(fs, cvGetFileNodeByName(fs, 0, nodename)); |
||||
} |
||||
|
||||
FileNode FileNode::operator[](const String& nodename) const |
||||
{ |
||||
return FileNode(fs, cvGetFileNodeByName(fs, node, nodename.c_str())); |
||||
} |
||||
|
||||
FileNode FileNode::operator[](const char* nodename) const |
||||
{ |
||||
return FileNode(fs, cvGetFileNodeByName(fs, node, nodename)); |
||||
} |
||||
|
||||
FileNode FileNode::operator[](int i) const |
||||
{ |
||||
return isSeq() ? FileNode(fs, (CvFileNode*)cvGetSeqElem(node->data.seq, i)) : |
||||
i == 0 ? *this : FileNode(); |
||||
} |
||||
|
||||
String FileNode::name() const |
||||
{ |
||||
const char* str; |
||||
return !node || (str = cvGetFileNodeName(node)) == 0 ? String() : String(str); |
||||
} |
||||
|
||||
void* FileNode::readObj() const |
||||
{ |
||||
if( !fs || !node ) |
||||
return 0; |
||||
return cvRead( (CvFileStorage*)fs, (CvFileNode*)node ); |
||||
} |
||||
|
||||
static const FileNodeIterator::SeqReader emptyReader = {0, 0, 0, 0, 0, 0, 0, 0}; |
||||
|
||||
FileNodeIterator::FileNodeIterator() |
||||
{ |
||||
fs = 0; |
||||
container = 0; |
||||
reader = emptyReader; |
||||
remaining = 0; |
||||
} |
||||
|
||||
FileNodeIterator::FileNodeIterator(const CvFileStorage* _fs, |
||||
const CvFileNode* _node, size_t _ofs) |
||||
{ |
||||
reader = emptyReader; |
||||
if( _fs && _node && CV_NODE_TYPE(_node->tag) != CV_NODE_NONE ) |
||||
{ |
||||
int node_type = _node->tag & FileNode::TYPE_MASK; |
||||
fs = _fs; |
||||
container = _node; |
||||
if( !(_node->tag & FileNode::USER) && (node_type == FileNode::SEQ || node_type == FileNode::MAP) ) |
||||
{ |
||||
cvStartReadSeq( _node->data.seq, (CvSeqReader*)&reader ); |
||||
remaining = FileNode(_fs, _node).size(); |
||||
} |
||||
else |
||||
{ |
||||
reader.ptr = (schar*)_node; |
||||
reader.seq = 0; |
||||
remaining = 1; |
||||
} |
||||
(*this) += (int)_ofs; |
||||
} |
||||
else |
||||
{ |
||||
fs = 0; |
||||
container = 0; |
||||
remaining = 0; |
||||
} |
||||
} |
||||
|
||||
FileNodeIterator::FileNodeIterator(const FileNodeIterator& it) |
||||
{ |
||||
fs = it.fs; |
||||
container = it.container; |
||||
reader = it.reader; |
||||
remaining = it.remaining; |
||||
} |
||||
|
||||
FileNodeIterator& FileNodeIterator::operator ++() |
||||
{ |
||||
if( remaining > 0 ) |
||||
{ |
||||
if( reader.seq ) |
||||
{ |
||||
if( ((reader).ptr += (((CvSeq*)reader.seq)->elem_size)) >= (reader).block_max ) |
||||
{ |
||||
cvChangeSeqBlock( (CvSeqReader*)&(reader), 1 ); |
||||
} |
||||
} |
||||
remaining--; |
||||
} |
||||
return *this; |
||||
} |
||||
|
||||
FileNodeIterator FileNodeIterator::operator ++(int) |
||||
{ |
||||
FileNodeIterator it = *this; |
||||
++(*this); |
||||
return it; |
||||
} |
||||
|
||||
FileNodeIterator& FileNodeIterator::operator --() |
||||
{ |
||||
if( remaining < FileNode(fs, container).size() ) |
||||
{ |
||||
if( reader.seq ) |
||||
{ |
||||
if( ((reader).ptr -= (((CvSeq*)reader.seq)->elem_size)) < (reader).block_min ) |
||||
{ |
||||
cvChangeSeqBlock( (CvSeqReader*)&(reader), -1 ); |
||||
} |
||||
} |
||||
remaining++; |
||||
} |
||||
return *this; |
||||
} |
||||
|
||||
FileNodeIterator FileNodeIterator::operator --(int) |
||||
{ |
||||
FileNodeIterator it = *this; |
||||
--(*this); |
||||
return it; |
||||
} |
||||
|
||||
FileNodeIterator& FileNodeIterator::operator += (int ofs) |
||||
{ |
||||
if( ofs == 0 ) |
||||
return *this; |
||||
if( ofs > 0 ) |
||||
ofs = std::min(ofs, (int)remaining); |
||||
else |
||||
{ |
||||
size_t count = FileNode(fs, container).size(); |
||||
ofs = (int)(remaining - std::min(remaining - ofs, count)); |
||||
} |
||||
remaining -= ofs; |
||||
if( reader.seq ) |
||||
cvSetSeqReaderPos( (CvSeqReader*)&reader, ofs, 1 ); |
||||
return *this; |
||||
} |
||||
|
||||
FileNodeIterator& FileNodeIterator::operator -= (int ofs) |
||||
{ |
||||
return operator += (-ofs); |
||||
} |
||||
|
||||
|
||||
FileNodeIterator& FileNodeIterator::readRaw( const String& fmt, uchar* vec, size_t maxCount ) |
||||
{ |
||||
if( fs && container && remaining > 0 ) |
||||
{ |
||||
size_t elem_size, cn; |
||||
getElemSize( fmt, elem_size, cn ); |
||||
CV_Assert( elem_size > 0 ); |
||||
size_t count = std::min(remaining, maxCount); |
||||
|
||||
if( reader.seq ) |
||||
{ |
||||
cvReadRawDataSlice( fs, (CvSeqReader*)&reader, (int)count, vec, fmt.c_str() ); |
||||
remaining -= count*cn; |
||||
} |
||||
else |
||||
{ |
||||
cvReadRawData( fs, container, vec, fmt.c_str() ); |
||||
remaining = 0; |
||||
} |
||||
} |
||||
return *this; |
||||
} |
||||
|
||||
|
||||
void write( FileStorage& fs, const String& name, int value ) |
||||
{ cvWriteInt( *fs, name.size() ? name.c_str() : 0, value ); } |
||||
|
||||
void write( FileStorage& fs, const String& name, float value ) |
||||
{ cvWriteReal( *fs, name.size() ? name.c_str() : 0, value ); } |
||||
|
||||
void write( FileStorage& fs, const String& name, double value ) |
||||
{ cvWriteReal( *fs, name.size() ? name.c_str() : 0, value ); } |
||||
|
||||
void write( FileStorage& fs, const String& name, const String& value ) |
||||
{ cvWriteString( *fs, name.size() ? name.c_str() : 0, value.c_str() ); } |
||||
|
||||
void writeScalar(FileStorage& fs, int value ) |
||||
{ cvWriteInt( *fs, 0, value ); } |
||||
|
||||
void writeScalar(FileStorage& fs, float value ) |
||||
{ cvWriteReal( *fs, 0, value ); } |
||||
|
||||
void writeScalar(FileStorage& fs, double value ) |
||||
{ cvWriteReal( *fs, 0, value ); } |
||||
|
||||
void writeScalar(FileStorage& fs, const String& value ) |
||||
{ cvWriteString( *fs, 0, value.c_str() ); } |
||||
|
||||
|
||||
void write( FileStorage& fs, const String& name, const Mat& value ) |
||||
{ |
||||
if( value.dims <= 2 ) |
||||
{ |
||||
CvMat mat = value; |
||||
cvWrite( *fs, name.size() ? name.c_str() : 0, &mat ); |
||||
} |
||||
else |
||||
{ |
||||
CvMatND mat = value; |
||||
cvWrite( *fs, name.size() ? name.c_str() : 0, &mat ); |
||||
} |
||||
} |
||||
|
||||
// TODO: the 4 functions below need to be implemented more efficiently
|
||||
void write( FileStorage& fs, const String& name, const SparseMat& value ) |
||||
{ |
||||
Ptr<CvSparseMat> mat(cvCreateSparseMat(value)); |
||||
cvWrite( *fs, name.size() ? name.c_str() : 0, mat ); |
||||
} |
||||
|
||||
|
||||
internal::WriteStructContext::WriteStructContext(FileStorage& _fs, |
||||
const String& name, int flags, const String& typeName) : fs(&_fs) |
||||
{ |
||||
cvStartWriteStruct(**fs, !name.empty() ? name.c_str() : 0, flags, |
||||
!typeName.empty() ? typeName.c_str() : 0); |
||||
fs->elname = String(); |
||||
if ((flags & FileNode::TYPE_MASK) == FileNode::SEQ) |
||||
{ |
||||
fs->state = FileStorage::VALUE_EXPECTED; |
||||
fs->structs.push_back('['); |
||||
} |
||||
else |
||||
{ |
||||
fs->state = FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP; |
||||
fs->structs.push_back('{'); |
||||
} |
||||
} |
||||
|
||||
internal::WriteStructContext::~WriteStructContext() |
||||
{ |
||||
cvEndWriteStruct(**fs); |
||||
fs->structs.pop_back(); |
||||
fs->state = fs->structs.empty() || fs->structs.back() == '{' ? |
||||
FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP : |
||||
FileStorage::VALUE_EXPECTED; |
||||
fs->elname = String(); |
||||
} |
||||
|
||||
|
||||
void read( const FileNode& node, Mat& mat, const Mat& default_mat ) |
||||
{ |
||||
if( node.empty() ) |
||||
{ |
||||
default_mat.copyTo(mat); |
||||
return; |
||||
} |
||||
void* obj = cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node); |
||||
if(CV_IS_MAT_HDR_Z(obj)) |
||||
{ |
||||
cvarrToMat(obj).copyTo(mat); |
||||
cvReleaseMat((CvMat**)&obj); |
||||
} |
||||
else if(CV_IS_MATND_HDR(obj)) |
||||
{ |
||||
cvarrToMat(obj).copyTo(mat); |
||||
cvReleaseMatND((CvMatND**)&obj); |
||||
} |
||||
else |
||||
{ |
||||
cvRelease(&obj); |
||||
CV_Error(CV_StsBadArg, "Unknown array type"); |
||||
} |
||||
} |
||||
|
||||
void read( const FileNode& node, SparseMat& mat, const SparseMat& default_mat ) |
||||
{ |
||||
if( node.empty() ) |
||||
{ |
||||
default_mat.copyTo(mat); |
||||
return; |
||||
} |
||||
Ptr<CvSparseMat> m((CvSparseMat*)cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node)); |
||||
CV_Assert(CV_IS_SPARSE_MAT(m)); |
||||
m->copyToSparseMat(mat); |
||||
} |
||||
|
||||
CV_EXPORTS void read(const FileNode& node, KeyPoint& value, const KeyPoint& default_value) |
||||
{ |
||||
if( node.empty() ) |
||||
{ |
||||
value = default_value; |
||||
return; |
||||
} |
||||
node >> value; |
||||
} |
||||
|
||||
CV_EXPORTS void read(const FileNode& node, DMatch& value, const DMatch& default_value) |
||||
{ |
||||
if( node.empty() ) |
||||
{ |
||||
value = default_value; |
||||
return; |
||||
} |
||||
node >> value; |
||||
} |
||||
|
||||
#ifdef CV__LEGACY_PERSISTENCE |
||||
void write( FileStorage& fs, const String& name, const std::vector<KeyPoint>& vec) |
||||
{ |
||||
// from template implementation
|
||||
cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ); |
||||
write(fs, vec); |
||||
} |
||||
|
||||
void read(const FileNode& node, std::vector<KeyPoint>& keypoints) |
||||
{ |
||||
FileNode first_node = *(node.begin()); |
||||
if (first_node.isSeq()) |
||||
{ |
||||
// modern scheme
|
||||
#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED |
||||
FileNodeIterator it = node.begin(); |
||||
size_t total = (size_t)it.remaining; |
||||
keypoints.resize(total); |
||||
for (size_t i = 0; i < total; ++i, ++it) |
||||
{ |
||||
(*it) >> keypoints[i]; |
||||
} |
||||
#else |
||||
FileNodeIterator it = node.begin(); |
||||
it >> keypoints; |
||||
#endif |
||||
return; |
||||
} |
||||
keypoints.clear(); |
||||
FileNodeIterator it = node.begin(), it_end = node.end(); |
||||
for( ; it != it_end; ) |
||||
{ |
||||
KeyPoint kpt; |
||||
it >> kpt.pt.x >> kpt.pt.y >> kpt.size >> kpt.angle >> kpt.response >> kpt.octave >> kpt.class_id; |
||||
keypoints.push_back(kpt); |
||||
} |
||||
} |
||||
|
||||
void write( FileStorage& fs, const String& name, const std::vector<DMatch>& vec) |
||||
{ |
||||
// from template implementation
|
||||
cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ); |
||||
write(fs, vec); |
||||
} |
||||
|
||||
void read(const FileNode& node, std::vector<DMatch>& matches) |
||||
{ |
||||
FileNode first_node = *(node.begin()); |
||||
if (first_node.isSeq()) |
||||
{ |
||||
// modern scheme
|
||||
#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED |
||||
FileNodeIterator it = node.begin(); |
||||
size_t total = (size_t)it.remaining; |
||||
matches.resize(total); |
||||
for (size_t i = 0; i < total; ++i, ++it) |
||||
{ |
||||
(*it) >> matches[i]; |
||||
} |
||||
#else |
||||
FileNodeIterator it = node.begin(); |
||||
it >> matches; |
||||
#endif |
||||
return; |
||||
} |
||||
matches.clear(); |
||||
FileNodeIterator it = node.begin(), it_end = node.end(); |
||||
for( ; it != it_end; ) |
||||
{ |
||||
DMatch m; |
||||
it >> m.queryIdx >> m.trainIdx >> m.imgIdx >> m.distance; |
||||
matches.push_back(m); |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
int FileNode::type() const { return !node ? NONE : (node->tag & TYPE_MASK); } |
||||
bool FileNode::isNamed() const { return !node ? false : (node->tag & NAMED) != 0; } |
||||
|
||||
size_t FileNode::size() const |
||||
{ |
||||
int t = type(); |
||||
return t == MAP ? (size_t)((CvSet*)node->data.map)->active_count : |
||||
t == SEQ ? (size_t)node->data.seq->total : (size_t)!isNone(); |
||||
} |
||||
|
||||
void read(const FileNode& node, int& value, int default_value) |
||||
{ |
||||
value = !node.node ? default_value : |
||||
CV_NODE_IS_INT(node.node->tag) ? node.node->data.i : std::numeric_limits<int>::max(); |
||||
} |
||||
|
||||
void read(const FileNode& node, float& value, float default_value) |
||||
{ |
||||
value = !node.node ? default_value : |
||||
CV_NODE_IS_INT(node.node->tag) ? (float)node.node->data.i : |
||||
CV_NODE_IS_REAL(node.node->tag) ? saturate_cast<float>(node.node->data.f) : std::numeric_limits<float>::max(); |
||||
} |
||||
|
||||
void read(const FileNode& node, double& value, double default_value) |
||||
{ |
||||
value = !node.node ? default_value : |
||||
CV_NODE_IS_INT(node.node->tag) ? (double)node.node->data.i : |
||||
CV_NODE_IS_REAL(node.node->tag) ? node.node->data.f : std::numeric_limits<double>::max(); |
||||
} |
||||
|
||||
void read(const FileNode& node, String& value, const String& default_value) |
||||
{ |
||||
value = !node.node ? default_value : CV_NODE_IS_STRING(node.node->tag) ? String(node.node->data.str.ptr) : String(); |
||||
} |
||||
|
||||
void read(const FileNode& node, std::string& value, const std::string& default_value) |
||||
{ |
||||
value = !node.node ? default_value : CV_NODE_IS_STRING(node.node->tag) ? std::string(node.node->data.str.ptr) : default_value; |
||||
} |
||||
|
||||
} // cv::
|
||||
@ -0,0 +1,897 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
|
||||
#include "precomp.hpp" |
||||
#include "persistence.hpp" |
||||
|
||||
/****************************************************************************************\
|
||||
* JSON Parser * |
||||
\****************************************************************************************/ |
||||
|
||||
static char* |
||||
icvJSONSkipSpaces( CvFileStorage* fs, char* ptr ) |
||||
{ |
||||
bool is_eof = false; |
||||
bool is_completed = false; |
||||
|
||||
while ( is_eof == false && is_completed == false ) |
||||
{ |
||||
switch ( *ptr ) |
||||
{ |
||||
/* comment */ |
||||
case '/' : { |
||||
ptr++; |
||||
if ( *ptr == '\0' ) |
||||
{ |
||||
ptr = icvGets( fs, fs->buffer_start, static_cast<int>(fs->buffer_end - fs->buffer_start) ); |
||||
if ( !ptr ) { is_eof = true; break; } |
||||
} |
||||
|
||||
if ( *ptr == '/' ) |
||||
{ |
||||
while ( *ptr != '\n' && *ptr != '\r' ) |
||||
{ |
||||
if ( *ptr == '\0' ) |
||||
{ |
||||
ptr = icvGets( fs, fs->buffer_start, static_cast<int>(fs->buffer_end - fs->buffer_start) ); |
||||
if ( !ptr ) { is_eof = true; break; } |
||||
} |
||||
else |
||||
{ |
||||
ptr++; |
||||
} |
||||
} |
||||
} |
||||
else if ( *ptr == '*' ) |
||||
{ |
||||
ptr++; |
||||
for (;;) |
||||
{ |
||||
if ( *ptr == '\0' ) |
||||
{ |
||||
ptr = icvGets( fs, fs->buffer_start, static_cast<int>(fs->buffer_end - fs->buffer_start) ); |
||||
if ( !ptr ) { is_eof = true; break; } |
||||
} |
||||
else if ( *ptr == '*' ) |
||||
{ |
||||
ptr++; |
||||
if ( *ptr == '\0' ) |
||||
{ |
||||
ptr = icvGets( fs, fs->buffer_start, static_cast<int>(fs->buffer_end - fs->buffer_start) ); |
||||
if ( !ptr ) { is_eof = true; break; } |
||||
} |
||||
if ( *ptr == '/' ) |
||||
{ |
||||
ptr++; |
||||
break; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
ptr++; |
||||
} |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
CV_PARSE_ERROR( "Not supported escape character" ); |
||||
} |
||||
} break; |
||||
/* whitespace */ |
||||
case '\t': |
||||
case ' ' : { |
||||
ptr++; |
||||
} break; |
||||
/* newline || end mark */ |
||||
case '\0': |
||||
case '\n': |
||||
case '\r': { |
||||
ptr = icvGets( fs, fs->buffer_start, static_cast<int>(fs->buffer_end - fs->buffer_start) ); |
||||
if ( !ptr ) { is_eof = true; break; } |
||||
} break; |
||||
/* other character */ |
||||
default: { |
||||
if ( !cv_isprint(*ptr) ) |
||||
CV_PARSE_ERROR( "Invalid character in the stream" ); |
||||
is_completed = true; |
||||
} break; |
||||
} |
||||
} |
||||
|
||||
if ( is_eof ) |
||||
{ |
||||
ptr = fs->buffer_start; |
||||
*ptr = '\0'; |
||||
fs->dummy_eof = 1; |
||||
} |
||||
else if ( !is_completed ) |
||||
{ |
||||
/* should not be executed */ |
||||
ptr = 0; |
||||
fs->dummy_eof = 1; |
||||
CV_PARSE_ERROR( "Abort at parse time" ); |
||||
} |
||||
return ptr; |
||||
} |
||||
|
||||
|
||||
static char* icvJSONParseKey( CvFileStorage* fs, char* ptr, CvFileNode* map, CvFileNode** value_placeholder ) |
||||
{ |
||||
if( *ptr != '"' ) |
||||
CV_PARSE_ERROR( "Key must start with \'\"\'" ); |
||||
|
||||
char * beg = ptr + 1; |
||||
char * end = beg; |
||||
|
||||
do ++ptr; |
||||
while( cv_isprint(*ptr) && *ptr != '"' ); |
||||
|
||||
if( *ptr != '"' ) |
||||
CV_PARSE_ERROR( "Key must end with \'\"\'" ); |
||||
|
||||
end = ptr; |
||||
ptr++; |
||||
ptr = icvJSONSkipSpaces( fs, ptr ); |
||||
if ( ptr == 0 || fs->dummy_eof ) |
||||
return 0; |
||||
|
||||
if( *ptr != ':' ) |
||||
CV_PARSE_ERROR( "Missing \':\' between key and value" ); |
||||
|
||||
/* [beg, end) */ |
||||
if( end <= beg ) |
||||
CV_PARSE_ERROR( "Key is empty" ); |
||||
|
||||
if ( end - beg == 7u && memcmp(beg, "type_id", 7u) == 0 ) |
||||
{ |
||||
*value_placeholder = 0; |
||||
} |
||||
else |
||||
{ |
||||
CvStringHashNode* str_hash_node = cvGetHashedKey( fs, beg, static_cast<int>(end - beg), 1 ); |
||||
*value_placeholder = cvGetFileNode( fs, map, str_hash_node, 1 ); |
||||
} |
||||
|
||||
ptr++; |
||||
return ptr; |
||||
} |
||||
|
||||
static char* icvJSONParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node ) |
||||
{ |
||||
ptr = icvJSONSkipSpaces( fs, ptr ); |
||||
if ( ptr == 0 || fs->dummy_eof ) |
||||
CV_PARSE_ERROR( "Unexpected End-Of-File" ); |
||||
|
||||
memset( node, 0, sizeof(*node) ); |
||||
|
||||
if ( *ptr == '"' ) |
||||
{ /* must be string or Base64 string */ |
||||
ptr++; |
||||
char * beg = ptr; |
||||
size_t len = 0u; |
||||
for ( ; (cv_isalnum(*ptr) || *ptr == '$' ) && len <= 9u; ptr++ ) |
||||
len++; |
||||
|
||||
if ( len >= 8u && memcmp( beg, "$base64$", 8u ) == 0 ) |
||||
{ /**************** Base64 string ****************/ |
||||
ptr = beg += 8; |
||||
|
||||
std::string base64_buffer; |
||||
base64_buffer.reserve( PARSER_BASE64_BUFFER_SIZE ); |
||||
|
||||
bool is_matching = false; |
||||
while ( !is_matching ) |
||||
{ |
||||
switch ( *ptr ) |
||||
{ |
||||
case '\0': |
||||
{ |
||||
base64_buffer.append( beg, ptr ); |
||||
|
||||
ptr = icvGets( fs, fs->buffer_start, static_cast<int>(fs->buffer_end - fs->buffer_start) ); |
||||
if ( !ptr ) |
||||
CV_PARSE_ERROR( "'\"' - right-quote of string is missing" ); |
||||
|
||||
beg = ptr; |
||||
break; |
||||
} |
||||
case '\"': |
||||
{ |
||||
base64_buffer.append( beg, ptr ); |
||||
beg = ptr; |
||||
is_matching = true; |
||||
break; |
||||
} |
||||
case '\n': |
||||
case '\r': |
||||
{ |
||||
CV_PARSE_ERROR( "'\"' - right-quote of string is missing" ); |
||||
break; |
||||
} |
||||
default: |
||||
{ |
||||
ptr++; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
if ( *ptr != '\"' ) |
||||
CV_PARSE_ERROR( "'\"' - right-quote of string is missing" ); |
||||
else |
||||
ptr++; |
||||
|
||||
if ( base64_buffer.size() >= base64::ENCODED_HEADER_SIZE ) |
||||
{ |
||||
const char * base64_beg = base64_buffer.data(); |
||||
const char * base64_end = base64_beg + base64_buffer.size(); |
||||
|
||||
/* get dt from header */ |
||||
std::string dt; |
||||
{ |
||||
std::vector<char> header(base64::HEADER_SIZE + 1, ' '); |
||||
base64::base64_decode(base64_beg, header.data(), 0U, base64::ENCODED_HEADER_SIZE); |
||||
if ( !base64::read_base64_header(header, dt) || dt.empty() ) |
||||
CV_PARSE_ERROR("Invalid `dt` in Base64 header"); |
||||
} |
||||
|
||||
/* set base64_beg to beginning of base64 data */ |
||||
base64_beg = &base64_buffer.at( base64::ENCODED_HEADER_SIZE ); |
||||
|
||||
if ( base64_buffer.size() > base64::ENCODED_HEADER_SIZE ) |
||||
{ |
||||
if ( !base64::base64_valid( base64_beg, 0U, base64_end - base64_beg ) ) |
||||
CV_PARSE_ERROR( "Invalid Base64 data." ); |
||||
|
||||
/* buffer for decoded data(exclude header) */ |
||||
std::vector<uchar> binary_buffer( base64::base64_decode_buffer_size(base64_end - base64_beg) ); |
||||
int total_byte_size = static_cast<int>( |
||||
base64::base64_decode_buffer_size( base64_end - base64_beg, base64_beg, false ) |
||||
); |
||||
{ |
||||
base64::Base64ContextParser parser(binary_buffer.data(), binary_buffer.size() ); |
||||
const uchar * binary_beg = reinterpret_cast<const uchar *>( base64_beg ); |
||||
const uchar * binary_end = binary_beg + (base64_end - base64_beg); |
||||
parser.read( binary_beg, binary_end ); |
||||
parser.flush(); |
||||
} |
||||
|
||||
/* save as CvSeq */ |
||||
int elem_size = ::icvCalcStructSize(dt.c_str(), 0); |
||||
if (total_byte_size % elem_size != 0) |
||||
CV_PARSE_ERROR("Byte size not match elememt size"); |
||||
int elem_cnt = total_byte_size / elem_size; |
||||
|
||||
/* after icvFSCreateCollection, node->tag == struct_flags */ |
||||
icvFSCreateCollection(fs, CV_NODE_FLOW | CV_NODE_SEQ, node); |
||||
base64::make_seq(binary_buffer.data(), elem_cnt, dt.c_str(), *node->data.seq); |
||||
} |
||||
else |
||||
{ |
||||
/* empty */ |
||||
icvFSCreateCollection(fs, CV_NODE_FLOW | CV_NODE_SEQ, node); |
||||
} |
||||
} |
||||
else if ( base64_buffer.empty() ) |
||||
{ |
||||
/* empty */ |
||||
icvFSCreateCollection(fs, CV_NODE_FLOW | CV_NODE_SEQ, node); |
||||
} |
||||
else |
||||
{ |
||||
CV_PARSE_ERROR("Unrecognized Base64 header"); |
||||
} |
||||
} |
||||
else |
||||
{ /**************** normal string ****************/ |
||||
std::string string_buffer; |
||||
string_buffer.reserve( PARSER_BASE64_BUFFER_SIZE ); |
||||
|
||||
ptr = beg; |
||||
bool is_matching = false; |
||||
while ( !is_matching ) |
||||
{ |
||||
switch ( *ptr ) |
||||
{ |
||||
case '\\': |
||||
{ |
||||
string_buffer.append( beg, ptr ); |
||||
ptr++; |
||||
switch ( *ptr ) |
||||
{ |
||||
case '\\': |
||||
case '\"': |
||||
case '\'': { string_buffer.append( 1u, *ptr ); break; } |
||||
case 'n' : { string_buffer.append( 1u, '\n' ); break; } |
||||
case 'r' : { string_buffer.append( 1u, '\r' ); break; } |
||||
case 't' : { string_buffer.append( 1u, '\t' ); break; } |
||||
case 'b' : { string_buffer.append( 1u, '\b' ); break; } |
||||
case 'f' : { string_buffer.append( 1u, '\f' ); break; } |
||||
case 'u' : { CV_PARSE_ERROR( "'\\uXXXX' currently not supported" ); } |
||||
default : { CV_PARSE_ERROR( "Invalid escape character" ); } |
||||
break; |
||||
} |
||||
ptr++; |
||||
beg = ptr; |
||||
break; |
||||
} |
||||
case '\0': |
||||
{ |
||||
string_buffer.append( beg, ptr ); |
||||
|
||||
ptr = icvGets( fs, fs->buffer_start, static_cast<int>(fs->buffer_end - fs->buffer_start) ); |
||||
if ( !ptr ) |
||||
CV_PARSE_ERROR( "'\"' - right-quote of string is missing" ); |
||||
|
||||
beg = ptr; |
||||
break; |
||||
} |
||||
case '\"': |
||||
{ |
||||
string_buffer.append( beg, ptr ); |
||||
beg = ptr; |
||||
is_matching = true; |
||||
break; |
||||
} |
||||
case '\n': |
||||
case '\r': |
||||
{ |
||||
CV_PARSE_ERROR( "'\"' - right-quote of string is missing" ); |
||||
break; |
||||
} |
||||
default: |
||||
{ |
||||
ptr++; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
if ( *ptr != '\"' ) |
||||
CV_PARSE_ERROR( "'\"' - right-quote of string is missing" ); |
||||
else |
||||
ptr++; |
||||
|
||||
node->data.str = cvMemStorageAllocString |
||||
( |
||||
fs->memstorage, |
||||
string_buffer.c_str(), |
||||
static_cast<int>(string_buffer.size()) |
||||
); |
||||
node->tag = CV_NODE_STRING; |
||||
} |
||||
} |
||||
else if ( cv_isdigit(*ptr) || *ptr == '-' || *ptr == '+' || *ptr == '.' ) |
||||
{ /**************** number ****************/ |
||||
char * beg = ptr; |
||||
if ( *ptr == '+' || *ptr == '-' ) |
||||
ptr++; |
||||
while( cv_isdigit(*ptr) ) |
||||
ptr++; |
||||
if (*ptr == '.' || *ptr == 'e') |
||||
{ |
||||
node->data.f = icv_strtod( fs, beg, &ptr ); |
||||
node->tag = CV_NODE_REAL; |
||||
} |
||||
else |
||||
{ |
||||
node->data.i = static_cast<int>(strtol( beg, &ptr, 0 )); |
||||
node->tag = CV_NODE_INT; |
||||
} |
||||
|
||||
if ( beg >= ptr ) |
||||
CV_PARSE_ERROR( "Invalid numeric value (inconsistent explicit type specification?)" ); |
||||
} |
||||
else |
||||
{ /**************** other data ****************/ |
||||
const char * beg = ptr; |
||||
size_t len = 0u; |
||||
for ( ; cv_isalpha(*ptr) && len <= 6u; ptr++ ) |
||||
len++; |
||||
|
||||
if ( len >= 4u && memcmp( beg, "null", 4u ) == 0 ) |
||||
{ |
||||
CV_PARSE_ERROR( "Value 'null' is not supported by this parser" ); |
||||
} |
||||
else if ( len >= 4u && memcmp( beg, "true", 4u ) == 0 ) |
||||
{ |
||||
node->data.i = 1; |
||||
node->tag = CV_NODE_INT; |
||||
} |
||||
else if ( len >= 5u && memcmp( beg, "false", 5u ) == 0 ) |
||||
{ |
||||
node->data.i = 0; |
||||
node->tag = CV_NODE_INT; |
||||
} |
||||
else |
||||
{ |
||||
CV_PARSE_ERROR( "Unrecognized value" ); |
||||
} |
||||
} |
||||
|
||||
return ptr; |
||||
} |
||||
|
||||
static char* icvJSONParseSeq( CvFileStorage* fs, char* ptr, CvFileNode* node ); |
||||
static char* icvJSONParseMap( CvFileStorage* fs, char* ptr, CvFileNode* node ); |
||||
|
||||
static char* icvJSONParseSeq( CvFileStorage* fs, char* ptr, CvFileNode* node ) |
||||
{ |
||||
if (!ptr) |
||||
CV_PARSE_ERROR( "ptr is NULL" ); |
||||
|
||||
if ( *ptr != '[' ) |
||||
CV_PARSE_ERROR( "'[' - left-brace of seq is missing" ); |
||||
else |
||||
ptr++; |
||||
|
||||
memset( node, 0, sizeof(*node) ); |
||||
icvFSCreateCollection( fs, CV_NODE_SEQ, node ); |
||||
|
||||
for (;;) |
||||
{ |
||||
ptr = icvJSONSkipSpaces( fs, ptr ); |
||||
if ( ptr == 0 || fs->dummy_eof ) |
||||
break; |
||||
|
||||
if ( *ptr != ']' ) |
||||
{ |
||||
CvFileNode* child = (CvFileNode*)cvSeqPush( node->data.seq, 0 ); |
||||
|
||||
if ( *ptr == '[' ) |
||||
ptr = icvJSONParseSeq( fs, ptr, child ); |
||||
else if ( *ptr == '{' ) |
||||
ptr = icvJSONParseMap( fs, ptr, child ); |
||||
else |
||||
ptr = icvJSONParseValue( fs, ptr, child ); |
||||
} |
||||
|
||||
ptr = icvJSONSkipSpaces( fs, ptr ); |
||||
if ( ptr == 0 || fs->dummy_eof ) |
||||
break; |
||||
|
||||
if ( *ptr == ',' ) |
||||
ptr++; |
||||
else if ( *ptr == ']' ) |
||||
break; |
||||
else |
||||
CV_PARSE_ERROR( "Unexpected character" ); |
||||
} |
||||
|
||||
if (!ptr) |
||||
CV_PARSE_ERROR("ptr is NULL"); |
||||
|
||||
if ( *ptr != ']' ) |
||||
CV_PARSE_ERROR( "']' - right-brace of seq is missing" ); |
||||
else |
||||
ptr++; |
||||
|
||||
return ptr; |
||||
} |
||||
|
||||
static char* icvJSONParseMap( CvFileStorage* fs, char* ptr, CvFileNode* node ) |
||||
{ |
||||
if (!ptr) |
||||
CV_PARSE_ERROR("ptr is NULL"); |
||||
|
||||
if ( *ptr != '{' ) |
||||
CV_PARSE_ERROR( "'{' - left-brace of map is missing" ); |
||||
else |
||||
ptr++; |
||||
|
||||
memset( node, 0, sizeof(*node) ); |
||||
icvFSCreateCollection( fs, CV_NODE_MAP, node ); |
||||
|
||||
for ( ;; ) |
||||
{ |
||||
ptr = icvJSONSkipSpaces( fs, ptr ); |
||||
if ( ptr == 0 || fs->dummy_eof ) |
||||
break; |
||||
|
||||
if ( *ptr == '"' ) |
||||
{ |
||||
CvFileNode* child = 0; |
||||
ptr = icvJSONParseKey( fs, ptr, node, &child ); |
||||
if ( ptr == 0 || fs->dummy_eof ) |
||||
break; |
||||
ptr = icvJSONSkipSpaces( fs, ptr ); |
||||
if ( ptr == 0 || fs->dummy_eof ) |
||||
break; |
||||
|
||||
if ( child == 0 ) |
||||
{ /* type_id */ |
||||
CvFileNode tmp; |
||||
ptr = icvJSONParseValue( fs, ptr, &tmp ); |
||||
if ( CV_NODE_IS_STRING(tmp.tag) ) |
||||
{ |
||||
node->info = cvFindType( tmp.data.str.ptr ); |
||||
if ( node->info ) |
||||
node->tag |= CV_NODE_USER; |
||||
// delete tmp.data.str
|
||||
} |
||||
else |
||||
{ |
||||
CV_PARSE_ERROR( "\"type_id\" should be of type string" ); |
||||
} |
||||
} |
||||
else |
||||
{ /* normal */ |
||||
if ( *ptr == '[' ) |
||||
ptr = icvJSONParseSeq( fs, ptr, child ); |
||||
else if ( *ptr == '{' ) |
||||
ptr = icvJSONParseMap( fs, ptr, child ); |
||||
else |
||||
ptr = icvJSONParseValue( fs, ptr, child ); |
||||
child->tag |= CV_NODE_NAMED; |
||||
} |
||||
} |
||||
|
||||
ptr = icvJSONSkipSpaces( fs, ptr ); |
||||
if ( ptr == 0 || fs->dummy_eof ) |
||||
break; |
||||
|
||||
if ( *ptr == ',' ) |
||||
ptr++; |
||||
else if ( *ptr == '}' ) |
||||
break; |
||||
else |
||||
CV_PARSE_ERROR( "Unexpected character" ); |
||||
} |
||||
|
||||
if (!ptr) |
||||
CV_PARSE_ERROR("ptr is NULL"); |
||||
|
||||
if ( *ptr != '}' ) |
||||
CV_PARSE_ERROR( "'}' - right-brace of map is missing" ); |
||||
else |
||||
ptr++; |
||||
|
||||
return ptr; |
||||
} |
||||
|
||||
|
||||
void icvJSONParse( CvFileStorage* fs ) |
||||
{ |
||||
char* ptr = fs->buffer_start; |
||||
ptr = icvJSONSkipSpaces( fs, ptr ); |
||||
if ( ptr == 0 || fs->dummy_eof ) |
||||
return; |
||||
|
||||
if ( *ptr == '{' ) |
||||
{ |
||||
CvFileNode* root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 ); |
||||
ptr = icvJSONParseMap( fs, ptr, root_node ); |
||||
} |
||||
else if ( *ptr == '[' ) |
||||
{ |
||||
CvFileNode* root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 ); |
||||
ptr = icvJSONParseSeq( fs, ptr, root_node ); |
||||
} |
||||
else |
||||
{ |
||||
CV_PARSE_ERROR( "left-brace of top level is missing" ); |
||||
} |
||||
|
||||
if ( fs->dummy_eof != 0 ) |
||||
CV_PARSE_ERROR( "Unexpected End-Of-File" ); |
||||
} |
||||
|
||||
|
||||
/****************************************************************************************\
|
||||
* JSON Emitter * |
||||
\****************************************************************************************/ |
||||
|
||||
void icvJSONWrite( CvFileStorage* fs, const char* key, const char* data ) |
||||
{ |
||||
/* check write_struct */ |
||||
|
||||
check_if_write_struct_is_delayed( fs ); |
||||
if ( fs->state_of_writing_base64 == base64::fs::Uncertain ) |
||||
{ |
||||
switch_to_Base64_state( fs, base64::fs::NotUse ); |
||||
} |
||||
else if ( fs->state_of_writing_base64 == base64::fs::InUse ) |
||||
{ |
||||
CV_Error( CV_StsError, "At present, output Base64 data only." ); |
||||
} |
||||
|
||||
/* check parameters */ |
||||
|
||||
size_t key_len = 0u; |
||||
if( key && *key == '\0' ) |
||||
key = 0; |
||||
if ( key ) |
||||
{ |
||||
key_len = strlen(key); |
||||
if ( key_len == 0u ) |
||||
CV_Error( CV_StsBadArg, "The key is an empty" ); |
||||
else if ( static_cast<int>(key_len) > CV_FS_MAX_LEN ) |
||||
CV_Error( CV_StsBadArg, "The key is too long" ); |
||||
} |
||||
|
||||
size_t data_len = 0u; |
||||
if ( data ) |
||||
data_len = strlen(data); |
||||
|
||||
int struct_flags = fs->struct_flags; |
||||
if( CV_NODE_IS_COLLECTION(struct_flags) ) |
||||
{ |
||||
if ( (CV_NODE_IS_MAP(struct_flags) ^ (key != 0)) ) |
||||
CV_Error( CV_StsBadArg, "An attempt to add element without a key to a map, " |
||||
"or add element with key to sequence" ); |
||||
} else { |
||||
fs->is_first = 0; |
||||
struct_flags = CV_NODE_EMPTY | (key ? CV_NODE_MAP : CV_NODE_SEQ); |
||||
} |
||||
|
||||
/* start to write */ |
||||
|
||||
char* ptr = 0; |
||||
|
||||
if( CV_NODE_IS_FLOW(struct_flags) ) |
||||
{ |
||||
int new_offset; |
||||
ptr = fs->buffer; |
||||
if( !CV_NODE_IS_EMPTY(struct_flags) ) |
||||
*ptr++ = ','; |
||||
new_offset = static_cast<int>(ptr - fs->buffer_start + key_len + data_len); |
||||
if( new_offset > fs->wrap_margin && new_offset - fs->struct_indent > 10 ) |
||||
{ |
||||
fs->buffer = ptr; |
||||
ptr = icvFSFlush(fs); |
||||
} |
||||
else |
||||
*ptr++ = ' '; |
||||
} |
||||
else |
||||
{ |
||||
if ( !CV_NODE_IS_EMPTY(struct_flags) ) |
||||
{ |
||||
ptr = fs->buffer; |
||||
*ptr++ = ','; |
||||
*ptr++ = '\n'; |
||||
*ptr++ = '\0'; |
||||
::icvPuts( fs, fs->buffer_start ); |
||||
ptr = fs->buffer = fs->buffer_start; |
||||
} |
||||
ptr = icvFSFlush(fs); |
||||
} |
||||
|
||||
if( key ) |
||||
{ |
||||
if( !cv_isalpha(key[0]) && key[0] != '_' ) |
||||
CV_Error( CV_StsBadArg, "Key must start with a letter or _" ); |
||||
|
||||
ptr = icvFSResizeWriteBuffer( fs, ptr, static_cast<int>(key_len) ); |
||||
*ptr++ = '\"'; |
||||
|
||||
for( size_t i = 0u; i < key_len; i++ ) |
||||
{ |
||||
char c = key[i]; |
||||
|
||||
ptr[i] = c; |
||||
if( !cv_isalnum(c) && c != '-' && c != '_' && c != ' ' ) |
||||
CV_Error( CV_StsBadArg, "Key names may only contain alphanumeric characters [a-zA-Z0-9], '-', '_' and ' '" ); |
||||
} |
||||
|
||||
ptr += key_len; |
||||
*ptr++ = '\"'; |
||||
*ptr++ = ':'; |
||||
*ptr++ = ' '; |
||||
} |
||||
|
||||
if( data ) |
||||
{ |
||||
ptr = icvFSResizeWriteBuffer( fs, ptr, static_cast<int>(data_len) ); |
||||
memcpy( ptr, data, data_len ); |
||||
ptr += data_len; |
||||
} |
||||
|
||||
fs->buffer = ptr; |
||||
fs->struct_flags = struct_flags & ~CV_NODE_EMPTY; |
||||
} |
||||
|
||||
|
||||
void icvJSONStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags, const char* type_name) |
||||
{ |
||||
int parent_flags; |
||||
char data[CV_FS_MAX_LEN + 1024]; |
||||
|
||||
struct_flags = (struct_flags & (CV_NODE_TYPE_MASK|CV_NODE_FLOW)) | CV_NODE_EMPTY; |
||||
if( !CV_NODE_IS_COLLECTION(struct_flags)) |
||||
CV_Error( CV_StsBadArg, |
||||
"Some collection type - CV_NODE_SEQ or CV_NODE_MAP, must be specified" ); |
||||
|
||||
if ( type_name && *type_name == '\0' ) |
||||
type_name = 0; |
||||
|
||||
bool has_type_id = false; |
||||
bool is_real_collection = true; |
||||
if (type_name && memcmp(type_name, "binary", 6) == 0) |
||||
{ |
||||
struct_flags = CV_NODE_STR; |
||||
data[0] = '\0'; |
||||
is_real_collection = false; |
||||
} |
||||
else if( type_name ) |
||||
{ |
||||
has_type_id = true; |
||||
} |
||||
|
||||
if ( is_real_collection ) |
||||
{ |
||||
char c = CV_NODE_IS_MAP(struct_flags) ? '{' : '['; |
||||
data[0] = c; |
||||
data[1] = '\0'; |
||||
} |
||||
|
||||
icvJSONWrite( fs, key, data ); |
||||
|
||||
parent_flags = fs->struct_flags; |
||||
cvSeqPush( fs->write_stack, &parent_flags ); |
||||
fs->struct_flags = struct_flags; |
||||
fs->struct_indent += 4; |
||||
|
||||
if ( has_type_id ) |
||||
fs->write_string( fs, "type_id", type_name, 1 ); |
||||
} |
||||
|
||||
|
||||
void icvJSONEndWriteStruct( CvFileStorage* fs ) |
||||
{ |
||||
if( fs->write_stack->total == 0 ) |
||||
CV_Error( CV_StsError, "EndWriteStruct w/o matching StartWriteStruct" ); |
||||
|
||||
int parent_flags = 0; |
||||
int struct_flags = fs->struct_flags; |
||||
cvSeqPop( fs->write_stack, &parent_flags ); |
||||
fs->struct_indent -= 4; |
||||
fs->struct_flags = parent_flags & ~CV_NODE_EMPTY; |
||||
assert( fs->struct_indent >= 0 ); |
||||
|
||||
if ( CV_NODE_IS_COLLECTION(struct_flags) ) |
||||
{ |
||||
if ( !CV_NODE_IS_FLOW(struct_flags) ) |
||||
{ |
||||
if ( fs->buffer <= fs->buffer_start + fs->space ) |
||||
{ |
||||
/* some bad code for base64_writer... */ |
||||
*fs->buffer++ = '\n'; |
||||
*fs->buffer++ = '\0'; |
||||
icvPuts( fs, fs->buffer_start ); |
||||
fs->buffer = fs->buffer_start; |
||||
} |
||||
icvFSFlush(fs); |
||||
} |
||||
|
||||
char* ptr = fs->buffer; |
||||
if( ptr > fs->buffer_start + fs->struct_indent && !CV_NODE_IS_EMPTY(struct_flags) ) |
||||
*ptr++ = ' '; |
||||
*ptr++ = CV_NODE_IS_MAP(struct_flags) ? '}' : ']'; |
||||
fs->buffer = ptr; |
||||
} |
||||
} |
||||
|
||||
|
||||
void icvJSONStartNextStream( CvFileStorage* fs ) |
||||
{ |
||||
if( !fs->is_first ) |
||||
{ |
||||
while( fs->write_stack->total > 0 ) |
||||
icvJSONEndWriteStruct(fs); |
||||
|
||||
fs->struct_indent = 4; |
||||
icvFSFlush(fs); |
||||
fs->buffer = fs->buffer_start; |
||||
} |
||||
} |
||||
|
||||
|
||||
void icvJSONWriteInt( CvFileStorage* fs, const char* key, int value ) |
||||
{ |
||||
char buf[128]; |
||||
icvJSONWrite( fs, key, icv_itoa( value, buf, 10 )); |
||||
} |
||||
|
||||
|
||||
void icvJSONWriteReal( CvFileStorage* fs, const char* key, double value ) |
||||
{ |
||||
char buf[128]; |
||||
size_t len = strlen( icvDoubleToString( buf, value ) ); |
||||
if( len > 0 && buf[len-1] == '.' ) |
||||
{ |
||||
// append zero if string ends with decimal place to match JSON standard
|
||||
buf[len] = '0'; |
||||
buf[len+1] = '\0'; |
||||
} |
||||
icvJSONWrite( fs, key, buf ); |
||||
} |
||||
|
||||
|
||||
void icvJSONWriteString( CvFileStorage* fs, const char* key, const char* str, int quote) |
||||
{ |
||||
char buf[CV_FS_MAX_LEN*4+16]; |
||||
char* data = (char*)str; |
||||
int i, len; |
||||
|
||||
if( !str ) |
||||
CV_Error( CV_StsNullPtr, "Null string pointer" ); |
||||
|
||||
len = (int)strlen(str); |
||||
if( len > CV_FS_MAX_LEN ) |
||||
CV_Error( CV_StsBadArg, "The written string is too long" ); |
||||
|
||||
if( quote || len == 0 || str[0] != str[len-1] || (str[0] != '\"' && str[0] != '\'') ) |
||||
{ |
||||
int need_quote = 1; |
||||
data = buf; |
||||
*data++ = '\"'; |
||||
for( i = 0; i < len; i++ ) |
||||
{ |
||||
char c = str[i]; |
||||
|
||||
switch ( c ) |
||||
{ |
||||
case '\\': |
||||
case '\"': |
||||
case '\'': { *data++ = '\\'; *data++ = c; break; } |
||||
case '\n': { *data++ = '\\'; *data++ = 'n'; break; } |
||||
case '\r': { *data++ = '\\'; *data++ = 'r'; break; } |
||||
case '\t': { *data++ = '\\'; *data++ = 't'; break; } |
||||
case '\b': { *data++ = '\\'; *data++ = 'b'; break; } |
||||
case '\f': { *data++ = '\\'; *data++ = 'f'; break; } |
||||
default : { *data++ = c; } |
||||
break; |
||||
} |
||||
} |
||||
|
||||
*data++ = '\"'; |
||||
*data++ = '\0'; |
||||
data = buf + !need_quote; |
||||
} |
||||
|
||||
icvJSONWrite( fs, key, data ); |
||||
} |
||||
|
||||
|
||||
void icvJSONWriteComment( CvFileStorage* fs, const char* comment, int eol_comment ) |
||||
{ |
||||
if( !comment ) |
||||
CV_Error( CV_StsNullPtr, "Null comment" ); |
||||
|
||||
int len = static_cast<int>(strlen(comment)); |
||||
char* ptr = fs->buffer; |
||||
const char* eol = strchr(comment, '\n'); |
||||
bool multiline = eol != 0; |
||||
|
||||
if( !eol_comment || multiline || fs->buffer_end - ptr < len || ptr == fs->buffer_start ) |
||||
ptr = icvFSFlush( fs ); |
||||
else |
||||
*ptr++ = ' '; |
||||
|
||||
while( comment ) |
||||
{ |
||||
*ptr++ = '/'; |
||||
*ptr++ = '/'; |
||||
*ptr++ = ' '; |
||||
if( eol ) |
||||
{ |
||||
ptr = icvFSResizeWriteBuffer( fs, ptr, (int)(eol - comment) + 1 ); |
||||
memcpy( ptr, comment, eol - comment + 1 ); |
||||
fs->buffer = ptr + (eol - comment); |
||||
comment = eol + 1; |
||||
eol = strchr( comment, '\n' ); |
||||
} |
||||
else |
||||
{ |
||||
len = (int)strlen(comment); |
||||
ptr = icvFSResizeWriteBuffer( fs, ptr, len ); |
||||
memcpy( ptr, comment, len ); |
||||
fs->buffer = ptr + len; |
||||
comment = 0; |
||||
} |
||||
ptr = icvFSFlush( fs ); |
||||
} |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,944 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
|
||||
#include "precomp.hpp" |
||||
#include "persistence.hpp" |
||||
|
||||
#define CV_YML_INDENT 3 |
||||
#define CV_YML_INDENT_FLOW 1 |
||||
|
||||
/****************************************************************************************\
|
||||
* YAML Parser * |
||||
\****************************************************************************************/ |
||||
|
||||
static char* icvYMLSkipSpaces( CvFileStorage* fs, char* ptr, int min_indent, int max_comment_indent ) |
||||
{ |
||||
for(;;) |
||||
{ |
||||
while( *ptr == ' ' ) |
||||
ptr++; |
||||
if( *ptr == '#' ) |
||||
{ |
||||
if( ptr - fs->buffer_start > max_comment_indent ) |
||||
return ptr; |
||||
*ptr = '\0'; |
||||
} |
||||
else if( cv_isprint(*ptr) ) |
||||
{ |
||||
if( ptr - fs->buffer_start < min_indent ) |
||||
CV_PARSE_ERROR( "Incorrect indentation" ); |
||||
break; |
||||
} |
||||
else if( *ptr == '\0' || *ptr == '\n' || *ptr == '\r' ) |
||||
{ |
||||
int max_size = (int)(fs->buffer_end - fs->buffer_start); |
||||
ptr = icvGets( fs, fs->buffer_start, max_size ); |
||||
if( !ptr ) |
||||
{ |
||||
// emulate end of stream
|
||||
ptr = fs->buffer_start; |
||||
ptr[0] = ptr[1] = ptr[2] = '.'; |
||||
ptr[3] = '\0'; |
||||
fs->dummy_eof = 1; |
||||
break; |
||||
} |
||||
else |
||||
{ |
||||
int l = (int)strlen(ptr); |
||||
if( ptr[l-1] != '\n' && ptr[l-1] != '\r' && !icvEof(fs) ) |
||||
CV_PARSE_ERROR( "Too long string or a last string w/o newline" ); |
||||
} |
||||
|
||||
fs->lineno++; |
||||
} |
||||
else |
||||
CV_PARSE_ERROR( *ptr == '\t' ? "Tabs are prohibited in YAML!" : "Invalid character" ); |
||||
} |
||||
|
||||
return ptr; |
||||
} |
||||
|
||||
|
||||
static void icvYMLGetMultilineStringContent(CvFileStorage* fs, char* ptr, int indent, char* &beg, char* &end) |
||||
{ |
||||
ptr = icvYMLSkipSpaces(fs, ptr, 0, INT_MAX); |
||||
beg = ptr; |
||||
end = ptr; |
||||
if (fs->dummy_eof) |
||||
return ; /* end of file */ |
||||
|
||||
if (ptr - fs->buffer_start != indent) |
||||
return ; /* end of string */ |
||||
|
||||
/* find end */ |
||||
while(cv_isprint(*ptr)) /* no check for base64 string */ |
||||
++ ptr; |
||||
if (*ptr == '\0') |
||||
CV_PARSE_ERROR("Unexpected end of line"); |
||||
|
||||
end = ptr; |
||||
} |
||||
|
||||
static char* icvYMLParseBase64(CvFileStorage* fs, char* ptr, int indent, CvFileNode * node) |
||||
{ |
||||
char * beg = 0; |
||||
char * end = 0; |
||||
|
||||
icvYMLGetMultilineStringContent(fs, ptr, indent, beg, end); |
||||
if (beg >= end) |
||||
return end; // CV_PARSE_ERROR("Empty Binary Data");
|
||||
|
||||
/* calc (decoded) total_byte_size from header */ |
||||
std::string dt; |
||||
{ |
||||
if (end - beg < static_cast<int>(base64::ENCODED_HEADER_SIZE)) |
||||
CV_PARSE_ERROR("Unrecognized Base64 header"); |
||||
|
||||
std::vector<char> header(base64::HEADER_SIZE + 1, ' '); |
||||
base64::base64_decode(beg, header.data(), 0U, base64::ENCODED_HEADER_SIZE); |
||||
if ( !base64::read_base64_header(header, dt) || dt.empty() ) |
||||
CV_PARSE_ERROR("Invalid `dt` in Base64 header"); |
||||
|
||||
beg += base64::ENCODED_HEADER_SIZE; |
||||
} |
||||
|
||||
/* get all Base64 data */ |
||||
std::string base64_buffer; |
||||
base64_buffer.reserve( PARSER_BASE64_BUFFER_SIZE ); |
||||
while( beg < end ) |
||||
{ |
||||
base64_buffer.append( beg, end ); |
||||
beg = end; |
||||
icvYMLGetMultilineStringContent( fs, beg, indent, beg, end ); |
||||
} |
||||
if ( base64_buffer.empty() || |
||||
!base64::base64_valid(base64_buffer.data(), 0U, base64_buffer.size()) ) |
||||
CV_PARSE_ERROR( "Invalid Base64 data." ); |
||||
|
||||
/* buffer for decoded data(exclude header) */ |
||||
std::vector<uchar> binary_buffer( base64::base64_decode_buffer_size(base64_buffer.size()) ); |
||||
int total_byte_size = static_cast<int>( |
||||
base64::base64_decode_buffer_size( base64_buffer.size(), base64_buffer.data(), false ) |
||||
); |
||||
{ |
||||
base64::Base64ContextParser parser(binary_buffer.data(), binary_buffer.size() ); |
||||
const uchar * buffer_beg = reinterpret_cast<const uchar *>( base64_buffer.data() ); |
||||
const uchar * buffer_end = buffer_beg + base64_buffer.size(); |
||||
parser.read( buffer_beg, buffer_end ); |
||||
parser.flush(); |
||||
} |
||||
|
||||
/* save as CvSeq */ |
||||
int elem_size = ::icvCalcStructSize(dt.c_str(), 0); |
||||
if (total_byte_size % elem_size != 0) |
||||
CV_PARSE_ERROR("Byte size not match elememt size"); |
||||
int elem_cnt = total_byte_size / elem_size; |
||||
|
||||
node->tag = CV_NODE_NONE; |
||||
int struct_flags = CV_NODE_FLOW | CV_NODE_SEQ; |
||||
/* after icvFSCreateCollection, node->tag == struct_flags */ |
||||
icvFSCreateCollection(fs, struct_flags, node); |
||||
base64::make_seq(binary_buffer.data(), elem_cnt, dt.c_str(), *node->data.seq); |
||||
|
||||
if (fs->dummy_eof) { |
||||
/* end of file */ |
||||
return fs->buffer_start; |
||||
} else { |
||||
/* end of line */ |
||||
return end; |
||||
} |
||||
} |
||||
|
||||
|
||||
static char* icvYMLParseKey( CvFileStorage* fs, char* ptr, CvFileNode* map_node, CvFileNode** value_placeholder ) |
||||
{ |
||||
char c; |
||||
char *endptr = ptr - 1, *saveptr; |
||||
CvStringHashNode* str_hash_node; |
||||
|
||||
if( *ptr == '-' ) |
||||
CV_PARSE_ERROR( "Key may not start with \'-\'" ); |
||||
|
||||
do c = *++endptr; |
||||
while( cv_isprint(c) && c != ':' ); |
||||
|
||||
if( c != ':' ) |
||||
CV_PARSE_ERROR( "Missing \':\'" ); |
||||
|
||||
saveptr = endptr + 1; |
||||
do c = *--endptr; |
||||
while( c == ' ' ); |
||||
|
||||
++endptr; |
||||
if( endptr == ptr ) |
||||
CV_PARSE_ERROR( "An empty key" ); |
||||
|
||||
str_hash_node = cvGetHashedKey( fs, ptr, (int)(endptr - ptr), 1 ); |
||||
*value_placeholder = cvGetFileNode( fs, map_node, str_hash_node, 1 ); |
||||
ptr = saveptr; |
||||
|
||||
return ptr; |
||||
} |
||||
|
||||
|
||||
static char* |
||||
icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node, |
||||
int parent_flags, int min_indent ) |
||||
{ |
||||
char buf[CV_FS_MAX_LEN + 1024] = {0}; |
||||
char* endptr = 0; |
||||
char c = ptr[0], d = ptr[1]; |
||||
int is_parent_flow = CV_NODE_IS_FLOW(parent_flags); |
||||
int value_type = CV_NODE_NONE; |
||||
int len; |
||||
bool is_binary_string = false; |
||||
|
||||
memset( node, 0, sizeof(*node) ); |
||||
|
||||
if( c == '!' ) // handle explicit type specification
|
||||
{ |
||||
if( d == '!' || d == '^' ) |
||||
{ |
||||
ptr++; |
||||
value_type |= CV_NODE_USER; |
||||
} |
||||
if ( d == '<') //support of full type heading from YAML 1.2
|
||||
{ |
||||
const char* yamlTypeHeading = "<tag:yaml.org,2002:"; |
||||
const size_t headingLenght = strlen(yamlTypeHeading); |
||||
|
||||
char* typeEndPtr = ++ptr; |
||||
|
||||
do d = *++typeEndPtr; |
||||
while( cv_isprint(d) && d != ' ' && d != '>' ); |
||||
|
||||
if ( d == '>' && (size_t)(typeEndPtr - ptr) > headingLenght ) |
||||
{ |
||||
if ( memcmp(ptr, yamlTypeHeading, headingLenght) == 0 ) |
||||
{ |
||||
value_type |= CV_NODE_USER; |
||||
*typeEndPtr = ' '; |
||||
ptr += headingLenght - 1; |
||||
} |
||||
} |
||||
} |
||||
|
||||
endptr = ptr++; |
||||
do d = *++endptr; |
||||
while( cv_isprint(d) && d != ' ' ); |
||||
len = (int)(endptr - ptr); |
||||
if( len == 0 ) |
||||
CV_PARSE_ERROR( "Empty type name" ); |
||||
d = *endptr; |
||||
*endptr = '\0'; |
||||
|
||||
if( len == 3 && !CV_NODE_IS_USER(value_type) ) |
||||
{ |
||||
if( memcmp( ptr, "str", 3 ) == 0 ) |
||||
value_type = CV_NODE_STRING; |
||||
else if( memcmp( ptr, "int", 3 ) == 0 ) |
||||
value_type = CV_NODE_INT; |
||||
else if( memcmp( ptr, "seq", 3 ) == 0 ) |
||||
value_type = CV_NODE_SEQ; |
||||
else if( memcmp( ptr, "map", 3 ) == 0 ) |
||||
value_type = CV_NODE_MAP; |
||||
} |
||||
else if( len == 5 && !CV_NODE_IS_USER(value_type) ) |
||||
{ |
||||
if( memcmp( ptr, "float", 5 ) == 0 ) |
||||
value_type = CV_NODE_REAL; |
||||
} |
||||
else if (len == 6 && CV_NODE_IS_USER(value_type)) |
||||
{ |
||||
if( memcmp( ptr, "binary", 6 ) == 0 ) { |
||||
value_type = CV_NODE_SEQ; |
||||
is_binary_string = true; |
||||
|
||||
/* for ignore '|' */ |
||||
|
||||
/**** operation with endptr ****/ |
||||
*endptr = d; |
||||
|
||||
do { |
||||
d = *++endptr; |
||||
if (d == '|') |
||||
break; |
||||
} while (d == ' '); |
||||
|
||||
d = *++endptr; |
||||
*endptr = '\0'; |
||||
} |
||||
} |
||||
else if( CV_NODE_IS_USER(value_type) ) |
||||
{ |
||||
node->info = cvFindType( ptr ); |
||||
if( !node->info ) |
||||
node->tag &= ~CV_NODE_USER; |
||||
} |
||||
|
||||
*endptr = d; |
||||
ptr = icvYMLSkipSpaces( fs, endptr, min_indent, INT_MAX ); |
||||
|
||||
c = *ptr; |
||||
|
||||
if( !CV_NODE_IS_USER(value_type) ) |
||||
{ |
||||
if (value_type == CV_NODE_STRING && c != '\'' && c != '\"') |
||||
goto force_string; |
||||
if( value_type == CV_NODE_INT ) |
||||
goto force_int; |
||||
if( value_type == CV_NODE_REAL ) |
||||
goto force_real; |
||||
} |
||||
} |
||||
|
||||
if (is_binary_string) |
||||
{ |
||||
/* for base64 string */ |
||||
int indent = static_cast<int>(ptr - fs->buffer_start); |
||||
ptr = icvYMLParseBase64(fs, ptr, indent, node); |
||||
} |
||||
else if( cv_isdigit(c) || |
||||
((c == '-' || c == '+') && (cv_isdigit(d) || d == '.')) || |
||||
(c == '.' && cv_isalnum(d))) // a number
|
||||
{ |
||||
double fval; |
||||
int ival; |
||||
endptr = ptr + (c == '-' || c == '+'); |
||||
while( cv_isdigit(*endptr) ) |
||||
endptr++; |
||||
if( *endptr == '.' || *endptr == 'e' ) |
||||
{ |
||||
force_real: |
||||
fval = icv_strtod( fs, ptr, &endptr ); |
||||
/*if( endptr == ptr || cv_isalpha(*endptr) )
|
||||
icvProcessSpecialDouble( fs, endptr, &fval, &endptr ));*/ |
||||
|
||||
node->tag = CV_NODE_REAL; |
||||
node->data.f = fval; |
||||
} |
||||
else |
||||
{ |
||||
force_int: |
||||
ival = (int)strtol( ptr, &endptr, 0 ); |
||||
node->tag = CV_NODE_INT; |
||||
node->data.i = ival; |
||||
} |
||||
|
||||
if( !endptr || endptr == ptr ) |
||||
CV_PARSE_ERROR( "Invalid numeric value (inconsistent explicit type specification?)" ); |
||||
|
||||
ptr = endptr; |
||||
} |
||||
else if( c == '\'' || c == '\"' ) // an explicit string
|
||||
{ |
||||
node->tag = CV_NODE_STRING; |
||||
if( c == '\'' ) |
||||
for( len = 0; len < CV_FS_MAX_LEN; ) |
||||
{ |
||||
c = *++ptr; |
||||
if( cv_isalnum(c) || (c != '\'' && cv_isprint(c))) |
||||
buf[len++] = c; |
||||
else if( c == '\'' ) |
||||
{ |
||||
c = *++ptr; |
||||
if( c != '\'' ) |
||||
break; |
||||
buf[len++] = c; |
||||
} |
||||
else |
||||
CV_PARSE_ERROR( "Invalid character" ); |
||||
} |
||||
else |
||||
for( len = 0; len < CV_FS_MAX_LEN; ) |
||||
{ |
||||
c = *++ptr; |
||||
if( cv_isalnum(c) || (c != '\\' && c != '\"' && cv_isprint(c))) |
||||
buf[len++] = c; |
||||
else if( c == '\"' ) |
||||
{ |
||||
++ptr; |
||||
break; |
||||
} |
||||
else if( c == '\\' ) |
||||
{ |
||||
d = *++ptr; |
||||
if( d == '\'' ) |
||||
buf[len++] = d; |
||||
else if( d == '\"' || d == '\\' || d == '\'' ) |
||||
buf[len++] = d; |
||||
else if( d == 'n' ) |
||||
buf[len++] = '\n'; |
||||
else if( d == 'r' ) |
||||
buf[len++] = '\r'; |
||||
else if( d == 't' ) |
||||
buf[len++] = '\t'; |
||||
else if( d == 'x' || (cv_isdigit(d) && d < '8') ) |
||||
{ |
||||
int val, is_hex = d == 'x'; |
||||
c = ptr[3]; |
||||
ptr[3] = '\0'; |
||||
val = (int)strtol( ptr + is_hex, &endptr, is_hex ? 8 : 16 ); |
||||
ptr[3] = c; |
||||
if( endptr == ptr + is_hex ) |
||||
buf[len++] = 'x'; |
||||
else |
||||
{ |
||||
buf[len++] = (char)val; |
||||
ptr = endptr; |
||||
} |
||||
} |
||||
} |
||||
else |
||||
CV_PARSE_ERROR( "Invalid character" ); |
||||
} |
||||
|
||||
if( len >= CV_FS_MAX_LEN ) |
||||
CV_PARSE_ERROR( "Too long string literal" ); |
||||
|
||||
node->data.str = cvMemStorageAllocString( fs->memstorage, buf, len ); |
||||
} |
||||
else if( c == '[' || c == '{' ) // collection as a flow
|
||||
{ |
||||
int new_min_indent = min_indent + !is_parent_flow; |
||||
int struct_flags = CV_NODE_FLOW + (c == '{' ? CV_NODE_MAP : CV_NODE_SEQ); |
||||
bool is_simple = true; |
||||
|
||||
icvFSCreateCollection( fs, CV_NODE_TYPE(struct_flags) + |
||||
(node->info ? CV_NODE_USER : 0), node ); |
||||
|
||||
d = c == '[' ? ']' : '}'; |
||||
|
||||
for( ++ptr ;;) |
||||
{ |
||||
CvFileNode* elem = 0; |
||||
|
||||
ptr = icvYMLSkipSpaces( fs, ptr, new_min_indent, INT_MAX ); |
||||
if( *ptr == '}' || *ptr == ']' ) |
||||
{ |
||||
if( *ptr != d ) |
||||
CV_PARSE_ERROR( "The wrong closing bracket" ); |
||||
ptr++; |
||||
break; |
||||
} |
||||
|
||||
if( node->data.seq->total != 0 ) |
||||
{ |
||||
if( *ptr != ',' ) |
||||
CV_PARSE_ERROR( "Missing , between the elements" ); |
||||
ptr = icvYMLSkipSpaces( fs, ptr + 1, new_min_indent, INT_MAX ); |
||||
} |
||||
|
||||
if( CV_NODE_IS_MAP(struct_flags) ) |
||||
{ |
||||
ptr = icvYMLParseKey( fs, ptr, node, &elem ); |
||||
ptr = icvYMLSkipSpaces( fs, ptr, new_min_indent, INT_MAX ); |
||||
} |
||||
else |
||||
{ |
||||
if( *ptr == ']' ) |
||||
break; |
||||
elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 ); |
||||
} |
||||
CV_Assert(elem); |
||||
ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, new_min_indent ); |
||||
if( CV_NODE_IS_MAP(struct_flags) ) |
||||
elem->tag |= CV_NODE_NAMED; |
||||
is_simple = is_simple && !CV_NODE_IS_COLLECTION(elem->tag); |
||||
} |
||||
node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0; |
||||
} |
||||
else |
||||
{ |
||||
int indent, struct_flags; |
||||
bool is_simple; |
||||
|
||||
if( is_parent_flow || c != '-' ) |
||||
{ |
||||
// implicit (one-line) string or nested block-style collection
|
||||
if( !is_parent_flow ) |
||||
{ |
||||
if( c == '?' ) |
||||
CV_PARSE_ERROR( "Complex keys are not supported" ); |
||||
if( c == '|' || c == '>' ) |
||||
CV_PARSE_ERROR( "Multi-line text literals are not supported" ); |
||||
} |
||||
|
||||
force_string: |
||||
endptr = ptr - 1; |
||||
|
||||
do c = *++endptr; |
||||
while( cv_isprint(c) && |
||||
(!is_parent_flow || (c != ',' && c != '}' && c != ']')) && |
||||
(is_parent_flow || c != ':' || value_type == CV_NODE_STRING)); |
||||
|
||||
if( endptr == ptr ) |
||||
CV_PARSE_ERROR( "Invalid character" ); |
||||
|
||||
if( is_parent_flow || c != ':' ) |
||||
{ |
||||
char* str_end = endptr; |
||||
node->tag = CV_NODE_STRING; |
||||
// strip spaces in the end of string
|
||||
do c = *--str_end; |
||||
while( str_end > ptr && c == ' ' ); |
||||
str_end++; |
||||
node->data.str = cvMemStorageAllocString( fs->memstorage, ptr, (int)(str_end - ptr) ); |
||||
ptr = endptr; |
||||
return ptr; |
||||
} |
||||
struct_flags = CV_NODE_MAP; |
||||
} |
||||
else |
||||
struct_flags = CV_NODE_SEQ; |
||||
|
||||
icvFSCreateCollection( fs, struct_flags + |
||||
(node->info ? CV_NODE_USER : 0), node ); |
||||
|
||||
indent = (int)(ptr - fs->buffer_start); |
||||
is_simple = true; |
||||
|
||||
for(;;) |
||||
{ |
||||
CvFileNode* elem = 0; |
||||
|
||||
if( CV_NODE_IS_MAP(struct_flags) ) |
||||
{ |
||||
ptr = icvYMLParseKey( fs, ptr, node, &elem ); |
||||
} |
||||
else |
||||
{ |
||||
c = *ptr++; |
||||
if( c != '-' ) |
||||
CV_PARSE_ERROR( "Block sequence elements must be preceded with \'-\'" ); |
||||
|
||||
elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 ); |
||||
} |
||||
CV_Assert(elem); |
||||
ptr = icvYMLSkipSpaces( fs, ptr, indent + 1, INT_MAX ); |
||||
ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, indent + 1 ); |
||||
if( CV_NODE_IS_MAP(struct_flags) ) |
||||
elem->tag |= CV_NODE_NAMED; |
||||
is_simple = is_simple && !CV_NODE_IS_COLLECTION(elem->tag); |
||||
|
||||
ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ); |
||||
if( ptr - fs->buffer_start != indent ) |
||||
{ |
||||
if( ptr - fs->buffer_start < indent ) |
||||
break; |
||||
else |
||||
CV_PARSE_ERROR( "Incorrect indentation" ); |
||||
} |
||||
if( memcmp( ptr, "...", 3 ) == 0 ) |
||||
break; |
||||
} |
||||
|
||||
node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0; |
||||
} |
||||
|
||||
return ptr; |
||||
} |
||||
|
||||
|
||||
void icvYMLParse( CvFileStorage* fs ) |
||||
{ |
||||
char* ptr = fs->buffer_start; |
||||
int is_first = 1; |
||||
|
||||
for(;;) |
||||
{ |
||||
// 0. skip leading comments and directives and ...
|
||||
// 1. reach the first item
|
||||
for(;;) |
||||
{ |
||||
ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ); |
||||
if( !ptr ) |
||||
return; |
||||
|
||||
if( *ptr == '%' ) |
||||
{ |
||||
if( memcmp( ptr, "%YAML", 5 ) == 0 && |
||||
memcmp( ptr, "%YAML:1.", 8 ) != 0 && |
||||
memcmp( ptr, "%YAML 1.", 8 ) != 0) |
||||
CV_PARSE_ERROR( "Unsupported YAML version (it must be 1.x)" ); |
||||
*ptr = '\0'; |
||||
} |
||||
else if( *ptr == '-' ) |
||||
{ |
||||
if( memcmp(ptr, "---", 3) == 0 ) |
||||
{ |
||||
ptr += 3; |
||||
break; |
||||
} |
||||
else if( is_first ) |
||||
break; |
||||
} |
||||
else if( cv_isalnum(*ptr) || *ptr=='_') |
||||
{ |
||||
if( !is_first ) |
||||
CV_PARSE_ERROR( "The YAML streams must start with '---', except the first one" ); |
||||
break; |
||||
} |
||||
else if( fs->dummy_eof ) |
||||
break; |
||||
else |
||||
CV_PARSE_ERROR( "Invalid or unsupported syntax" ); |
||||
} |
||||
|
||||
ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ); |
||||
if( memcmp( ptr, "...", 3 ) != 0 ) |
||||
{ |
||||
// 2. parse the collection
|
||||
CvFileNode* root_node = (CvFileNode*)cvSeqPush( fs->roots, 0 ); |
||||
|
||||
ptr = icvYMLParseValue( fs, ptr, root_node, CV_NODE_NONE, 0 ); |
||||
if( !CV_NODE_IS_COLLECTION(root_node->tag) ) |
||||
CV_PARSE_ERROR( "Only collections as YAML streams are supported by this parser" ); |
||||
|
||||
// 3. parse until the end of file or next collection
|
||||
ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX ); |
||||
if( !ptr ) |
||||
return; |
||||
} |
||||
|
||||
if( fs->dummy_eof ) |
||||
break; |
||||
ptr += 3; |
||||
is_first = 0; |
||||
} |
||||
} |
||||
|
||||
|
||||
/****************************************************************************************\
|
||||
* YAML Emitter * |
||||
\****************************************************************************************/ |
||||
|
||||
void icvYMLWrite( CvFileStorage* fs, const char* key, const char* data ) |
||||
{ |
||||
check_if_write_struct_is_delayed( fs ); |
||||
if ( fs->state_of_writing_base64 == base64::fs::Uncertain ) |
||||
{ |
||||
switch_to_Base64_state( fs, base64::fs::NotUse ); |
||||
} |
||||
else if ( fs->state_of_writing_base64 == base64::fs::InUse ) |
||||
{ |
||||
CV_Error( CV_StsError, "At present, output Base64 data only." ); |
||||
} |
||||
|
||||
int i, keylen = 0; |
||||
int datalen = 0; |
||||
int struct_flags; |
||||
char* ptr; |
||||
|
||||
struct_flags = fs->struct_flags; |
||||
|
||||
if( key && key[0] == '\0' ) |
||||
key = 0; |
||||
|
||||
if( CV_NODE_IS_COLLECTION(struct_flags) ) |
||||
{ |
||||
if( (CV_NODE_IS_MAP(struct_flags) ^ (key != 0)) ) |
||||
CV_Error( CV_StsBadArg, "An attempt to add element without a key to a map, " |
||||
"or add element with key to sequence" ); |
||||
} |
||||
else |
||||
{ |
||||
fs->is_first = 0; |
||||
struct_flags = CV_NODE_EMPTY | (key ? CV_NODE_MAP : CV_NODE_SEQ); |
||||
} |
||||
|
||||
if( key ) |
||||
{ |
||||
keylen = (int)strlen(key); |
||||
if( keylen == 0 ) |
||||
CV_Error( CV_StsBadArg, "The key is an empty" ); |
||||
|
||||
if( keylen > CV_FS_MAX_LEN ) |
||||
CV_Error( CV_StsBadArg, "The key is too long" ); |
||||
} |
||||
|
||||
if( data ) |
||||
datalen = (int)strlen(data); |
||||
|
||||
if( CV_NODE_IS_FLOW(struct_flags) ) |
||||
{ |
||||
int new_offset; |
||||
ptr = fs->buffer; |
||||
if( !CV_NODE_IS_EMPTY(struct_flags) ) |
||||
*ptr++ = ','; |
||||
new_offset = (int)(ptr - fs->buffer_start) + keylen + datalen; |
||||
if( new_offset > fs->wrap_margin && new_offset - fs->struct_indent > 10 ) |
||||
{ |
||||
fs->buffer = ptr; |
||||
ptr = icvFSFlush(fs); |
||||
} |
||||
else |
||||
*ptr++ = ' '; |
||||
} |
||||
else |
||||
{ |
||||
ptr = icvFSFlush(fs); |
||||
if( !CV_NODE_IS_MAP(struct_flags) ) |
||||
{ |
||||
*ptr++ = '-'; |
||||
if( data ) |
||||
*ptr++ = ' '; |
||||
} |
||||
} |
||||
|
||||
if( key ) |
||||
{ |
||||
if( !cv_isalpha(key[0]) && key[0] != '_' ) |
||||
CV_Error( CV_StsBadArg, "Key must start with a letter or _" ); |
||||
|
||||
ptr = icvFSResizeWriteBuffer( fs, ptr, keylen ); |
||||
|
||||
for( i = 0; i < keylen; i++ ) |
||||
{ |
||||
char c = key[i]; |
||||
|
||||
ptr[i] = c; |
||||
if( !cv_isalnum(c) && c != '-' && c != '_' && c != ' ' ) |
||||
CV_Error( CV_StsBadArg, "Key names may only contain alphanumeric characters [a-zA-Z0-9], '-', '_' and ' '" ); |
||||
} |
||||
|
||||
ptr += keylen; |
||||
*ptr++ = ':'; |
||||
if( !CV_NODE_IS_FLOW(struct_flags) && data ) |
||||
*ptr++ = ' '; |
||||
} |
||||
|
||||
if( data ) |
||||
{ |
||||
ptr = icvFSResizeWriteBuffer( fs, ptr, datalen ); |
||||
memcpy( ptr, data, datalen ); |
||||
ptr += datalen; |
||||
} |
||||
|
||||
fs->buffer = ptr; |
||||
fs->struct_flags = struct_flags & ~CV_NODE_EMPTY; |
||||
} |
||||
|
||||
|
||||
void icvYMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags, const char* type_name) |
||||
{ |
||||
int parent_flags; |
||||
char buf[CV_FS_MAX_LEN + 1024]; |
||||
const char* data = 0; |
||||
|
||||
if ( type_name && *type_name == '\0' ) |
||||
type_name = 0; |
||||
|
||||
struct_flags = (struct_flags & (CV_NODE_TYPE_MASK|CV_NODE_FLOW)) | CV_NODE_EMPTY; |
||||
if( !CV_NODE_IS_COLLECTION(struct_flags)) |
||||
CV_Error( CV_StsBadArg, |
||||
"Some collection type - CV_NODE_SEQ or CV_NODE_MAP, must be specified" ); |
||||
|
||||
if (type_name && memcmp(type_name, "binary", 6) == 0) |
||||
{ |
||||
/* reset struct flag. in order not to print ']' */ |
||||
struct_flags = CV_NODE_SEQ; |
||||
sprintf(buf, "!!binary |"); |
||||
data = buf; |
||||
} |
||||
else if( CV_NODE_IS_FLOW(struct_flags)) |
||||
{ |
||||
char c = CV_NODE_IS_MAP(struct_flags) ? '{' : '['; |
||||
struct_flags |= CV_NODE_FLOW; |
||||
|
||||
if( type_name ) |
||||
sprintf( buf, "!!%s %c", type_name, c ); |
||||
else |
||||
{ |
||||
buf[0] = c; |
||||
buf[1] = '\0'; |
||||
} |
||||
data = buf; |
||||
} |
||||
else if( type_name ) |
||||
{ |
||||
sprintf( buf, "!!%s", type_name ); |
||||
data = buf; |
||||
} |
||||
|
||||
icvYMLWrite( fs, key, data ); |
||||
|
||||
parent_flags = fs->struct_flags; |
||||
cvSeqPush( fs->write_stack, &parent_flags ); |
||||
fs->struct_flags = struct_flags; |
||||
|
||||
if( !CV_NODE_IS_FLOW(parent_flags) ) |
||||
fs->struct_indent += CV_YML_INDENT + CV_NODE_IS_FLOW(struct_flags); |
||||
} |
||||
|
||||
|
||||
void icvYMLEndWriteStruct( CvFileStorage* fs ) |
||||
{ |
||||
int parent_flags = 0, struct_flags; |
||||
char* ptr; |
||||
|
||||
struct_flags = fs->struct_flags; |
||||
if( fs->write_stack->total == 0 ) |
||||
CV_Error( CV_StsError, "EndWriteStruct w/o matching StartWriteStruct" ); |
||||
|
||||
cvSeqPop( fs->write_stack, &parent_flags ); |
||||
|
||||
if( CV_NODE_IS_FLOW(struct_flags) ) |
||||
{ |
||||
ptr = fs->buffer; |
||||
if( ptr > fs->buffer_start + fs->struct_indent && !CV_NODE_IS_EMPTY(struct_flags) ) |
||||
*ptr++ = ' '; |
||||
*ptr++ = CV_NODE_IS_MAP(struct_flags) ? '}' : ']'; |
||||
fs->buffer = ptr; |
||||
} |
||||
else if( CV_NODE_IS_EMPTY(struct_flags) ) |
||||
{ |
||||
ptr = icvFSFlush(fs); |
||||
memcpy( ptr, CV_NODE_IS_MAP(struct_flags) ? "{}" : "[]", 2 ); |
||||
fs->buffer = ptr + 2; |
||||
} |
||||
|
||||
if( !CV_NODE_IS_FLOW(parent_flags) ) |
||||
fs->struct_indent -= CV_YML_INDENT + CV_NODE_IS_FLOW(struct_flags); |
||||
assert( fs->struct_indent >= 0 ); |
||||
|
||||
fs->struct_flags = parent_flags; |
||||
} |
||||
|
||||
|
||||
void icvYMLStartNextStream( CvFileStorage* fs ) |
||||
{ |
||||
if( !fs->is_first ) |
||||
{ |
||||
while( fs->write_stack->total > 0 ) |
||||
icvYMLEndWriteStruct(fs); |
||||
|
||||
fs->struct_indent = 0; |
||||
icvFSFlush(fs); |
||||
icvPuts( fs, "...\n" ); |
||||
icvPuts( fs, "---\n" ); |
||||
fs->buffer = fs->buffer_start; |
||||
} |
||||
} |
||||
|
||||
|
||||
void icvYMLWriteInt( CvFileStorage* fs, const char* key, int value ) |
||||
{ |
||||
char buf[128]; |
||||
icvYMLWrite( fs, key, icv_itoa( value, buf, 10 )); |
||||
} |
||||
|
||||
|
||||
void icvYMLWriteReal( CvFileStorage* fs, const char* key, double value ) |
||||
{ |
||||
char buf[128]; |
||||
icvYMLWrite( fs, key, icvDoubleToString( buf, value )); |
||||
} |
||||
|
||||
|
||||
void icvYMLWriteString( CvFileStorage* fs, const char* key, const char* str, int quote) |
||||
{ |
||||
char buf[CV_FS_MAX_LEN*4+16]; |
||||
char* data = (char*)str; |
||||
int i, len; |
||||
|
||||
if( !str ) |
||||
CV_Error( CV_StsNullPtr, "Null string pointer" ); |
||||
|
||||
len = (int)strlen(str); |
||||
if( len > CV_FS_MAX_LEN ) |
||||
CV_Error( CV_StsBadArg, "The written string is too long" ); |
||||
|
||||
if( quote || len == 0 || str[0] != str[len-1] || (str[0] != '\"' && str[0] != '\'') ) |
||||
{ |
||||
int need_quote = quote || len == 0 || str[0] == ' '; |
||||
data = buf; |
||||
*data++ = '\"'; |
||||
for( i = 0; i < len; i++ ) |
||||
{ |
||||
char c = str[i]; |
||||
|
||||
if( !need_quote && !cv_isalnum(c) && c != '_' && c != ' ' && c != '-' && |
||||
c != '(' && c != ')' && c != '/' && c != '+' && c != ';' ) |
||||
need_quote = 1; |
||||
|
||||
if( !cv_isalnum(c) && (!cv_isprint(c) || c == '\\' || c == '\'' || c == '\"') ) |
||||
{ |
||||
*data++ = '\\'; |
||||
if( cv_isprint(c) ) |
||||
*data++ = c; |
||||
else if( c == '\n' ) |
||||
*data++ = 'n'; |
||||
else if( c == '\r' ) |
||||
*data++ = 'r'; |
||||
else if( c == '\t' ) |
||||
*data++ = 't'; |
||||
else |
||||
{ |
||||
sprintf( data, "x%02x", c ); |
||||
data += 3; |
||||
} |
||||
} |
||||
else |
||||
*data++ = c; |
||||
} |
||||
if( !need_quote && (cv_isdigit(str[0]) || |
||||
str[0] == '+' || str[0] == '-' || str[0] == '.' )) |
||||
need_quote = 1; |
||||
|
||||
if( need_quote ) |
||||
*data++ = '\"'; |
||||
*data++ = '\0'; |
||||
data = buf + !need_quote; |
||||
} |
||||
|
||||
icvYMLWrite( fs, key, data ); |
||||
} |
||||
|
||||
|
||||
void icvYMLWriteComment( CvFileStorage* fs, const char* comment, int eol_comment ) |
||||
{ |
||||
int len; //, indent;
|
||||
int multiline; |
||||
const char* eol; |
||||
char* ptr; |
||||
|
||||
if( !comment ) |
||||
CV_Error( CV_StsNullPtr, "Null comment" ); |
||||
|
||||
len = (int)strlen(comment); |
||||
eol = strchr(comment, '\n'); |
||||
multiline = eol != 0; |
||||
ptr = fs->buffer; |
||||
|
||||
if( !eol_comment || multiline || |
||||
fs->buffer_end - ptr < len || ptr == fs->buffer_start ) |
||||
ptr = icvFSFlush( fs ); |
||||
else |
||||
*ptr++ = ' '; |
||||
|
||||
while( comment ) |
||||
{ |
||||
*ptr++ = '#'; |
||||
*ptr++ = ' '; |
||||
if( eol ) |
||||
{ |
||||
ptr = icvFSResizeWriteBuffer( fs, ptr, (int)(eol - comment) + 1 ); |
||||
memcpy( ptr, comment, eol - comment + 1 ); |
||||
fs->buffer = ptr + (eol - comment); |
||||
comment = eol + 1; |
||||
eol = strchr( comment, '\n' ); |
||||
} |
||||
else |
||||
{ |
||||
len = (int)strlen(comment); |
||||
ptr = icvFSResizeWriteBuffer( fs, ptr, len ); |
||||
memcpy( ptr, comment, len ); |
||||
fs->buffer = ptr + len; |
||||
comment = 0; |
||||
} |
||||
ptr = icvFSFlush( fs ); |
||||
} |
||||
} |
||||
Loading…
Reference in new issue