C++ any::desc方法代码示例

//CAST
any bitset_descriptor::cast (const any& value) const
{
    if (value.desc() != this)
    {
        any destination;
        std::string svalue;
        return this->stoa(value.desc()->atos(value), destination);
    }

    return any(value);
}

// RAW VALUE SERIALIZATION
void bitset_descriptor::set(void* ptr, const any& value)  const
{
    boost::dynamic_bitset<>* destination = (boost::dynamic_bitset<>*) ptr;
    if (value.desc() != this)
    {
        any a = destination;
        std::string svalue = std::move(value.desc()->atos(value));
        this->stoa(svalue, a);
        *destination = *anycast<boost::dynamic_bitset<>*>(a);
    }
    else
    {
        *destination = *anycast<boost::dynamic_bitset<>*>(value);
    }
}

// TO/FROM STRING SERIALIZATION 
std::string any_descriptor::atos(const any& value) const
{
	const descriptor* cd = value.desc();
	if (!cd)
	{
		throw LAURENA_NULL_POINTER_EXCEPTION("unknow class descriptor");
	}
	return cd->atos(value);

}

    static void impl(CONTAINER* c, const descriptor* element_descriptor, any& element)
    {
        if ( element.desc()->has(descriptor::Flags::ATOMIC))
	    {
		    element = element_descriptor->cast(element);
		    c->push_back(anycast<ELEMENT>(element));
	    }
	    else
	    {
		    ELEMENT* e = anycast<ELEMENT*>(element);
		    c->push_back(*e);
	    }
    }

void oarchive_json::serializeObject(const any& value)
{
const descriptor* cd = value.desc();

    if ( !cd)
    {
        throw new LAURENA_NULL_POINTER_EXCEPTION("any& value do have nullptr descriptor.");
    }

    word32 backup = this->_nb_fields;
    this->_nb_fields = 0;

	std::string opening = "{";
	std::string ending = "}" ;

	if (cd->hasFeature(Feature::CONTAINER))
	{
		opening = "[" ;
		ending = "]" ;
	}

    // opening
	if (this->_compact) 
		this->_data << opening ;
	else
	{
		this->_data << this->_tab << opening << std::endl;
		this->_tab.increase();
	}


    if (cd->has(descriptor::Flags::FIELDS))
        this->serializeFields(*cd,value);   

    if (cd->hasFeature(Feature::CONTAINER))
        this->serializeElements(*cd,value);

	if (this->_compact)
		this->_data << ending ;
	else 
	{
		this->_data << std::endl << this->_tab.decrease() << ending ;
	}

    this->_nb_fields = backup;
}

void iarchive_xml::readObject(const std::string& tag, any& object)
{
token t;
std::string keyword;
const descriptor* d = object.desc();

    // READ ATTRIBUTES
    this->readAttributes(object);

    // End of section
    t = std::move(this->read_token(XML::TOKEN_INFERIOR_SLASH, XML::TOKEN_SUPERIOR));


    while(true)
    {
        std::string content = this->_tokenizer.readUntil("<",true);
        if (*this->_tokenizer._ptr == '/')
        {
            // Check that incoming keyword is same than the last one
            this->read_token(XML::TOKEN_SLASH);
            t = std::move(this->read_token( XML::TOKEN_KEYWORD));

            std::string keyword = anycast<std::string>(t);
            if (keyword == tag)
            {
                this->read_token(XML::TOKEN_SUPERIOR);
                //object.desc()->stoa(content, object);
                return;
            }
            else
                this->error_tag_not_expected(tag, keyword);
        }
        else
        {
            // check content is tabs
            if (!const_charsets<>::TABS.validate(content))
            {
                throw LAURENA_FAILED_PARSING_EXCEPTION("Syntax error",this->_tokenizer._ptr);
            }

            // read keyword
            t=std::move(this->read_token(XML::TOKEN_KEYWORD));
            std::string keyword = anycast<std::string>(t);

            // Identification of keyword
	        if (d->has(descriptor::Flags::FIELDS))
	        {
		        const field* f = d->findField(keyword); 
                if (f)
                {
                    this->readField(*f, keyword, object);
                    continue;
                }
            }
            
            std::ostringstream ss;
            ss << keyword << " : unknow child for class " << d->name();
            throw LAURENA_FAILED_PARSING_EXCEPTION(ss.str().c_str(),this->_tokenizer._ptr);
            
        }

    }
}