// Common, group Parsing
// Copyright Alexander Liss

#ifndef __STRSTRBLOCKS_H__
#define __STRSTRBLOCKS_H__

#include "strbuf.h"
#include "array.h"

// non-overlapping special character blocks in a string
// divide this string into a sequence of 
// non-special character blocks

class StrBlocks
{

StrBlocks(const StrBlocks&);			// cannot use
StrBlocks& operator=(const StrBlocks&);	// cannot use

public:

StrBlocks():next_index(-1),next_after(0),have_block(false){}
~StrBlocks(){}

int add(const char* before,const char * after)
{BlockDataUnit z(before,after); return block_data.add(z);}
int add(const StrBuffer& before,const StrBuffer& after)
{BlockDataUnit z(before,after); return block_data.add(z);}

int parse(const char * string);
int parse(const char * data,int size);
int parse(const StrBuffer& s){return parse(s.data,s.data_size);}
int translate_parse(const char * string,const char *from,char to=',');
int translate_parse(const StrBuffer& s,const char *from,char to=',')
	{return translate_parse(s.data,from,to);}
int shrink_parse(const char * Str,const char *from,char to=' ',bool drop_ends=true);
int shrink_parse(const StrBuffer& s,const char *from,char to=' ',bool drop_ends=true)
	{return shrink_parse(s.data,from,to,drop_ends);}

//int number(){return block_number;}

// dropps "before" and "after"
// base block has an index -1
int get_next(int& index, StrBuffer& dest);
int start();

private:

	struct BlockDataUnit
	{
		StrBuffer before,after;
		BlockDataUnit(){}
		BlockDataUnit(const StrBuffer& b,const StrBuffer& a):
		before(b),after(a){}
		BlockDataUnit(const char* b,const char* a):
		before(b),after(a){}
	};

	SimpleCollector<BlockDataUnit,SimpleArray<BlockDataUnit> > block_data;
	StrBuffer data, shift_buffer;
	int next_index,next_after;
	bool have_block;

int match(int& before,int& after,const BlockDataUnit&);
};


#endif