void StarsNode::unpackState(std::streambuf & in) {
    uint32_t size;
    in.sgetn((char *)&size, 4);
    msgpack::unpacker upk;
    upk.reserve_buffer(size);
    in.sgetn(upk.buffer(), size);
    upk.buffer_consumed(size);
    MsgpackInArchive ar(upk);
    ar & power & mem & disk & static_cast<SimOverlayBranch &>(getBranch()) & static_cast<SimOverlayLeaf &>(getLeaf());
    switch (Configuration::getInstance().getPolicy()) {
        case Configuration::IBPolicy:
            static_cast<IBPDispatcher &>(getDisp()).serializeState(ar);
            break;
        case Configuration::MMPolicy:
            static_cast<MMPDispatcher &>(getDisp()).serializeState(ar);
            break;
        case Configuration::DPolicy:
            static_cast<DPDispatcher &>(getDisp()).serializeState(ar);
            break;
        case Configuration::FSPolicy:
            static_cast<FSPDispatcher &>(getDisp()).serializeState(ar);
            break;
        default:
            break;
    }
}

	std::streambuf::int_type SolidusEscaper::operator()(std::streambuf &destination,
	                                                    std::streambuf::int_type character) {
		bool notEscaped = true;
		std::streambuf::char_type tmpChar = std::streambuf::traits_type::to_char_type(character);

		// If we encounter a quotation mark.
		if (tmpChar == Strings::Json::Escape::QUOTATION_MARK) {
			// If we're not in a string, we change that. If we're in a string,
			// we change that only if we're not after an escape back slash.
			inString = !inString || (afterBackSlash);

		} else if (inString && !afterBackSlash) {
			// If we are in a string definition and we're not after a backslash
			// escape.
			if (tmpChar == Strings::Std::SOLIDUS) {
				destination.sputn(Strings::Json::SOLIDUS.c_str(), Strings::Json::SOLIDUS.size());
				notEscaped = false;

			}

		}

		// We determine if we start a backslash escape or not.
		afterBackSlash = inString && !afterBackSlash && (tmpChar == Strings::Json::Escape::BEGIN_ESCAPE);
		return (notEscaped) ? (destination.sputc(tmpChar)) : (0);
	}

void StarsNode::packState(std::streambuf & out) {
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> pk(&buffer);
    MsgpackOutArchive ar(pk);
    ar & power & mem & disk & static_cast<SimOverlayBranch &>(getBranch()) & static_cast<SimOverlayLeaf &>(getLeaf());
    switch (Configuration::getInstance().getPolicy()) {
        case Configuration::IBPolicy:
            static_cast<IBPDispatcher &>(getDisp()).serializeState(ar);
            break;
        case Configuration::MMPolicy:
            static_cast<MMPDispatcher &>(getDisp()).serializeState(ar);
            break;
        case Configuration::DPolicy:
            static_cast<DPDispatcher &>(getDisp()).serializeState(ar);
            break;
        case Configuration::FSPolicy:
            static_cast<FSPDispatcher &>(getDisp()).serializeState(ar);
            break;
        default:
            break;
    }
    uint32_t size = buffer.size();
    out.sputn((const char *)&size, 4);
    out.sputn(buffer.data(), size);
}

    static std::string parseXMLIdentifier(std::streambuf& buffer)
    {
        std::stringstream identifier;
        {
            char c=buffer.sgetc();
            if((c<'A' || c>'Z') && (c<'a' || c>'z'))
            {
                throw XMLParseException();
            }
            buffer.snextc();
            identifier<<c;
        }
        for(;;)
        {
            char c=buffer.sgetc();
            if((c<'0' || c>'9') && (c<'A' || c>'Z') && (c<'a' || c>'z'))
            {
                break;
            }
            buffer.snextc();
            identifier<<c;
        }
        return identifier.str();

    }

 static void parseXMLSkipSpace(std::streambuf& buffer)
 {
     while(buffer.sgetc()==' ' || buffer.sgetc()=='\n' || buffer.sgetc()=='\r')
     {
         buffer.snextc();
     }
 }

/**
   read whole contents of streambuf 'buf'

   \return size of data malloced and copied into \param[out] buffer unless size
   is 0 (in which case buffer is set to NULL for convenience, so you can blindly free)

   requires put pointer is at end for determining size (e.g. just-written iostream)
*/
inline std::size_t read_streambuf_malloc(std::streambuf& buf, void*& buffer) {
  typedef std::streambuf::pos_type Pos;
  typedef std::streambuf::off_type Off;
  Pos sz = buf.pubseekoff(0, std::ios::end, std::ios_base::out);
  if (sz > 0 && seek_ok(sz) && seek_ok(buf.pubseekpos(0, std::ios_base::in)))
    return buf.sgetn((char*)(buffer = std::malloc(sz)), sz);
  else {
    buffer = 0;
    return 0;
  }
}

	std::streambuf::int_type Indenter::operator()(std::streambuf &destination,
	                                              std::streambuf::int_type character) {
		std::streambuf::char_type tmpChar = std::streambuf::traits_type::to_char_type(character);

		if (atStartOfLine && tmpChar != Whitespace::NEW_LINE) {
			destination.sputc(Whitespace::HORIZONTAL_TAB);
		}

		atStartOfLine = (tmpChar == Whitespace::NEW_LINE);
		return destination.sputc(tmpChar);
	}

    std::size_t HeaderParser::advance(std::streambuf& sb)
    {
        std::size_t ret = 0;

        while (sb.in_avail() > 0)
        {
            ++ret;
            if (parse(sb.sbumpc()))
                return ret;
        }

        return ret;
    }

    virtual std::streampos seekoff (std::streamoff off, std::ios_base::seekdir way,
                   std::ios_base::openmode which = std::ios_base::in)
    {
        std::streamoff newpos;
        if ( way == std::ios_base::beg )
        {
            newpos = off;
        }
        else if ( way == std::ios_base::cur )
        {
            newpos = _curPos + off;
        }
        else if ( way == std::ios_base::end )
        {
            newpos = _numChars + off;
        }
        else
        {
            return -1;
        }

        if ( newpos<0 || newpos>_numChars ) return -1;
        if ( ARCHIVE_POS(_streambuf->pubseekpos( STREAM_POS(_startPos+newpos), which)) < 0 ) return -1;
        _curPos = newpos;
        return _curPos;
    }

 XMLNode_SPtr parseXML(std::streambuf& buffer)
 {
     std::cout<<"Parse Start"<<std::endl;
     parseXMLSkipSpace(buffer);
     char c=buffer.sgetc();
     if(c=='<')
     {
         buffer.snextc();
         std::cout<<"Parse Node"<<std::endl;
         XMLNode_SPtr current=parseXMLNode(buffer);
         std::cout<<"Something"<<std::endl;
         return current;
     }
     std::cout<<"Nothing"<<std::endl;
     return XMLNode_SPtr();
 }

Ttamanio Bloque::serializar(std::streambuf&salida)const{
	unsigned char nrocomponetes=componentes.size();
	Ttamanio offset=sizeof(unsigned char);
	salida.sputn((char*)&nrocomponetes,offset);
	for(Ttamanio i=0;i<nrocomponetes;i++){
		offset+=componentes.at(i)->serializar(salida);
	}
	return offset;
}

 int operator()(std::streambuf& sbuf, int c)
 {
     int result = eof();
     if (c != eof() && new_line)
     {
         std::ostream(&sbuf) << ++line_number << ": ";
     }
     new_line = (c == '\n');
     
     return result != eof() ? result : sbuf.sputc(c);
 }

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
bool t_single_scenario_campaign_file_header::read(
	std::streambuf &		stream,
	t_progress_handler *	progress_handler_ptr )
{
	m_map_data_start = stream.pubseekoff( 0, std::ios::cur );
	m_map_data_end = stream.pubseekoff( 0, std::ios::end );
	stream.pubseekpos( m_map_data_start );

	try
	{
		t_inflate_filter inflater( stream );
		if ( !::read( inflater, *m_map_header_ptr, progress_handler_ptr ) ) 
			return false;
	}
	catch ( t_inflate_filter::t_data_error const & )
	{
		return false;
	}
	return true;
}

//////////////////////////////////////////////////////////////////////////////
// STATIC
void
read(std::streambuf & istrm, void * dataIn, size_t dataInLen)
{
	std::streamsize cnt = dataInLen;
#ifdef BLOCXX_WIN32
// VC10 warns that sgetn is unsafe.
#pragma warning(push)
#pragma warning(disable:4996)
#endif
	if (istrm.sgetn(static_cast<char *>(dataIn), cnt) != cnt)
#ifdef BLOCXX_WIN32
#pragma warning(pop)
#endif
	{
		BLOCXX_THROW(IOException, "Failed reading data");
	}
}

	std::streambuf::int_type Escaper::operator()(std::streambuf &destination,
	                                             std::streambuf::int_type character) {
		bool notEscaped = true;
		std::streambuf::char_type tmpChar = std::streambuf::traits_type::to_char_type(character);

		// If we encounter a quotation mark.
		if (tmpChar == Structural::BEGIN_END_STRING) {
			// If we're not in a string, we change that. If we're in a string,
			// we change that only if we're not after an escape back slash.
			inString = !inString || (afterBackSlash);

		} else if (inString && !afterBackSlash) {
			// If we are in a string definition and we're not after a backslash
			// escape.
			if (tmpChar == Strings::Std::REVERSE_SOLIDUS) {
				destination.sputn(Strings::Json::REVERSE_SOLIDUS.c_str(), Strings::Json::REVERSE_SOLIDUS.size());
				notEscaped = false;

			} else if (tmpChar == Strings::Std::BACKSPACE) {
				destination.sputn(Strings::Json::BACKSPACE.c_str(), Strings::Json::BACKSPACE.size());
				notEscaped = false;

			} else if (tmpChar == Strings::Std::FORM_FEED) {
				destination.sputn(Strings::Json::FORM_FEED.c_str(), Strings::Json::FORM_FEED.size());
				notEscaped = false;

			} else if (tmpChar == Strings::Std::LINE_FEED) {
				destination.sputn(Strings::Json::LINE_FEED.c_str(), Strings::Json::LINE_FEED.size());
				notEscaped = false;

			} else if (tmpChar == Strings::Std::TAB) {
				destination.sputn(Strings::Json::TAB.c_str(), Strings::Json::TAB.size());
				notEscaped = false;

			} else if (tmpChar >= '\0' && tmpChar <= '\x1f') {
				std::string tmp(Value::escapeToUnicode(tmpChar));
				destination.sputn(tmp.c_str(), tmp.size());
				notEscaped = false;
			}

		}

		// We determine if we start a backslash escape or not.
		afterBackSlash = inString && !afterBackSlash && (tmpChar == Strings::Json::Escape::BEGIN_ESCAPE);
		return (notEscaped) ? (destination.sputc(tmpChar)) : (0);
	}

    virtual int_type underflow()
    {
        // Return current character.

        if ( gptr() == &_oneChar ) return traits_type::to_int_type(_oneChar);

        // Get another character from the archive stream, if available.

        if ( _curPos==_numChars ) return traits_type::eof();
         _curPos += 1;

        int_type next_value = _streambuf->sbumpc();

        if ( !traits_type::eq_int_type(next_value,traits_type::eof()) )
        {
            setg(&_oneChar, &_oneChar, (&_oneChar)+1);
            _oneChar = traits_type::to_char_type(next_value);
        }

        return next_value;
    }

Ttamanio Bloque::deserializar(std::streambuf&entrada){
	unsigned char nrocomponetes;
	Ttamanio offset=sizeof(unsigned char);
	entrada.sgetn((char*)&nrocomponetes,offset);
	Ttamanio i=0;
	while(i<nrocomponetes and i<componentes.size()){
		offset+=componentes.at(i)->deserializar(entrada);
		i++;
	}
	/*le sobran componentes*/
	while(i<componentes.size()){
		delete componentes.at(i);
		componentes.erase(componentes.begin()+i);
	}
	/*le faltan componentes*/
	Componente* auxiliar;
	while(i<nrocomponetes){
		auxiliar=componentes.at(0)->clonar();
		offset+=auxiliar->deserializar(entrada);
		componentes.push_back(auxiliar);
		i++;
	}
	return offset;
}

    static XMLNode_SPtr parseXMLNode(std::streambuf& buffer)
    {
        // 1. Read Symbol name
        parseXMLSkipSpace(buffer);
        std::string id=parseXMLIdentifier(buffer);
        std::cout<<"Parse Id:"<<id<<std::endl;
        std::list<XMLNode_SPtr> children;
        std::string text;

        parseXMLSkipSpace(buffer);

        for(;;)
        {
            char c=buffer.sgetc();
            char c2=buffer.snextc();
            if((c=='/') && (c2=='>'))
            {
                buffer.snextc();
                goto completeNode;
            }
            if(c=='>')
            {
                goto parseText;
            }
            // TODO: Parse attribute
        }
    parseText:
        std::cout<<"Parse Text"<<std::endl;
        {
            std::stringstream textbuffer;
            parseXMLSkipSpace(buffer);
            for(;;)
            {
                char c=buffer.sgetc();
                char c2=buffer.snextc();
                if(c!='<')
                {
                    textbuffer<<c;
                }
                else
                {
                    if(c2=='/')
                    {
                        buffer.snextc();
                        break;
                    }
                    // TODO: There may be other cases.
                    children.push_back(parseXMLNode(buffer));
                }
            }
            text=textbuffer.str();
        }
        {
            std::string::reverse_iterator trimpos=text.rbegin();
            while((trimpos!=text.rend()) && (*trimpos==' ' || *trimpos=='\n' || *trimpos=='\r'))
            {
                trimpos++;
            }
            text.erase(trimpos.base(),text.end());
        }
        std::cout<<"Parse end"<<std::endl;
        {
            std::string endidentifier=parseXMLIdentifier(buffer);
            if(endidentifier!=id)
            {
                throw XMLParseException();
            }
            parseXMLSkipSpace(buffer);
            char c=buffer.sgetc();
            if(c!='>')
            {
                throw XMLParseException();
            }
            buffer.snextc();
        }
    completeNode:
        std::cout<<"Complete"<<std::endl;
        // Complete...just build and return it.
        XMLNode_SPtr node(new XMLNode(id, children, text));
        return node;
    }

bool Responder::advance(std::streambuf& in)
{
    std::streambuf::int_type chi;
    while ((chi = in.sgetc()) != std::streambuf::traits_type::eof())
    {
        char ch = std::streambuf::traits_type::to_char_type(chi);
        switch (_state)
        {
            case state_0:
                log_debug("new rpc request");

                if (ch == '\xc0')
                    _state = state_method;
                else if (ch == '\xc3')
                    _state = state_domain;
                else
                    throw std::runtime_error("domain or method name expected");
                in.sbumpc();
                break;

            case state_domain:
                if (ch == '\0')
                {
                    log_info_if(!_domain.empty(), "rpc method domain \"" << _domain << '"');
                    _state = state_method;
                }
                else
                    _domain += ch;
                in.sbumpc();
                break;

            case state_method:
                if (ch == '\0')
                {
                    log_info("rpc method \"" << _methodName << '"');

                    _proc = _serviceRegistry.getProcedure(_domain.empty() ? _methodName : _domain + '\0' + _methodName);

                    if (_proc)
                    {
                        _args = _proc->beginCall();
                        _state = state_params;
                    }
                    else
                    {
                        _failed = true;
                        _errorMessage = "unknown method \"" + _methodName + '"';
                        _state = state_params_skip;
                    }

                    _methodName.clear();
                    _domain.clear();
                }
                else
                    _methodName += ch;
                in.sbumpc();
                break;

            case state_params:
                if (ch == '\xff')
                {
                    if (_args && *_args)
                    {
                        _failed = true;
                        _errorMessage = "argument expected";
                    }

                    in.sbumpc();
                    return true;
                }
                else
                {
                    if (_args == 0 || *_args == 0)
                    {
                        _failed = true;
                        _errorMessage = "too many arguments";
                        _state = state_params_skip;
                    }
                    else
                    {
                        _deserializer.begin(false);
                        _state = state_param;
                    }
                }
                break;

            case state_params_skip:
                if (ch == '\xff')
                {
                    in.sbumpc();
                    return true;
                }
                else
                {
                    _deserializer.skip();
                    _state = state_param_skip;
                }

                break;

//.........这里部分代码省略.........

// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
bool t_multi_scenario_campaign_file_header::read(
	std::streambuf &		stream,
	t_progress_handler *	progress_handler_ptr )
{
	int const k_current_format_version = 1;

	int format_version = get< t_uint16 >( stream );
	if ( format_version < 0 || format_version > k_current_format_version )
		return false;

	std::string new_name;
	std::string new_description;
	if (	!read_string16( stream, new_name )
		||	( format_version >= 1 && !read_string16( stream, new_description ) ) )
		return false;

	int map_count = get< t_uint16 >( stream );
	if ( map_count <= 0 )
		return false;

	std::vector< std::streambuf::off_type > map_data_sizes( map_count );
	std::vector< t_map_info > new_map_info_vector( map_count );

	int map_num;
	for ( map_num = 0; map_num < map_count; ++map_num )
		map_data_sizes[ map_num ] = get< t_uint32 >( stream );

	std::streambuf::pos_type start_pos = stream.pubseekoff( 0, std::ios::cur );
	map_num = 0;
	while( true )
	{
		std::streambuf::pos_type end_pos = start_pos + map_data_sizes[ map_num ];

		t_map_info & map_info = new_map_info_vector[ map_num ];
		map_info.data_start = start_pos;
		map_info.data_end = end_pos;
		map_info.header_ptr = new t_map_header;

		stream.pubseekpos( start_pos );
		try
		{
			t_inflate_filter inflater( stream );
			if ( !::read( inflater, *map_info.header_ptr, progress_handler_ptr ) ) 
				return false;
		}
		catch ( t_inflate_filter::t_data_error const & )
		{
			return false;
		}

		if ( ++map_num >= map_count )
			break;

		start_pos = end_pos;
	}

	m_name.swap( new_name );
	m_description.swap( new_description );
	m_map_info_vector.swap( new_map_info_vector );

	return true;
}