v8serialize - 源码 - 源码 - 免费下载

v8serialize

文件大小： unknow

源码售价： 5 个金币积分规则积分充值

资源说明：A header-only library for simple conversion between javascript and C++ objects and primitives.

v8serialize (aka v8s)
=====================

v8serialize is a header-only library for easy conversion between 
C++ and JavaScript types. The primary goal of the library is to use it as
a method of serializing C++ data to json and back using v8.

Building and dependencies 
-------------------------

v8s is header only so there's nothing to build. Just download, include and use.
v8s depends on STL and some boost libraries (just `boost::shared_ptr` at 
the moment, boost::function might be added later). boost functionality is 
optional, define `V8SERIALIZE_NO_BOOST` to use v8s without it.

Supported compilers
-------------------

So far v8s has only been tested on g++ 4.5.2, but it should work without
problems with any sane compiler.

Converting types
----------------


Converting types from JavaScript to C++ is done using `from_js`, from C++ 
to JavaScript using `to_js`. v8s can convert the following types out of 
the box: 
 
* `int16_t`, `uint16_t`
* `int32_t`, `uint32_t`
* `int64_t`, `uint64_t`
* `double`
* `float`
* `std::string` (const char* conversion is not supported)
* `std::vector` and `std::list` if T is convertible
* `std::map` if T is convertible
* `boost::shared_ptr` if T is convertible *(only if* `V8SERIALIZE_NO_BOOST` *is not defined)*

The library exposes two functions for conversion : `v8s::from_js` and `v8s::to_js`. 
All v8serialize functions and classes are members of `namespace v8s`, but it will 
be omitted in the examples for readability. 

Examples
--------

    Handle js_value; //value to convert to C++
    uint32_t cpp_value; //value to convert to
    
    from_js(js_value, cpp_value);

This will either convert js_value to cpp_value or throw a `bad_conversion_exception`
if js_value can't be converted to a uint32_t. To convert from
C++ types to JavaScript, use `to_js`. Note that `to_js` returns a 
`v8::Handle`, whereas `from_js` requires you to pass a C++ value 
to be filled by reference.

    //An example of converting a std::string to a JavaScript string :
    std::string cpp_str = "Yay!";
    Handle js_str = to_js(cpp_str);

A more advanced example of out-of-the-box conversion would be converting
nested structures. An object with lists defined in json :

    {
    "even":  [2, 4, 6, 8, 10],
    "odd":   [1, 3, 5, 7, 9],
    }

Can be converted to C++ like this :

    Handle js_numbers = json_from_file("example.json");
    std::map > cpp_numbers;
    from_js(js_numbers, cpp_numbers);
    
    int_32 n = cpp_numbers["odd"][3];
    //n = 5

To convert user types to and from JavaScript, the user type `T` must expose 
static methods `void load(load_info &data, T &o)` and 
`void save(save_info &data, const T &o)`. `load` will be called when 
converting from JavaScript to C++, `save` when converting from C++ to 
JavaScript. Take a look at these two structs :

    struct screen
    {
		int width, height;
		bool fullscreen;
		int bpp;
		
		static void load(v8s::load_info &data, screen &o)
		static void save(v8s::save_info &data, const screen &o);
	};

	struct config
	{
		screen screen_settings;
		std::string window_name;
		
		static void load(v8s::load_info &data, config &o)
		static void save(v8s::save_info &data, const config &o);		
	};


Since they aren't convertible out of the box, we will have to provide
static `save` and `load` methods. 

	void screen::load(v8s::load_info &data, screen &o)
	{
		data.get("width", o.width, 800);
		data.get("height", o.height, 600);
		data.get("bpp", o.bpp, 32);
		data.get("fullscreen", o.fullscreen, false);
	}
	void screen::save(v8s::save_info &data, const screen &o)
	{
		data.set("width", o.width);
		data.set("height", o.height);
		data.set("bpp", o.bpp);
		data.set("fullscreen", o.fullscreen);
	}    
    
And for `config` :

	void load(v8s::load_info &data, config &o)
	{
		data.get("screen", o.screen_settings);
		data.get("windowName", o.window_name, std::string("Generic window"));
	}
	void save(v8s::save_info &data, const config &o)
	{
		data.set("screen", o.screen_settings);
		data.set("windowName", o.window_name);
	}

Converting them from js to C++ and back :

	boost::shared_ptr config;
	Handle json = json_file_parse("config_in.json");
	from_js(json, config);

	Handle out = to_js(config);
	json_to_file(out, "config_out.json");    

The `load_info::get` method can be called with 3 arguments, the third one 
being the default value. In `config::load`, property "windowName" is being
converted and written into `o.window_name`. If the conversion fails, either
because "windowName" is not a string or is simply not defined, value of 
`o.window_name` will be set to the default value "Generic window".

When converting from a JavaScript type to `boost::shared_ptr`, if 
there is a valid conversion from that type to T, a value of type T will be
created using `new` and converted as it normally would.

部分文件列表（点击文件名可查看文件内容）

					
									本源码包内暂不包含可直接显示的源代码文件，请下载源码包。