Changeset 107

(2010/06/18 11:53) Almost 2 years ago

CHANGES: PKinilib now does not treat empty value as an error; 
ADDITIONS: warning functionality added to PKini_file_holder (so far just 1 warning about empty value);
FIXES: some tests of PKinilib now use strings instead of files; confusing names in PKinilib (those with "single line" changed; PKpreprocessed entry analyzer now expects values with no garbage at the end, garbage removal moved to preprocessor, where it should be;

Affected files

PKinilib/PKerror_holder.h (Quick diff)
PKinilib/PKhelpers.h (Quick diff)
PKinilib/PKinilib.h (Quick diff)
PKinilib/PKpreprocessed_entry_analyzer.h copied from PKinilib/PKsingle_line_entry_analyzer.h
PKinilib/PKpreprocessed_entry_parser.h copied from PKinilib/PKsingle_line_entry_parser.h
PKinilib/PKsingle_line_entry_analyzer.h
PKinilib/PKsingle_line_entry_parser.h
PKinilib_tests/PKinilib_tests.cpp (Quick diff)
test_text_files/wrong_section_name_backslash.ini
test_text_files/wrong_section_name_closing_sq_bracket.ini
test_text_files/wrong_section_name_equals.ini
test_text_files/wrong_section_name_newline_cr.ini
test_text_files/wrong_section_name_opening_sq_bracket.ini
test_text_files/wrong_section_name_semicolon.ini
test_text_files/wrong_section_name_space.ini
test_text_files/wrong_section_name_tab.ini

PKinilib/PKerror_holder.h Download diff

         ///get_errors is guaranteed to end with '_text';
         virtual void put_error(const std::string& _text);
         virtual void reset_errors();
+        bool has_errors()const;
         const std::string& get_errors()const;
     };
         err_msg="";
     }
+    inline bool PKstring_error_holder:: has_errors()const
+    {
+        return !err_msg.empty();
+    }
     inline const std::string& PKstring_error_holder::get_errors()const
     {
         return err_msg;

PKinilib/PKhelpers.h Download diff

	106		107
60	static const char_type defs[]={';','[',']','\\','=',0};	60	static const char_type defs[]={';','[',']','\\','=',0};
61	return defs;	61	return defs;
62	}	62	}
63	PKini_forbidden_chars(const string_type& _in_sec_name,	63	PKini_forbidden_chars(const string_type& _additional_in_sec_name,
64	const string_type& _in_key,	64	const string_type& _additional_in_key,
65	const string_type& _in_value):	65	const string_type& _additional_in_value):
66	in_sec_name(unify_strings(_in_sec_name,in_sec_name_defaults())),	66	in_sec_name(unify_strings(
67	in_key(unify_strings(_in_key,in_key_defaults())),	67	_additional_in_sec_name,in_sec_name_defaults())),
68	in_value(unify_strings(_in_value,in_value_defaults()))	68	in_key(unify_strings(_additional_in_key,in_key_defaults())),
		69	in_value(unify_strings(_additional_in_value,in_value_defaults()))
69	{}	70	{}
70	PKini_forbidden_chars():	71	PKini_forbidden_chars():
71	in_sec_name(in_sec_name_defaults()),	72	in_sec_name(in_sec_name_defaults()),

PKinilib/PKinilib.h Download diff

 #ifndef PKINILIB_H_DEFINED
 #define PKINILIB_H_DEFINED
-#include "PKsingle_line_entry_analyzer.h"
+#include "PKpreprocessed_entry_analyzer.h"
-#include "PKsingle_line_entry_parser.h"
+#include "PKpreprocessed_entry_parser.h"
 #include "PKerror_holder.h"
 #include "PKini_file_format_ASCII.h"
 #include "PKinilib_private.h"
 ///to/from ini files using the names of sections and keys;
 namespace PKinilib
 {
-    //documentation needed;
+    //different values of this enum tell PKini_file_holder when to write to
+    //the opened file stream;
+    //- NO_WRITE means that the stream is left unchanged;
+    //- WRITE_LAZY means that changes to ini entries are written to the file
+    //  just before it is closed;
+    //- WRITE_IMMEDIATELY tells to update the file contents immediately after
+    //  every change
+    //.
     enum PKini_write_flag
     {
         NO_WRITE=0,
     ///in the 'sections' map and the writing to the file happens in
     ///destructor; if you need to update the ini file averytime you change
     ///anything in the ini data, set 'lazy_write' member to false;
-    ///for the details about the used ini specification read PKINILIBDOC.txt;
     template<class file_format>
     class PKini_file_holder
     {
         PKini_write_flag write_flag;
         bool file_changed;
         PKini_forbidden_chars<char_type> forbidden_chars;
-//        std::string err_msg;
         PKstring_error_holder err_msg;
+        PKstring_error_holder warning_msgs;
         std::string filename;
         char_type semicolon[2];
       public:
         void set_forbidden_chars(
             const PKini_forbidden_chars<char_type>& _new_chars);
         void reset_err_msg();
+        void reset_warnings();
         ///those characters are forbidden in various parts of ini file, so
         ///if they are found in it, the reading process is terminated
         ///and an error message is put to 'err_msg' field;
         const PKini_forbidden_chars<char_type>& get_forbidden_chars()const;
         ///returns the last error message;
         const std::string& get_err_msg()const;
+        bool error_messages_exist()const;
+        const std::string& get_warning_msg()const;
+        bool warning_messages_exist()const;
         ///returns data if there is something associated with given
         ///arguments or nulls if there is not;
         ///returns pointer to internal data;
             string_type assembled_line;
         };
         struct PKanalysis_events:
-            public PKsingle_line_semantic_events<char_type>
+            public PKentry_analyzis_semantic_events<char_type>
         {
             PKini_file_holder& file_holder;
             string_type& current_section_name_buf;
             virtual void section_found(const string_type& _section_name);
             virtual void key_value_pair_found(const string_type& _key_name,
                 const string_type& _value_name);
+            virtual void empty_line_found(){}
         };
         friend struct PKanalysis_events;
         bool assemble_line(const string_type& _line,
         std::fstream* temp_file=new std::fstream(_filename.c_str(),
             std::ios_base::binary|std::ios_base::in|std::ios_base::out);
         if(file_format::OMITTED_BYTES)
-        {
-            //std::cout<<"OMITTED_BYTES"<<
-            //    (unsigned)(file_format::OMITTED_BYTES)<<std::endl;
             temp_file->ignore((unsigned)(file_format::OMITTED_BYTES),EOF);
-        }
         sections_map_type* temp_sections=0;
         std::list<line_type>* temp_file_contents=0;
         if(*temp_file)
         ///
         if(_line.empty())
             {return true;}
-        bool is_before_first_section_name=false;
-        if(_current_section_name_buf.empty())
-            is_before_first_section_name=true;
         bool no_error=true;
         PKassembling_output out;
-        no_error=assemble_line(_line,is_before_first_section_name,
+        no_error=assemble_line(_line,_current_section_name_buf.empty(),
             _multiline_key_and_value_buf,out,_err_msg);
         if(out.is_beginning_of_key_or_section)
         {
             _current_section_name_buf,
             temp_sections,
             _file_contents);
-        PKsingle_line_entry_analyzer<char_type> analyzer(
+        PKpreprocessed_entry_analyzer<char_type> analyzer(
             forbidden_chars);
         no_error=analyzer.analyze(out.assembled_line,
             !_current_section_name_buf.empty(),
             if(cur_pos<_line.length() && no_error &&
                 !line_is_a_beginning_of_multiline_entry)
             {
+                const char_type end_line_chars[]={';','\n','\r',0};
+                size_type end_line_pos=
+                    _line.find_first_of(end_line_chars,cur_pos);
+                if(end_line_pos==string_type::npos)
+                    {end_line_pos=_line.length();}
                 string_type rest_of_line=_line.substr(
-                    cur_pos,_line.length()-cur_pos);
+                    cur_pos,end_line_pos-cur_pos);
                 out.finished_assembling_and_has_content=true;
                 out.assembled_line_must_be_key_value_pair=false;
                 out.assembled_line=rest_of_line;
         temp_sections[current_section_name_buf][_key_name]=_value_name;
         temp_sections[current_section_name_buf][_key_name].in_file_iter=
             file_holder.get_last_good_line(file_contents);
+        if(_value_name.empty())
+        {
+            file_holder.warning_msgs.put_error(
+                "value for key ["+to_string(_key_name)+
+                "] of section ["+to_string(current_section_name_buf)+
+                "] has 0 length;");
+        }
     }
     template<class file_format>
     {
         if(file)
         {
-            //std::cout<<"close_file_finally..."<<std::endl;
             if(file_changed && write_flag==WRITE_LAZY)
                 {actualize_file();}
             file->close();
         {err_msg.reset_errors();}
     template<class file_format>
+    inline void PKini_file_holder<file_format>::reset_warnings()
+        {warning_msgs.reset_errors();}
+    template<class file_format>
     inline const PKini_forbidden_chars<typename file_format::char_type>&
         PKini_file_holder<file_format>::
       get_forbidden_chars()const
         {return forbidden_chars;}
     template<class file_format>
-    const std::string& PKini_file_holder<file_format>::
+    inline const std::string& PKini_file_holder<file_format>::
       get_err_msg()const
         {return err_msg.get_errors();}
+    template<class file_format>
+    inline bool PKini_file_holder<file_format>::error_messages_exist()const
+        {return err_msg.has_errors();}
+    template<class file_format>
+    inline const std::string& PKini_file_holder<file_format>::
+      get_warning_msg()const
+        {return warning_msgs.get_errors();}
+    template<class file_format>
+    inline bool PKini_file_holder<file_format>::warning_messages_exist()const
+        {return warning_msgs.has_errors();}
 }
 #endif
 ///921

PKinilib_tests/PKinilib_tests.cpp Download diff

	106		107
16	void test_PKini_file_format_ASCII_writing();	16	void test_PKini_file_format_ASCII_writing();
17	void test_PKini_file_format_ASCII_reading();	17	void test_PKini_file_format_ASCII_reading();
18	void test_PKini_file_holder();	18	void test_PKini_file_holder();
		19	void test_PKpreprocessed_entry_parser();
		20	void test_PKpreprocessed_entry_analyzer();
19	bool test_inferring_line_ending(const char* _ending);	21	bool test_inferring_line_ending(const char* _ending);
20	bool section_exist_and_has_correct_key_count(HolderT& _holder,	22	bool section_exist_and_has_correct_key_count(HolderT& _holder,
21	const char* _sec_name,size_t _count);	23	const char* _sec_name,size_t _count);
...		...
25	const key_val_vec_type& _args,std::string& _err_msg);	27	const key_val_vec_type& _args,std::string& _err_msg);
26	void put(key_val_vec_type& _vec,const char* _arg1,const char*_arg2);	28	void put(key_val_vec_type& _vec,const char* _arg1,const char*_arg2);
27	bool test_wrong_file(const char*);	29	bool test_wrong_file(const char*);
		30	bool test_section_name_line(const char* _line);
		31	bool test_key_value_line(const char* _line);
		32	struct semantic_events:public PKentry_analyzis_semantic_events<char>
		33	{
		34	bool key_value_fired;
		35	bool section_fired;
		36	bool empty_fired;
		37	std::string data;
		38	std::string separator;
		39	semantic_events():key_value_fired(false),section_fired(false),
		40	empty_fired(false),
		41	separator("][")
		42	{}
		43	virtual void empty_line_found()
		44	{
		45	empty_fired=true;
		46	}
		47	virtual void section_found(const string_type& _section_name)
		48	{
		49	section_fired=true;
		50	data=_section_name;
		51	}
		52	virtual void key_value_pair_found(const string_type& _key_name,
		53	const string_type& _value_name)
		54	{
		55	key_value_fired=true;
		56	data=_key_name+_value_name;
		57	}
		58	};
		59	bool test_key_value_classification(const char* _key,
		60	const char* _value,std::string& error_buf);
28	};	61	};
29		62
		63	bool test_PKinilib::pimpl::test_section_name_line(const char* _line)
		64	{
		65	PKpreprocessed_entry_parser<char> parser=
		66	PKini_forbidden_chars<char>();
		67	std::string result;
		68	PKstring_error_holder err_holder;
		69	return parser.parse_section_name(_line,result,err_holder);
		70	}
		71
		72	bool test_PKinilib::pimpl::test_key_value_line(const char* _line)
		73	{
		74	PKpreprocessed_entry_parser<char> parser=
		75	PKini_forbidden_chars<char>();
		76	std::string resulting_key;
		77	std::string resulting_value;
		78	PKstring_error_holder err_holder;
		79	return parser.parse_key_value(_line,resulting_key,
		80	resulting_value,err_holder);
		81	}
		82
30	bool test_PKinilib::pimpl::test_wrong_file(const char* _filename)	83	bool test_PKinilib::pimpl::test_wrong_file(const char* _filename)
31	{	84	{
32	bool good=true;	85	bool good=true;
...		...
410	PKTESTER_IS_TRUE(key_exists_and_value_equals(	463	PKTESTER_IS_TRUE(key_exists_and_value_equals(
411	holder,"section1","key1","h"));	464	holder,"section1","key1","h"));
412	}	465	}
413	//test incorrect files:
414	PKTESTER_IS_TRUE(test_wrong_file("test_text_files/"
415	"wrong_section_name_backslash.ini"));
416	PKTESTER_IS_TRUE(test_wrong_file("test_text_files/"
417	"wrong_section_name_closing_sq_bracket.ini"));
418	PKTESTER_IS_TRUE(test_wrong_file("test_text_files/"
419	"wrong_section_name_equals.ini"));
420	PKTESTER_IS_TRUE(test_wrong_file("test_text_files/"
421	"wrong_section_name_newline_cr.ini"));
422	PKTESTER_IS_TRUE(test_wrong_file("test_text_files/"
423	"wrong_section_name_equals.ini"));
424	}	466	}
425		467
		468	void test_PKinilib::pimpl::test_PKpreprocessed_entry_parser()
		469	{
		470	//test correct section names
		471	PKTESTER_IS_TRUE(test_section_name_line("[k]"));
		472	PKTESTER_IS_TRUE(test_section_name_line("[kg_fd_fd]"));
		473	PKTESTER_IS_TRUE(test_section_name_line("[_]"));
		474	PKTESTER_IS_TRUE(test_section_name_line("[kgfdfd]"));
		475	//test faulty section names
		476	PKTESTER_IS_FALSE(test_section_name_line("[kgfd\\fd]"));
		477	PKTESTER_IS_FALSE(test_section_name_line("[jksaf]]"));
		478	PKTESTER_IS_FALSE(test_section_name_line("[fkdas=fds]"));
		479	PKTESTER_IS_FALSE(test_section_name_line("[fdsafs\nfdsafsdfds]"));
		480	PKTESTER_IS_FALSE(test_section_name_line("[fdsj[kj]"));
		481	PKTESTER_IS_FALSE(test_section_name_line("[fdsafj;fds]"));
		482	PKTESTER_IS_FALSE(test_section_name_line("[fdsa ]"));
		483	PKTESTER_IS_FALSE(test_section_name_line("[fdsa\tfds]"));
		484	PKTESTER_IS_FALSE(test_section_name_line("[\vfdsafds]"));
		485	PKTESTER_IS_FALSE(test_section_name_line("[fdsafds\r]"));
		486	//test correct key-value pairs
		487	PKTESTER_IS_TRUE(test_key_value_line("fdklsl=fdslfj"));
		488	PKTESTER_IS_TRUE(test_key_value_line("fdklsl= fdslfj"));
		489	PKTESTER_IS_TRUE(test_key_value_line("fdklsl=fdslfj "));
		490	PKTESTER_IS_TRUE(test_key_value_line("fdklsl=\t\tfdslfj "));
		491	PKTESTER_IS_TRUE(test_key_value_line("fdklsl= fdslfj "));
		492	PKTESTER_IS_TRUE(test_key_value_line("fdk_lsl=fdslfj"));
		493	PKTESTER_IS_TRUE(test_key_value_line("_fdk_lsl_=fdslfj"));
		494	PKTESTER_IS_TRUE(test_key_value_line("_=fdslfj"));
		495	PKTESTER_IS_TRUE(test_key_value_line("a=fdslfj"));
		496	PKTESTER_IS_TRUE(test_key_value_line("a="));
		497	//test faulty key names
		498	PKTESTER_IS_FALSE(test_key_value_line(" fdklsl=fdslfj"));
		499	PKTESTER_IS_FALSE(test_key_value_line("fdklsl =fdslfj"));
		500	PKTESTER_IS_FALSE(test_key_value_line("fdk;lsl=fdslfj"));
		501	PKTESTER_IS_FALSE(test_key_value_line("fdk[lsl=fdslfj"));
		502	PKTESTER_IS_FALSE(test_key_value_line("fdklsl]=fdslfj"));
		503	PKTESTER_IS_FALSE(test_key_value_line("\\fdklsl=fdslfj"));
		504	PKTESTER_IS_FALSE(test_key_value_line("fd=klsl= fdslfj"));
		505	PKTESTER_IS_FALSE(test_key_value_line("fdkl\tsl=fdslfj"));
		506	PKTESTER_IS_FALSE(test_key_value_line("\vfdklsl=fdslfj"));
		507	PKTESTER_IS_FALSE(test_key_value_line("fdk\nlsl=fdslfj"));
		508	PKTESTER_IS_FALSE(test_key_value_line("fdk\rlsl=fdslfj"));
		509	//test faulty value names
		510	PKTESTER_IS_FALSE(test_key_value_line("fdklsl=f;dslfj"));
		511	PKTESTER_IS_FALSE(test_key_value_line("fdklsl=fdsl[fj"));
		512	PKTESTER_IS_FALSE(test_key_value_line("fdklsl=fd]slfj"));
		513	PKTESTER_IS_FALSE(test_key_value_line("fdklsl=fd]s\\lfj"));
		514	PKTESTER_IS_FALSE(test_key_value_line("fdklsl=fd]s=lfj"));
		515	}
		516
		517	bool test_PKinilib::pimpl::test_key_value_classification(
		518	const char* _key,
		519	const char* _value,
		520	std::string& error_buf)
		521	{
		522	error_buf="";
		523	PKpreprocessed_entry_analyzer<char> analyzer=
		524	PKini_forbidden_chars<char>();
		525	PKstring_error_holder errors;
		526	semantic_events events;
		527	analyzer.analyze(std::string(_key)+"="+_value,
		528	true,events,errors);
		529	if(events.key_value_fired!=true)
		530	{
		531	error_buf=errors.get_errors();
		532	return false;
		533	}
		534	return true;
		535	}
		536
		537	void test_PKinilib::pimpl::test_PKpreprocessed_entry_analyzer()
		538	{
		539	std::string err;
		540	//test real cases
		541	PKTESTER_IS_TRUE_MSG(test_key_value_classification(
		542	"fdsfds"," kljkgds fds' fds*& ",err),err);
		543	PKTESTER_IS_TRUE_MSG(test_key_value_classification(
		544	"_"," kljkgds fds' fds*& ",err),err);
		545	PKTESTER_IS_TRUE_MSG(test_key_value_classification(
		546	"_"," kljkg\nds f\rds' f\vd\rs*&\t\t\t\t \t",err),err);
		547	PKTESTER_IS_TRUE_MSG(test_key_value_classification(
		548	"_","\n",err),err);
		549	PKTESTER_IS_TRUE_MSG(test_key_value_classification(
		550	"_","\r",err),err);
		551	PKTESTER_IS_TRUE_MSG(test_key_value_classification(
		552	"_","",err),err);
		553	PKTESTER_IS_TRUE_MSG(test_key_value_classification(
		554	"_","\t",err),err);
		555	PKTESTER_IS_FALSE_MSG(test_key_value_classification(
		556	"","kkkk",err),err);
		557	PKTESTER_IS_FALSE_MSG(test_key_value_classification(
		558	"fdsfds "," kljkgds fds' fds*& ",err),err);
		559	PKTESTER_IS_FALSE_MSG(test_key_value_classification(
		560	" fdsfds "," kljkgds fds' fds*& ",err),err);
		561	PKTESTER_IS_FALSE_MSG(test_key_value_classification(
		562	" fdsfds"," kljkgds fds' fds*& ",err),err);
		563	}
		564
426	bool test_PKinilib::pimpl::test()	565	bool test_PKinilib::pimpl::test()
427	{	566	{
428	test_PKini_file_format_ASCII_writing();	567	test_PKini_file_format_ASCII_writing();
429	test_PKini_file_format_ASCII_reading();	568	test_PKini_file_format_ASCII_reading();
		569	test_PKpreprocessed_entry_parser();
		570	test_PKpreprocessed_entry_analyzer();
430	test_PKini_file_holder();	571	test_PKini_file_holder();
431	return PKunit::PKtest_manager::is_current_test_succesfull();	572	return PKunit::PKtest_manager::is_current_test_succesfull();
432	}	573	}

PKguiSpace

Changeset 107

Affected files

PKinilib/PKerror_holder.h Download diff

PKinilib/PKhelpers.h Download diff

PKinilib/PKinilib.h Download diff

PKinilib_tests/PKinilib_tests.cpp Download diff