A Whole New World (clang-format edition)

I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?

I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon

A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format

A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code

1 files changed, 180 insertions, 216 deletions

diff --git a/core/io/stream_peer.cpp b/core/io/stream_peer.cpp
index 3c4719269..07df47f8c 100644
--- a/core/io/stream_peer.cpp
+++ b/core/io/stream_peer.cpp
@@ -29,21 +29,21 @@
 #include "stream_peer.h"
 #include "io/marshalls.h"
 
-Error StreamPeer::_put_data(const PoolVector<uint8_t>& p_data) {
+Error StreamPeer::_put_data(const PoolVector<uint8_t> &p_data) {
 
 	int len = p_data.size();
-	if (len==0)
+	if (len == 0)
 		return OK;
 	PoolVector<uint8_t>::Read r = p_data.read();
-	return put_data(&r[0],len);
+	return put_data(&r[0], len);
 }
 
-Array StreamPeer::_put_partial_data(const PoolVector<uint8_t>& p_data) {
+Array StreamPeer::_put_partial_data(const PoolVector<uint8_t> &p_data) {
 
 	Array ret;
 
 	int len = p_data.size();
-	if (len==0) {
+	if (len == 0) {
 		ret.push_back(OK);
 		ret.push_back(0);
 		return ret;
@@ -51,24 +51,23 @@ Array StreamPeer::_put_partial_data(const PoolVector<uint8_t>& p_data) {
 
 	PoolVector<uint8_t>::Read r = p_data.read();
 	int sent;
-	Error err = put_partial_data(&r[0],len,sent);
+	Error err = put_partial_data(&r[0], len, sent);
 
-	if (err!=OK) {
-		sent=0;
+	if (err != OK) {
+		sent = 0;
 	}
 	ret.push_back(err);
 	ret.push_back(sent);
 	return ret;
 }
 
-
 Array StreamPeer::_get_data(int p_bytes) {
 
 	Array ret;
 
 	PoolVector<uint8_t> data;
 	data.resize(p_bytes);
-	if (data.size()!=p_bytes) {
+	if (data.size() != p_bytes) {
 
 		ret.push_back(ERR_OUT_OF_MEMORY);
 		ret.push_back(PoolVector<uint8_t>());
@@ -76,12 +75,11 @@ Array StreamPeer::_get_data(int p_bytes) {
 	}
 
 	PoolVector<uint8_t>::Write w = data.write();
-	Error err = get_data(&w[0],p_bytes);
+	Error err = get_data(&w[0], p_bytes);
 	w = PoolVector<uint8_t>::Write();
 	ret.push_back(err);
 	ret.push_back(data);
 	return ret;
-
 }
 
 Array StreamPeer::_get_partial_data(int p_bytes) {
@@ -90,7 +88,7 @@ Array StreamPeer::_get_partial_data(int p_bytes) {
 
 	PoolVector<uint8_t> data;
 	data.resize(p_bytes);
-	if (data.size()!=p_bytes) {
+	if (data.size() != p_bytes) {
 
 		ret.push_back(ERR_OUT_OF_MEMORY);
 		ret.push_back(PoolVector<uint8_t>());
@@ -99,12 +97,12 @@ Array StreamPeer::_get_partial_data(int p_bytes) {
 
 	PoolVector<uint8_t>::Write w = data.write();
 	int received;
-	Error err = get_partial_data(&w[0],p_bytes,received);
+	Error err = get_partial_data(&w[0], p_bytes, received);
 	w = PoolVector<uint8_t>::Write();
 
-	if (err!=OK) {
+	if (err != OK) {
 		data.resize(0);
-	} else 	if (received!=data.size()) {
+	} else if (received != data.size()) {
 
 		data.resize(received);
 	}
@@ -112,12 +110,11 @@ Array StreamPeer::_get_partial_data(int p_bytes) {
 	ret.push_back(err);
 	ret.push_back(data);
 	return ret;
-
 }
 
 void StreamPeer::set_big_endian(bool p_enable) {
 
-	big_endian=p_enable;
+	big_endian = p_enable;
 }
 
 bool StreamPeer::is_big_endian_enabled() const {
@@ -125,389 +122,359 @@ bool StreamPeer::is_big_endian_enabled() const {
 	return big_endian;
 }
 
-
 void StreamPeer::put_u8(uint8_t p_val) {
-	put_data((const uint8_t*)&p_val,1);
-
+	put_data((const uint8_t *)&p_val, 1);
 }
 
-void StreamPeer::put_8(int8_t p_val){
+void StreamPeer::put_8(int8_t p_val) {
 
-	put_data((const uint8_t*)&p_val,1);
+	put_data((const uint8_t *)&p_val, 1);
 }
-void StreamPeer::put_u16(uint16_t p_val){
+void StreamPeer::put_u16(uint16_t p_val) {
 
 	if (big_endian) {
-		p_val=BSWAP16(p_val);
+		p_val = BSWAP16(p_val);
 	}
 	uint8_t buf[2];
-	encode_uint16(p_val,buf);
-	put_data(buf,2);
-
+	encode_uint16(p_val, buf);
+	put_data(buf, 2);
 }
-void StreamPeer::put_16(int16_t p_val){
+void StreamPeer::put_16(int16_t p_val) {
 
 	if (big_endian) {
-		p_val=BSWAP16(p_val);
+		p_val = BSWAP16(p_val);
 	}
 	uint8_t buf[2];
-	encode_uint16(p_val,buf);
-	put_data(buf,2);
-
+	encode_uint16(p_val, buf);
+	put_data(buf, 2);
 }
-void StreamPeer::put_u32(uint32_t p_val){
+void StreamPeer::put_u32(uint32_t p_val) {
 
 	if (big_endian) {
-		p_val=BSWAP32(p_val);
+		p_val = BSWAP32(p_val);
 	}
 	uint8_t buf[4];
-	encode_uint32(p_val,buf);
-	put_data(buf,4);
-
+	encode_uint32(p_val, buf);
+	put_data(buf, 4);
 }
-void StreamPeer::put_32(int32_t p_val){
+void StreamPeer::put_32(int32_t p_val) {
 
 	if (big_endian) {
-		p_val=BSWAP32(p_val);
+		p_val = BSWAP32(p_val);
 	}
 	uint8_t buf[4];
-	encode_uint32(p_val,buf);
-	put_data(buf,4);
-
+	encode_uint32(p_val, buf);
+	put_data(buf, 4);
 }
-void StreamPeer::put_u64(uint64_t p_val){
+void StreamPeer::put_u64(uint64_t p_val) {
 
 	if (big_endian) {
-		p_val=BSWAP64(p_val);
+		p_val = BSWAP64(p_val);
 	}
 	uint8_t buf[8];
-	encode_uint64(p_val,buf);
-	put_data(buf,8);
-
+	encode_uint64(p_val, buf);
+	put_data(buf, 8);
 }
-void StreamPeer::put_64(int64_t p_val){
+void StreamPeer::put_64(int64_t p_val) {
 
 	if (big_endian) {
-		p_val=BSWAP64(p_val);
+		p_val = BSWAP64(p_val);
 	}
 	uint8_t buf[8];
-	encode_uint64(p_val,buf);
-	put_data(buf,8);
-
+	encode_uint64(p_val, buf);
+	put_data(buf, 8);
 }
-void StreamPeer::put_float(float p_val){
+void StreamPeer::put_float(float p_val) {
 
 	uint8_t buf[4];
 
-	encode_float(p_val,buf);
+	encode_float(p_val, buf);
 	if (big_endian) {
-		uint32_t *p32=(uint32_t *)buf;
-		*p32=BSWAP32(*p32);
+		uint32_t *p32 = (uint32_t *)buf;
+		*p32 = BSWAP32(*p32);
 	}
 
-	put_data(buf,4);
-
+	put_data(buf, 4);
 }
-void StreamPeer::put_double(double p_val){
+void StreamPeer::put_double(double p_val) {
 
 	uint8_t buf[8];
-	encode_double(p_val,buf);
+	encode_double(p_val, buf);
 	if (big_endian) {
-		uint64_t *p64=(uint64_t *)buf;
-		*p64=BSWAP64(*p64);
+		uint64_t *p64 = (uint64_t *)buf;
+		*p64 = BSWAP64(*p64);
 	}
-	put_data(buf,8);
-
+	put_data(buf, 8);
 }
-void StreamPeer::put_utf8_string(const String& p_string) {
+void StreamPeer::put_utf8_string(const String &p_string) {
 
-	CharString cs=p_string.utf8();
+	CharString cs = p_string.utf8();
 	put_u32(p_string.length());
-	put_data((const uint8_t*)cs.get_data(),cs.length());
-
+	put_data((const uint8_t *)cs.get_data(), cs.length());
 }
-void StreamPeer::put_var(const Variant& p_variant){
+void StreamPeer::put_var(const Variant &p_variant) {
 
-	int len=0;
+	int len = 0;
 	Vector<uint8_t> buf;
-	encode_variant(p_variant,NULL,len);
+	encode_variant(p_variant, NULL, len);
 	buf.resize(len);
 	put_32(len);
-	encode_variant(p_variant,buf.ptr(),len);
-	put_data(buf.ptr(),buf.size());
-
-
+	encode_variant(p_variant, buf.ptr(), len);
+	put_data(buf.ptr(), buf.size());
 }
 
-uint8_t StreamPeer::get_u8(){
+uint8_t StreamPeer::get_u8() {
 
 	uint8_t buf[1];
-	get_data(buf,1);
+	get_data(buf, 1);
 	return buf[0];
 }
-int8_t StreamPeer::get_8(){
+int8_t StreamPeer::get_8() {
 
 	uint8_t buf[1];
-	get_data(buf,1);
+	get_data(buf, 1);
 	return buf[0];
-
 }
-uint16_t StreamPeer::get_u16(){
+uint16_t StreamPeer::get_u16() {
 
 	uint8_t buf[2];
-	get_data(buf,2);
+	get_data(buf, 2);
 	uint16_t r = decode_uint16(buf);
 	if (big_endian) {
-		r=BSWAP16(r);
+		r = BSWAP16(r);
 	}
 	return r;
-
 }
-int16_t StreamPeer::get_16(){
+int16_t StreamPeer::get_16() {
 
 	uint8_t buf[2];
-	get_data(buf,2);
+	get_data(buf, 2);
 	uint16_t r = decode_uint16(buf);
 	if (big_endian) {
-		r=BSWAP16(r);
+		r = BSWAP16(r);
 	}
 	return r;
-
 }
-uint32_t StreamPeer::get_u32(){
+uint32_t StreamPeer::get_u32() {
 
 	uint8_t buf[4];
-	get_data(buf,4);
+	get_data(buf, 4);
 	uint32_t r = decode_uint32(buf);
 	if (big_endian) {
-		r=BSWAP32(r);
+		r = BSWAP32(r);
 	}
 	return r;
-
 }
-int32_t StreamPeer::get_32(){
+int32_t StreamPeer::get_32() {
 
 	uint8_t buf[4];
-	get_data(buf,4);
+	get_data(buf, 4);
 	uint32_t r = decode_uint32(buf);
 	if (big_endian) {
-		r=BSWAP32(r);
+		r = BSWAP32(r);
 	}
 	return r;
-
 }
-uint64_t StreamPeer::get_u64(){
+uint64_t StreamPeer::get_u64() {
 
 	uint8_t buf[8];
-	get_data(buf,8);
+	get_data(buf, 8);
 	uint64_t r = decode_uint64(buf);
 	if (big_endian) {
-		r=BSWAP64(r);
+		r = BSWAP64(r);
 	}
 	return r;
-
 }
-int64_t StreamPeer::get_64(){
+int64_t StreamPeer::get_64() {
 
 	uint8_t buf[8];
-	get_data(buf,8);
+	get_data(buf, 8);
 	uint64_t r = decode_uint64(buf);
 	if (big_endian) {
-		r=BSWAP64(r);
+		r = BSWAP64(r);
 	}
 	return r;
-
 }
-float StreamPeer::get_float(){
+float StreamPeer::get_float() {
 
 	uint8_t buf[4];
-	get_data(buf,4);
+	get_data(buf, 4);
 
 	if (big_endian) {
-		uint32_t *p32=(uint32_t *)buf;
-		*p32=BSWAP32(*p32);
+		uint32_t *p32 = (uint32_t *)buf;
+		*p32 = BSWAP32(*p32);
 	}
 
 	return decode_float(buf);
 }
 
-float StreamPeer::get_double(){
+float StreamPeer::get_double() {
 
 	uint8_t buf[8];
-	get_data(buf,8);
+	get_data(buf, 8);
 
 	if (big_endian) {
-		uint64_t *p64=(uint64_t *)buf;
-		*p64=BSWAP64(*p64);
+		uint64_t *p64 = (uint64_t *)buf;
+		*p64 = BSWAP64(*p64);
 	}
 
 	return decode_double(buf);
-
 }
-String StreamPeer::get_string(int p_bytes){
+String StreamPeer::get_string(int p_bytes) {
 
-	ERR_FAIL_COND_V(p_bytes<0,String());
+	ERR_FAIL_COND_V(p_bytes < 0, String());
 
 	Vector<char> buf;
-	Error err = buf.resize(p_bytes+1);
-	ERR_FAIL_COND_V(err!=OK,String());
-	err = get_data((uint8_t*)&buf[0],p_bytes);
-	ERR_FAIL_COND_V(err!=OK,String());
-	buf[p_bytes]=0;
+	Error err = buf.resize(p_bytes + 1);
+	ERR_FAIL_COND_V(err != OK, String());
+	err = get_data((uint8_t *)&buf[0], p_bytes);
+	ERR_FAIL_COND_V(err != OK, String());
+	buf[p_bytes] = 0;
 	return buf.ptr();
-
 }
-String StreamPeer::get_utf8_string(int p_bytes){
+String StreamPeer::get_utf8_string(int p_bytes) {
 
-	ERR_FAIL_COND_V(p_bytes<0,String());
+	ERR_FAIL_COND_V(p_bytes < 0, String());
 
 	Vector<uint8_t> buf;
 	Error err = buf.resize(p_bytes);
-	ERR_FAIL_COND_V(err!=OK,String());
-	err = get_data(buf.ptr(),p_bytes);
-	ERR_FAIL_COND_V(err!=OK,String());
+	ERR_FAIL_COND_V(err != OK, String());
+	err = get_data(buf.ptr(), p_bytes);
+	ERR_FAIL_COND_V(err != OK, String());
 
 	String ret;
-	ret.parse_utf8((const char*)buf.ptr(),buf.size());
+	ret.parse_utf8((const char *)buf.ptr(), buf.size());
 	return ret;
-
 }
-Variant StreamPeer::get_var(){
+Variant StreamPeer::get_var() {
 
 	int len = get_32();
 	Vector<uint8_t> var;
 	Error err = var.resize(len);
-	ERR_FAIL_COND_V(err!=OK,Variant());
-	err = get_data(var.ptr(),len);
-	ERR_FAIL_COND_V(err!=OK,Variant());
+	ERR_FAIL_COND_V(err != OK, Variant());
+	err = get_data(var.ptr(), len);
+	ERR_FAIL_COND_V(err != OK, Variant());
 
 	Variant ret;
-	decode_variant(ret,var.ptr(),len);
+	decode_variant(ret, var.ptr(), len);
 	return ret;
 }
 
-
 void StreamPeer::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("put_data","data"),&StreamPeer::_put_data);
-	ClassDB::bind_method(D_METHOD("put_partial_data","data"),&StreamPeer::_put_partial_data);
+	ClassDB::bind_method(D_METHOD("put_data", "data"), &StreamPeer::_put_data);
+	ClassDB::bind_method(D_METHOD("put_partial_data", "data"), &StreamPeer::_put_partial_data);
 
-	ClassDB::bind_method(D_METHOD("get_data","bytes"),&StreamPeer::_get_data);
-	ClassDB::bind_method(D_METHOD("get_partial_data","bytes"),&StreamPeer::_get_partial_data);
+	ClassDB::bind_method(D_METHOD("get_data", "bytes"), &StreamPeer::_get_data);
+	ClassDB::bind_method(D_METHOD("get_partial_data", "bytes"), &StreamPeer::_get_partial_data);
 
-	ClassDB::bind_method(D_METHOD("get_available_bytes"),&StreamPeer::get_available_bytes);
+	ClassDB::bind_method(D_METHOD("get_available_bytes"), &StreamPeer::get_available_bytes);
 
-	ClassDB::bind_method(D_METHOD("set_big_endian","enable"),&StreamPeer::set_big_endian);
-	ClassDB::bind_method(D_METHOD("is_big_endian_enabled"),&StreamPeer::is_big_endian_enabled);
+	ClassDB::bind_method(D_METHOD("set_big_endian", "enable"), &StreamPeer::set_big_endian);
+	ClassDB::bind_method(D_METHOD("is_big_endian_enabled"), &StreamPeer::is_big_endian_enabled);
 
-	ClassDB::bind_method(D_METHOD("put_8","val"),&StreamPeer::put_8);
-	ClassDB::bind_method(D_METHOD("put_u8","val"),&StreamPeer::put_u8);
-	ClassDB::bind_method(D_METHOD("put_16","val"),&StreamPeer::put_16);
-	ClassDB::bind_method(D_METHOD("put_u16","val"),&StreamPeer::put_u16);
-	ClassDB::bind_method(D_METHOD("put_32","val"),&StreamPeer::put_32);
-	ClassDB::bind_method(D_METHOD("put_u32","val"),&StreamPeer::put_u32);
-	ClassDB::bind_method(D_METHOD("put_64","val"),&StreamPeer::put_64);
-	ClassDB::bind_method(D_METHOD("put_u64","val"),&StreamPeer::put_u64);
-	ClassDB::bind_method(D_METHOD("put_float","val"),&StreamPeer::put_float);
-	ClassDB::bind_method(D_METHOD("put_double","val"),&StreamPeer::put_double);
-	ClassDB::bind_method(D_METHOD("put_utf8_string","val"),&StreamPeer::put_utf8_string);
-	ClassDB::bind_method(D_METHOD("put_var","val:Variant"),&StreamPeer::put_var);
+	ClassDB::bind_method(D_METHOD("put_8", "val"), &StreamPeer::put_8);
+	ClassDB::bind_method(D_METHOD("put_u8", "val"), &StreamPeer::put_u8);
+	ClassDB::bind_method(D_METHOD("put_16", "val"), &StreamPeer::put_16);
+	ClassDB::bind_method(D_METHOD("put_u16", "val"), &StreamPeer::put_u16);
+	ClassDB::bind_method(D_METHOD("put_32", "val"), &StreamPeer::put_32);
+	ClassDB::bind_method(D_METHOD("put_u32", "val"), &StreamPeer::put_u32);
+	ClassDB::bind_method(D_METHOD("put_64", "val"), &StreamPeer::put_64);
+	ClassDB::bind_method(D_METHOD("put_u64", "val"), &StreamPeer::put_u64);
+	ClassDB::bind_method(D_METHOD("put_float", "val"), &StreamPeer::put_float);
+	ClassDB::bind_method(D_METHOD("put_double", "val"), &StreamPeer::put_double);
+	ClassDB::bind_method(D_METHOD("put_utf8_string", "val"), &StreamPeer::put_utf8_string);
+	ClassDB::bind_method(D_METHOD("put_var", "val:Variant"), &StreamPeer::put_var);
 
-	ClassDB::bind_method(D_METHOD("get_8"),&StreamPeer::get_8);
-	ClassDB::bind_method(D_METHOD("get_u8"),&StreamPeer::get_u8);
-	ClassDB::bind_method(D_METHOD("get_16"),&StreamPeer::get_16);
-	ClassDB::bind_method(D_METHOD("get_u16"),&StreamPeer::get_u16);
-	ClassDB::bind_method(D_METHOD("get_32"),&StreamPeer::get_32);
-	ClassDB::bind_method(D_METHOD("get_u32"),&StreamPeer::get_u32);
-	ClassDB::bind_method(D_METHOD("get_64"),&StreamPeer::get_64);
-	ClassDB::bind_method(D_METHOD("get_u64"),&StreamPeer::get_u64);
-	ClassDB::bind_method(D_METHOD("get_float"),&StreamPeer::get_float);
-	ClassDB::bind_method(D_METHOD("get_double"),&StreamPeer::get_double);
-	ClassDB::bind_method(D_METHOD("get_string","bytes"),&StreamPeer::get_string);
-	ClassDB::bind_method(D_METHOD("get_utf8_string","bytes"),&StreamPeer::get_utf8_string);
-	ClassDB::bind_method(D_METHOD("get_var:Variant"),&StreamPeer::get_var);
+	ClassDB::bind_method(D_METHOD("get_8"), &StreamPeer::get_8);
+	ClassDB::bind_method(D_METHOD("get_u8"), &StreamPeer::get_u8);
+	ClassDB::bind_method(D_METHOD("get_16"), &StreamPeer::get_16);
+	ClassDB::bind_method(D_METHOD("get_u16"), &StreamPeer::get_u16);
+	ClassDB::bind_method(D_METHOD("get_32"), &StreamPeer::get_32);
+	ClassDB::bind_method(D_METHOD("get_u32"), &StreamPeer::get_u32);
+	ClassDB::bind_method(D_METHOD("get_64"), &StreamPeer::get_64);
+	ClassDB::bind_method(D_METHOD("get_u64"), &StreamPeer::get_u64);
+	ClassDB::bind_method(D_METHOD("get_float"), &StreamPeer::get_float);
+	ClassDB::bind_method(D_METHOD("get_double"), &StreamPeer::get_double);
+	ClassDB::bind_method(D_METHOD("get_string", "bytes"), &StreamPeer::get_string);
+	ClassDB::bind_method(D_METHOD("get_utf8_string", "bytes"), &StreamPeer::get_utf8_string);
+	ClassDB::bind_method(D_METHOD("get_var:Variant"), &StreamPeer::get_var);
 }
 ////////////////////////////////
 
-
 void StreamPeerBuffer::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("seek","pos"),&StreamPeerBuffer::seek);
-	ClassDB::bind_method(D_METHOD("get_size"),&StreamPeerBuffer::get_size);
-	ClassDB::bind_method(D_METHOD("get_pos"),&StreamPeerBuffer::get_pos);
-	ClassDB::bind_method(D_METHOD("resize","size"),&StreamPeerBuffer::resize);
-	ClassDB::bind_method(D_METHOD("set_data_array","data"),&StreamPeerBuffer::set_data_array);
-	ClassDB::bind_method(D_METHOD("get_data_array"),&StreamPeerBuffer::get_data_array);
-	ClassDB::bind_method(D_METHOD("clear"),&StreamPeerBuffer::clear);
-	ClassDB::bind_method(D_METHOD("duplicate:StreamPeerBuffer"),&StreamPeerBuffer::duplicate);
-
+	ClassDB::bind_method(D_METHOD("seek", "pos"), &StreamPeerBuffer::seek);
+	ClassDB::bind_method(D_METHOD("get_size"), &StreamPeerBuffer::get_size);
+	ClassDB::bind_method(D_METHOD("get_pos"), &StreamPeerBuffer::get_pos);
+	ClassDB::bind_method(D_METHOD("resize", "size"), &StreamPeerBuffer::resize);
+	ClassDB::bind_method(D_METHOD("set_data_array", "data"), &StreamPeerBuffer::set_data_array);
+	ClassDB::bind_method(D_METHOD("get_data_array"), &StreamPeerBuffer::get_data_array);
+	ClassDB::bind_method(D_METHOD("clear"), &StreamPeerBuffer::clear);
+	ClassDB::bind_method(D_METHOD("duplicate:StreamPeerBuffer"), &StreamPeerBuffer::duplicate);
 }
 
+Error StreamPeerBuffer::put_data(const uint8_t *p_data, int p_bytes) {
 
-Error StreamPeerBuffer::put_data(const uint8_t* p_data,int p_bytes) {
-
-	if (p_bytes<=0)
+	if (p_bytes <= 0)
 		return OK;
 
-	if (pointer+p_bytes > data.size()) {
-		data.resize(pointer+p_bytes);
-
+	if (pointer + p_bytes > data.size()) {
+		data.resize(pointer + p_bytes);
 	}
 
 	PoolVector<uint8_t>::Write w = data.write();
-	copymem(&w[pointer],p_data,p_bytes);
+	copymem(&w[pointer], p_data, p_bytes);
 
-	pointer+=p_bytes;
+	pointer += p_bytes;
 	return OK;
 }
 
-Error StreamPeerBuffer::put_partial_data(const uint8_t* p_data,int p_bytes, int &r_sent){
+Error StreamPeerBuffer::put_partial_data(const uint8_t *p_data, int p_bytes, int &r_sent) {
 
-	r_sent=p_bytes;
-	return put_data(p_data,p_bytes);
+	r_sent = p_bytes;
+	return put_data(p_data, p_bytes);
 }
 
-Error StreamPeerBuffer::get_data(uint8_t* p_buffer, int p_bytes){
+Error StreamPeerBuffer::get_data(uint8_t *p_buffer, int p_bytes) {
 
 	int recv;
-	get_partial_data(p_buffer,p_bytes,recv);
-	if (recv!=p_bytes)
+	get_partial_data(p_buffer, p_bytes, recv);
+	if (recv != p_bytes)
 		return ERR_INVALID_PARAMETER;
 
 	return OK;
-
 }
-Error StreamPeerBuffer::get_partial_data(uint8_t* p_buffer, int p_bytes,int &r_received){
-
+Error StreamPeerBuffer::get_partial_data(uint8_t *p_buffer, int p_bytes, int &r_received) {
 
-	if (pointer+p_bytes > data.size()) {
-		r_received=data.size()-pointer;
-		if (r_received<=0) {
-			r_received=0;
+	if (pointer + p_bytes > data.size()) {
+		r_received = data.size() - pointer;
+		if (r_received <= 0) {
+			r_received = 0;
 			return OK; //you got 0
 		}
 	} else {
-		r_received=p_bytes;
+		r_received = p_bytes;
 	}
 
 	PoolVector<uint8_t>::Read r = data.read();
-	copymem(p_buffer,r.ptr(),r_received);
-	
+	copymem(p_buffer, r.ptr(), r_received);
+
 	// FIXME: return what? OK or ERR_*
 }
 
 int StreamPeerBuffer::get_available_bytes() const {
 
-	return data.size()-pointer;
+	return data.size() - pointer;
 }
 
-void StreamPeerBuffer::seek(int p_pos){
+void StreamPeerBuffer::seek(int p_pos) {
 
 	ERR_FAIL_COND(p_pos < 0);
 	ERR_FAIL_COND(p_pos > data.size());
-	pointer=p_pos;
+	pointer = p_pos;
 }
-int StreamPeerBuffer::get_size() const{
+int StreamPeerBuffer::get_size() const {
 
 	return data.size();
 }
@@ -517,40 +484,37 @@ int StreamPeerBuffer::get_pos() const {
 	return pointer;
 }
 
-void StreamPeerBuffer::resize(int p_size){
+void StreamPeerBuffer::resize(int p_size) {
 
 	data.resize(p_size);
 }
 
-void StreamPeerBuffer::set_data_array(const PoolVector<uint8_t> & p_data){
+void StreamPeerBuffer::set_data_array(const PoolVector<uint8_t> &p_data) {
 
-	data=p_data;
-	pointer=0;
+	data = p_data;
+	pointer = 0;
 }
 
-PoolVector<uint8_t> StreamPeerBuffer::get_data_array() const{
+PoolVector<uint8_t> StreamPeerBuffer::get_data_array() const {
 
 	return data;
 }
 
-
 void StreamPeerBuffer::clear() {
 
 	data.resize(0);
-	pointer=0;
+	pointer = 0;
 }
 
-
 Ref<StreamPeerBuffer> StreamPeerBuffer::duplicate() const {
 
 	Ref<StreamPeerBuffer> spb;
 	spb.instance();
-	spb->data=data;
+	spb->data = data;
 	return spb;
 }
 
-
 StreamPeerBuffer::StreamPeerBuffer() {
 
-	pointer=0;
+	pointer = 0;
 }