Subversion Repositories spk

/*

  things used both in bob_dom_cut and bob_dom_bob are defined here

*/

#ifndef BOB_DOM_BASE_INCLUDED

#define BOB_DOM_BASE_INCLUDED

#include "../common/ext_list.h"

#include "bob_names.h"

#include "bob_dom_stream.h"

#include "bob_dom_filestream.h"

#include <string.h>

#include <stdarg.h>

class bob_dom_section;

class bob_dom_string;

class bob_dom_info;

enum bob_error_codes

{

	e_noError,

	e_badHeader,

	e_badEndHeader,

	e_notEnoughData,

	e_moreData,

	e_unkPointHeader,

	e_error,

	e_format_noStatFormat,

	e_format_notEnoughData,

	e_format_UserWarning,

	e_pointNotFound,

	e_badVersion,

	e_unsupportedFrameFlags,

	e_unkMaterialValueType

};

enum bob_error_severity

{

	s_warning,

	s_error

};

const char* bob_traslate_error(bob_error_codes code);

int peek(bob_dom_ibinaryfilestream& is);

class bob_with_errors

{

	protected:

		void error(bob_error_codes code);

		void error(bob_error_severity severity, bob_error_codes code);

		void error(bob_error_codes code, const char *format, ...);

		void error(bob_error_severity severity, bob_error_codes code, const char *format, ...);

		void verror(bob_error_severity severity, bob_error_codes code, const char *format, va_list ap);

	public:

		struct bob_error

		{

			bob_error_codes code;

			bob_error_severity severity;

			char text[255];

		};

		typedef ext::list<bob_error*> ErrorList;

		typedef ext::list<bob_error*>::iterator ErrorIterator;

		ErrorList errors;

		virtual ~bob_with_errors()

		{

			for(ErrorIterator &it=errors.begin(); it!=errors.end(); it++){

				delete *it;

			}

		}

};

class bob_dom_section : public bob_with_errors

{

	public:

		static const int null_value=-1;

		int peek(bob_dom_ibinaryfilestream& is)

		{

			int i;

			is >> i;

			is.advance(-(int)sizeof(int));

			return i;

		}

};

template <class Ty>

class bob_dom_cantainer

{

	private:

		typedef ext::list<Ty*> list_type;

	public:

		typedef Ty value_type;

		typedef Ty* value_type_ptr;

		typedef value_type child_type;

		typedef typename list_type::size_type size_type;

		typedef typename list_type::iterator iterator;

		typedef typename list_type::const_iterator const_iterator;

	protected:

		list_type children;

	public:

		const_iterator begin() const { return children.begin(); }

		iterator begin() { return children.begin(); }

		const_iterator end() const { return children.end(); }

		iterator end() { return children.end(); }

		virtual ~bob_dom_cantainer()

		{

			removeChildren();

		}

		void removeChildren()

		{

			for(iterator &it=children.begin(); it!=children.end(); ++it){

				delete *it;

			}

			children.clear();

		}

		size_type size() const { return children.size(); }

		value_type_ptr createChild() { return *(children.push_back(new value_type())); }

		value_type_ptr front() { return children.front(); }

		value_type_ptr back() { return children.back(); }

		void removeChild(iterator &where) 

		{

			delete *where;

			children.erase(where);

		}

		void removeChild(value_type_ptr child) 

		{

			iterator it, old;

			while((it=children.find(child))!=children.end()){

				old=it - 1;

				delete *it;

				children.erase(it);

				it=old;

			}

		}

};

class bob_dom_string : public bob_dom_section

{

	public:

		char *m_text;

		const char *text() const { return m_text; }

		void text(const char *str) { text(str, strlen(str));	}

		void text(const char *str, size_t size) 

		{

			delete[] m_text;

			m_text=new char[size + 1];

			memcpy(m_text, str, size);

			m_text[size]=0;

		}

		bob_dom_string() { m_text=0; }

		virtual ~bob_dom_string() { delete[] m_text; }

		bool load(unsigned char *data, size_t size, int startHeader, int endHeader);

		bool load(bob_dom_ibinaryfilestream& is, int startHeader, int endHeader);

		bool toFile(bob_dom_obinaryfilestream& os, int begin, int end);

};

class bob_dom_info : public bob_dom_string

{

	public:

		static const int hdr_begin=BOB_SECTION_NAME_INFO_BEGIN;

		static const int hdr_end=BOB_SECTION_NAME_INFO_END;

		bool load(unsigned char *data, size_t size) { return bob_dom_string::load(data, size, hdr_begin, hdr_end); }

		bool load(bob_dom_ibinaryfilestream& is) { return bob_dom_string::load(is, hdr_begin, hdr_end); }

		bool toFile(bob_dom_obinaryfilestream& os) { return bob_dom_string::toFile(os, hdr_begin, hdr_end); }

		bool toFile(bob_dom_otextfilestream& os);

};

#endif // !defined(BOB_DOM_BASE_INCLUDED)