qad/libs/utils/chunkstream.h

/*
	QAD - Qt ADvanced

	Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef CHUNKSTREAM_H
#define CHUNKSTREAM_H

#include <QDataStream>
#include <QBuffer>
#include <QByteArray>
#include <QDebug>
#include <QMap>
#include "qad_utils_export.h"


class QAD_UTILS_EXPORT ChunkStream
{
public:
	enum Version {
		Version_1 /*! First, old version */,
		Version_2 /*! Second, more optimized version */ = 2,
	};
	ChunkStream(const QByteArray & data): version_(Version_2) {setSource(data);}
	ChunkStream(QDataStream & str): version_(Version_2) {setSource(str);}
	ChunkStream(QByteArray * data = 0, Version v = Version_2): version_(v) {setSource(data);}
	ChunkStream(Version v): version_(v) {setSource(0);}
	~ChunkStream();

	template <typename T>
	struct Chunk {
		Chunk(int i, const T & d): id(i), data(d) {}
		int id;
		T data;
	};
	template <typename T>
	struct ChunkConst {
		ChunkConst(int i, const T & d): id(i), data(d) {}
		int id;
		const T & data;
	};
	template <typename T> static ChunkConst<T> chunk(int id, const T & data) {return ChunkConst<T>(id, data);}

	template <typename T> ChunkStream & add(int id, const T & data) {*this << ChunkConst<T>(id, data); return *this;}

	void setSource(const QByteArray & data);
	void setSource(QDataStream & str);
	void setSource(QByteArray * data);
	QDataStream & dataStream() {return stream_;}
	QByteArray data() const {return tmp_data;}
	bool atEnd() const {return stream_.atEnd();}
	Version version() const {return (Version)version_;}



	int read();
	void readAll();
	int getID() {return last_id;}

	template <typename T>
	void get(T & v) const {v = getData<T>();}

	template <typename T> typename std::enable_if<!std::is_enum<T>::value, T>::type
	getData() const {
		QDataStream s(last_data);
		s.setVersion(QDataStream::Qt_4_8);
		T ret;
		s >> ret;
		return ret;
	}
	template <typename T> typename std::enable_if<std::is_enum<T>::value, T>::type
	getData() const {
		QDataStream s(last_data);
		s.setVersion(QDataStream::Qt_4_8);
		typename std::underlying_type<T>::type ret;
		s >> ret;
		return (T)ret;
	}

	template <typename T> typename std::enable_if<!std::is_enum<T>::value, const ChunkStream &>::type
	get(int id, T & v) const {
		QByteArray ba = data_map.value(id);
		if (!ba.isEmpty()) {
			QDataStream s(ba);
			s.setVersion(QDataStream::Qt_4_8);
			s >> v;
		}
		return *this;
	}
	template <typename T> typename std::enable_if<std::is_enum<T>::value, const ChunkStream &>::type
	get(int id, T & v) const {
		QByteArray ba = data_map.value(id);
		if (!ba.isEmpty()) {
			QDataStream s(ba);
			s.setVersion(QDataStream::Qt_4_8);
			typename std::underlying_type<T>::type iv;
			s >> iv;
			v = (T)iv;
		}
		return *this;
	}

private:
	void _init();

	static uint readVInt(QDataStream & s);
	static void writeVInt(QDataStream & s, uint val);

	int last_id;
	uchar version_;
	QByteArray * data_, last_data, tmp_data;
	QBuffer buffer;
	QDataStream stream_;
	QMap<int, QByteArray> data_map;

	template <typename T> friend ChunkStream & operator <<(ChunkStream & s, const ChunkStream::Chunk<T> & c);
	template <typename T> friend ChunkStream & operator <<(ChunkStream & s, const ChunkStream::ChunkConst<T> & c);
};

template <typename T> typename std::enable_if<!std::is_enum<T>::value, void>::type
__writeChunkData(QByteArray & ba, const ChunkStream::Chunk<T> & c) {
	QDataStream bas(&ba, QIODevice::WriteOnly);
	bas.setVersion(QDataStream::Qt_4_8);
	bas << c.data;
}
template <typename T> typename std::enable_if<std::is_enum<T>::value, void>::type
__writeChunkData(QByteArray & ba, const ChunkStream::Chunk<T> & c) {
	QDataStream bas(&ba, QIODevice::WriteOnly);
	bas.setVersion(QDataStream::Qt_4_8);
	typename std::underlying_type<T>::type iv = c.data;
	bas << iv;
}
template <typename T> typename std::enable_if<!std::is_enum<T>::value, void>::type
__writeChunkConstData(QByteArray & ba, const ChunkStream::ChunkConst<T> & c) {
	QDataStream bas(&ba, QIODevice::WriteOnly);
	bas.setVersion(QDataStream::Qt_4_8);
	bas << c.data;
}
template <typename T> typename std::enable_if<std::is_enum<T>::value, void>::type
__writeChunkConstData(QByteArray & ba, const ChunkStream::ChunkConst<T> & c) {
	QDataStream bas(&ba, QIODevice::WriteOnly);
	bas.setVersion(QDataStream::Qt_4_8);
	typename std::underlying_type<T>::type iv = c.data;
	bas << iv;
}

template <typename T>
ChunkStream & operator <<(ChunkStream & s, const ChunkStream::Chunk<T> & c) {
	QByteArray ba;
	__writeChunkData(ba, c);
	switch (s.version_) {
	case ChunkStream::Version_1:
		s.stream_ << c.id << ba;
		break;
	case ChunkStream::Version_2:
		if (s.data_->isEmpty())
			s.stream_ << uchar(uchar(s.version_) | 0x80);
		ChunkStream::writeVInt(s.stream_, c.id);
		ChunkStream::writeVInt(s.stream_, ba.size());
		s.stream_.writeRawData(ba.data(), ba.size());
		break;
	default: break;
	}
	return s;
}

template <typename T>
ChunkStream & operator <<(ChunkStream & s, const ChunkStream::ChunkConst<T> & c) {
	QByteArray ba;
	__writeChunkConstData(ba, c);
	switch (s.version_) {
	case ChunkStream::Version_1:
		s.stream_ << c.id << ba;
		break;
	case ChunkStream::Version_2:
		if (s.data_->isEmpty())
			s.stream_ << uchar(uchar(s.version_) | 0x80);
		ChunkStream::writeVInt(s.stream_, c.id);
		ChunkStream::writeVInt(s.stream_, ba.size());
		s.stream_.writeRawData(ba.data(), ba.size());
		break;
	default: break;
	}
	return s;
}

#endif // CHUNKSTREAM_H