zetjsoncpp::deserialize<zetjsoncpp::BooleanJsonVar<>>("true");

zetjsoncpp::deserialize<zetjsoncpp::ArrayBooleanJsonVar<>>(
"["
   "true"
   ",false"
   ",true"
"]");

zetjsoncpp::deserialize<zetjsoncpp::MapBooleanJsonVar<>>(
"{"
   "\"id1\":true"
   ",\"id2\":false"
   ",\"id3\":true"
"}");

zetjsoncpp::deserialize<zetjsoncpp::NumberJsonVar<>>("1");

zetjsoncpp::deserialize<zetjsoncpp::ArrayNumberJsonVar<>>(
"["
   "1"
   ",3.7e+2"
   ",-3"
"]");

zetjsoncpp::deserialize<zetjsoncpp::MapNumberJsonVar<>>(
"{"
   "\"id1\":1"
   ",\"id2\":3.7e+2"
   ",\"id3\":-3"
"}");

zetjsoncpp::deserialize<zetjsoncpp::StringJsonVar<>>("\"my_string\"")

zetjsoncpp::deserialize<ArrayStringJsonVar<>>(
"["
    "\"string_1\""
    ",\"string_2\""
    ",\"string_3\""
"]");

MapStringJsonVar<> *m3=zetjsoncpp::deserialize<zetjsoncpp::MapStringJsonVar<>>(
"{"
    "\"id1\":\"string_1\""
    ",\"id2\":\"string_2\""
    ",\"id3\":\"string_3\""
"}");

MapArrayStringJsonVar<> *m3=zetjsoncpp::deserialize<zetjsoncpp::MapArrayStringJsonVar<>>(
"{"
   "\"id1\":[\"string_1\",\"string_2\",\"string_3\"]"
   ",\"id2\":[\"string_4\",\"string_5\",\"string_6\"]"
   ",\"id3\":[\"string_7\",\"string_8\",\"string_9\"]"
"}");

typedef struct{
    zetjsoncpp::StringJsonVar<ZJ_CONST_CHAR("encoding")>    encoding;
    zetjsoncpp::NumberJsonVar<ZJ_CONST_CHAR("length")>      length;     
    zetjsoncpp::BooleanJsonVar<ZJ_CONST_CHAR("use_space")>  use_space; 
}JsonSample;

auto json_object=zetjsoncpp::deserialize<zetjsoncpp::ObjectJsonVar<JsonSample>>(
"{"
   "\"encoding\":\"UTF-8\""
   ",\"length\":1000"
   ",\"use_space\":false"         
"}");

if(json_object->encoding.isDeserialized()){

// value deserialized ok. do something... 

}

zetjsoncpp::deserialize<zetjsoncpp::ArrayObjectJsonVar<JsonSample>>(
"[{"  
   "\"encoding\":\"UTF-8\""  
   ",\"length\":1000"   
   ",\"use_space\":false" 
  "},{"  
    "\"encoding\":\"ANSII\""  
    ",\"length\":1500"  
    ",\"use_space\":true" 
"}]");

zetjsoncpp::deserialize<zetjsoncpp::MapObjectJsonVar<JsonSample>>(
"{"
  "\"id1\":{"
     "\"encoding\":\"UTF-8\""  
     ",\"length\":1000"    
     ",\"use_space\":false" 
  "}"
  ",\"id2\":{"
      "\"encoding\":\"ANSII\""
      ",\"length\":1500"  
      ",\"use_space\":true" 
  "}"
"}");

// parse json var number
auto json_number=zetjsoncpp::deserialize<zetjsoncpp::NumberJsonVar<>>("2");

// change it by 3.5
json_number=3.5;

std::cout << zetjsoncpp::serialize(json_var); << std::enl;

// it outputs 3.5

#include "zetjsoncpp.h"

using zetjsoncpp::NumberJsonVar;
using zetjsoncpp::BooleanJsonVar;
using zetjsoncpp::StringJsonVar;
using zetjsoncpp::MapStringJsonVar;
using zetjsoncpp::ArrayNumberJsonVar;
using zetjsoncpp::ArrayStringJsonVar;
using zetjsoncpp::ObjectJsonVar;
using zetjsoncpp::ArrayObjectJsonVar;
using zetjsoncpp::MapObjectJsonVar;

typedef struct{
  // Number length
  NumberJsonVar<ZJ_CONST_CHAR("length")>  length;

  // Boolean use_space
  BooleanJsonVar<ZJ_CONST_CHAR("use_space")>use_space;
}Ident;

typedef struct{
  // String code
  StringJsonVar<ZJ_CONST_CHAR("code")>  code;

  // Map of strings general_texts
  MapStringJsonVar<ZJ_CONST_CHAR("general_texts")>  general_texts;
}Language;


typedef struct{
  // String type
  StringJsonVar<ZJ_CONST_CHAR("type")>  type;

  // String channels
  StringJsonVar<ZJ_CONST_CHAR("channels")>  channels;

  // Array of numbers data
  ArrayNumberJsonVar<ZJ_CONST_CHAR("data")>  data;
}Interpolation;

typedef struct
{
  // String encoding
  StringJsonVar<ZJ_CONST_CHAR("encoding")>  encoding;

  // Number number
  NumberJsonVar<ZJ_CONST_CHAR("number")>  number;

  // Array of strings plug-ins
  ArrayStringJsonVar<ZJ_CONST_CHAR("plug-ins")>  plugins;

  // Object indent
  ObjectJsonVar<Ident,ZJ_CONST_CHAR("indent")>  indent;

  // Object languages
  ArrayObjectJsonVar<Language,ZJ_CONST_CHAR("languages")>  languages;

  // Map of objects interpolations
  MapObjectJsonVar<Interpolation,ZJ_CONST_CHAR("interpolations")>  interpolations;


   // Map of array of strings
   zetjsoncpp::MapArrayStringJsonVar<ZJ_CONST_CHAR("map_array_strings")>
   map_array_strings;

}SampleJson;

int main(int argc, char *argv[]){

	try{
		auto json_object=zetjsoncpp::deserialize_file<ObjectJsonVar<SampleJson>>("sample.json");
		
		// the values before modifications.
		std::cout << "---------------------------------------------------" << std::endl;
		std::cout << " Before modifications:"<< std::endl;
		std::cout << zetjsoncpp::serialize(json_object);
		
		// From here we can operate with loaded data in our program using c++ operators
		// put m_use_space to false...
		json_object->indent.use_space = false;
		
		// iterate of all plugins and replace with random strings...
		for(unsigned i = 0; i < json_object->plugins.size(); i++) {
			json_object->plugins[i] = "my_randomstring"+zetjsoncpp::String::integerToString(i+1);
		}

		// iterate of all interpolations and replace its data values...
		for(auto it_map = json_object->interpolations.begin(); it_map != json_object->interpolations.end(); it_map++) {
			for(auto it = it_map->second->data.begin(); it != it_map->second->data.end(); it++) {
			    *it = rand();
			}
		}
        
		// Modification of a map of array of strings...
		int k=0;
		for(auto it_map_array_strings : json_object->map_array_strings) {
			int j=0;
			
			for(size_t i=0; i < json_object->map_array_strings[it_map_array_strings.first].size(); i++) {
				json_object->map_array_strings[it_map_array_strings.first][i]="modified_string_"+std::to_string(k)+"_"+std::to_string(j);
				j++;
			}
			k++;
		}        

		std::cout << "--------------------------------------------------" << std::endl;
		std::cout << " After modifications:"<< std::endl;
		std::cout << zetjsoncpp::serialize(json_object);
	
	    // destroy json_object
	    delete json_object;
	}catch(std::exception & ex){
    	std::cerr << "Error:" << ex.what() << std::endl;
	}
}