fork download 
  1.  
  2. #include <bits/stdc++.h>
  3. #include <string>
  4. using namespace std;
  5. struct curlybrace
  6. {
  7. 	 const char *separator=",";
  8. 	 const char *closing_char="}";
  9. 	 const char *token_char=":";
  10. } ;
  11. struct value_array
  12. {
  13. 	 const char *separator=",";
  14. 	  const char *closing_char="]";
  15. 	  const char *token_char=":";
  16. };
  17.  
  18. class baseComp {
  19. protected:
  20. 	enum types {integer, floater, doubled, strings, array_t ,composite};
  21. public:
  22.  
  23. 	virtual void parse() {};
  24. 	virtual void print() {};
  25. 	types check(const char* str) {
  26.  
  27. 		bool flag=false;
  28. 		if (str=="[") {
  29. 			return array_t;
  30. 		}
  31. 		else if (str,"{")
  32. 		    return composite;
  33. 		while (*str++!='\0') 
  34. 		{
  35. 			if ((*str>='0' && *str<='9'))
  36. 			{
  37. 				continue;
  38. 			}else 
  39. 			{
  40. 			    if (!flag && *str=='.')
  41. 				    flag=true;
  42. 			    else if(flag && *str=='.')
  43.                     return strings;
  44.                 else if (flag && *str>='0' && *str<='9')
  45.                 {
  46.                     continue;
  47. 				}
  48. 				else
  49. 				    return strings;
  50. 			}
  51. 		}
  52. 		    if (flag) return floater;
  53. 		    else return integer;
  54. 	}
  55. };
  56.  
  57. template <class T>
  58. class LeafComp:  public baseComp
  59. {
  60. 	T data;
  61.     string key;
  62.     std::pair<string, T> m_p;
  63. public:
  64.  
  65. 	LeafComp():baseComp() { }
  66. 	LeafComp( T d, const char* k):baseComp(), data(d) { key= string(k);
  67. 	    m_p= std::make_pair(key, data);
  68. 	}
  69.  
  70. 	void parse() {}
  71. 	void print() {
  72. 	cout<<key<<":"<<data<<endl;
  73. 	}
  74. };
  75.  
  76. template<>
  77. void LeafComp<string>::print(){
  78. 	cout<<"hi";
  79. }
  80.  
  81. template<>
  82. void LeafComp<vector<baseComp*>>:: print() {
  83. 	for (baseComp* x: data) {
  84. 		cout<<"["<<endl;
  85. 		x->print();
  86. 		cout<<"]"<<endl;
  87. 	}
  88. }
  89. template<>
  90. void LeafComp<baseComp*>:: print() {
  91. 	cout<<"{"<<endl;
  92. 	data->print();
  93. 	cout<<"}"<<endl;
  94. }
  95. template<class del=curlybrace>
  96. class Comp: public baseComp
  97. {
  98.  
  99. protected :
  100. 	const char** json_ptr;
  101.     const del delobj;
  102.  
  103. public:
  104.     const char* getStartDel(){
  105.         return delobj.separator;
  106.     };
  107.     const char* getEndchar(){
  108.         return delobj.closing_char;
  109.     };
  110.     const char* gettokenchar(){
  111.         return delobj.token_char;
  112.     }
  113.     const char* getseparator(){
  114.         return delobj.separator;
  115.     }
  116.     vector<baseComp*> components;
  117. 	Comp (const char** sptr): baseComp(),json_ptr(sptr) {}
  118. 	Comp():baseComp() {
  119. 		json_ptr=nullptr;
  120. 	}
  121.     void tokenise(string s);
  122. 	void print() {
  123. 	    for_each (components.begin(), components.end(), [](baseComp* ptr){ ptr->print();});
  124. 	}
  125.  
  126.     void checks(types type_T, const char* t2 , const char* t1=nullptr){
  127.          switch ( type_T) 
  128. 			    {
  129.     				case integer:
  130.     				{	LeafComp<int> *li= new LeafComp<int> (atoi(t2), t1);
  131.     					components.push_back(li);
  132.     					break;
  133.     				}
  134.     				case floater:
  135.     				{	LeafComp<float>* lf = new LeafComp<float> (atof(t2), t1);
  136.     					components.push_back(lf);
  137.     					break;
  138.     				}
  139.     				case doubled:
  140.     				{	LeafComp<double>* ld= new LeafComp<double> {atof(t2), t1};
  141.     					components.push_back(ld);
  142.     					break;
  143.     				}
  144.     				case strings:
  145.     				{	LeafComp<string>*ls= new LeafComp<string> {string(t2), t1};
  146.     					components.push_back(ls);
  147.     					break;
  148.     				}
  149.     				case array_t:
  150.     				{
  151.     				    const char ** ptr=&t2;
  152.     					Comp<value_array>* ca= new Comp<value_array> (ptr);
  153.     					ca->parse();
  154.     					LeafComp<vector<baseComp*>>* la = new LeafComp<vector<baseComp*>> {ca->components, t1};
  155.     					components.push_back(la);
  156.     					break;
  157.     				}
  158.     				case composite:
  159.     				{	
  160.     				    //string newstr= string(t2).substr(1, strlen(t2)-1);
  161.  
  162.     					const char ** dummyptr=&t2;
  163.     					Comp<curlybrace>* ca= new Comp<curlybrace> (dummyptr);
  164.     					ca->parse();
  165.     					components.insert(ca->components.end(),ca->components.begin(), ca->components.end());
  166.     					break;
  167.     				}
  168. 			    }
  169.  
  170.     }
  171.  
  172. 	//parse
  173. 	void parse()
  174. 	{
  175. 		string str=string("");
  176.  
  177. 		while( *(++(*json_ptr)) != '\0')
  178. 		{
  179.  
  180. 			if(*json_ptr=="{")
  181. 			{
  182. 				Comp<curlybrace>* c= new Comp<curlybrace>(json_ptr);
  183.  
  184. 				c->parse();
  185. 				components.push_back(c);
  186. 			}
  187. 			else if(*json_ptr==getEndchar() )
  188. 			{
  189.  
  190. 			    Comp<del>::tokenise(str);
  191. 				str=string("");
  192. 			}
  193. 			else
  194. 			    str+=**json_ptr;
  195. 		}
  196. 	}
  197. };
  198. template<>
  199. void Comp<value_array>::tokenise(string str){
  200.  
  201.                 char *tok1= nullptr;
  202. 				const char * sep= getseparator();
  203.  
  204. 				tok1= strtok(&str[0], sep);
  205. 				while(tok1!=NULL)
  206. 				{
  207.                     types type_T= check(tok1);
  208.                     checks(type_T,tok1);
  209.     				tok1= strtok(NULL,sep);
  210. 				}
  211. }
  212. template<>
  213.  void Comp<curlybrace>::tokenise(string str){
  214.                 char *tok1= nullptr; const char *tok2=nullptr;const char *tok3=nullptr;
  215. 				vector<char*> v;
  216. 				const char * sep= getseparator();
  217.  
  218. 				tok1= strtok(&str[0], sep);
  219. 				v.push_back(tok1);
  220.  
  221. 				while (tok1!=NULL)
  222. 				{
  223.                     tok1=strtok(NULL,sep);
  224.                     v.push_back(tok1);
  225. 			    }
  226. 			    for (auto tok: v){
  227. 			        tok2= strtok(tok, gettokenchar());
  228.         		    tok3= strtok(NULL, gettokenchar());
  229.         		    types type_T= check(tok3);
  230.                     checks(type_T,tok3,tok2);
  231. 			    }
  232.     }
  233.  
  234.  
  235. int main()
  236. {
  237. 	string json=string("{\"salary\": \"1lPA\", \"contract\":10}");
  238. 	const char*ptr=&json[0];
  239.     const char** json_ptr=&ptr;
  240. 	Comp<curlybrace> obj(json_ptr);
  241.  
  242. 	obj.parse();
  243. 	obj.print();
  244.  
  245. 	//delete ptr;
  246. 	return 0;
  247. }
Success #stdin #stdout 0s 5276KB
comments (?)
stdin 
Standard input is empty
stdout 
Standard output is empty
https://ideone.com/mvPWVf
language:
C++ (gcc 8.3)
created:
12 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!