C++ any类代码示例

void JsonSerializer::recurseRead(Json::Value& jv, any& av)
{
	if(av.type() == typeid(int))
	{
		jv = any_cast<int>(av);
	}
	else if(av.type() == typeid(unsigned int))
	{
		jv = any_cast<unsigned int>(av);
	}
	else if(av.type() == typeid(long long int))
	{
		jv = any_cast<long long int>(av);
	}
	else if(av.type() == typeid(unsigned long long int))
	{
		jv = any_cast<unsigned long long int>(av);
	}
	else if(av.type() == typeid(float))
	{
		jv = any_cast<float>(av);
	}
	else if(av.type() == typeid(double))
	{
		jv = any_cast<double>(av);
	}
	else if(av.type() == typeid(bool))
	{
		jv = any_cast<bool>(av);
	}
	else if(av.type() == typeid(string))
	{
		string str = any_cast<string>(av);
		jv = str;
	}
	else if(av.type() == typeid(list<any>))
	{
		auto lst = any_cast<list<any>&>(av);
		int i = 0;
		for(auto it:lst)
		{
			recurseRead(jv[i], it);
			++i;
		}
	}
	else if(av.type() == typeid(list<pair<string, any> >))
	{
		list<pair<string, any> >& lst = any_cast<list<pair<string, any> >&>(av);
		Json::Value tmp;
		for(auto it:lst)
		{
			recurseRead(tmp[it.first], it.second);
		}
		jv.append(tmp);
	}
	else
	{
		cout<<"error wrong type!"<<endl;
	}
}

void field::set(any& o, const any& value) const
{
	if (this->_setter != nullptr)
	{
		any v = this->desc().cast(value);		
		this->_setter (o,v);
		return;
	}

    void* optr = o.ptr();
    word8** ptr = memory::ptr(optr,this->_offset);
    if (this->_descriptor->has(descriptor::Flags::FIELDS))
    {
        if (this->_flags.test(field::FLAGS_IS_POINTER))
        {
            word8** destination = (word8**) ptr;
			word8* source = (word8*) value.ptr();
			*destination = source;
        }
    }
    else 
    {
        if (value.type() == typeid(std::string))
        {
            std::string svalue = anycast<std::string>(value);
            this->froms(o,svalue);
        }
        else   
            this->_descriptor->set(ptr,value);       
    }
}

void test_default_ctor()
{
    const any value;

    check_true(value.empty(), "empty");
    check_null(any_cast<int>(&value), "any_cast<int>");
    check_equal(value.type(), typeid(void), "type");
}

void test_null_copying()
{
    const any null;
    any copied = null, assigned;
    assigned = null;

    check_true(null.empty(), "empty on null");
    check_true(copied.empty(), "empty on copied");
    check_true(assigned.empty(), "empty on copied");
}

//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);
}

 //! \brief Return if two any objects are the same or not. 
 bool same( const any &other ) const
   {
     if( this->empty() && other.empty() )
       return true;
     else if( this->empty() && !other.empty() )
       return false;
     else if( !this->empty() && other.empty() )
       return false;
     // !this->empty() && !other.empty()
     return content->same(*other.content);
   }

// 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);
    }
}

/* set a named property */
bool GemState::set(const GemState::key_t key, any value) {
  if(value.empty()) {
    data->data.erase(key);
    return false;
  }

  /* wrapper for DEPRECATED access to member variables */
  if(1) {
    try {
      switch(key) {
      case(_DIRTY): dirty=gem::any_cast<bool>(value); break;
      case(_PIX): image=gem::any_cast<pixBlock*>(value); break;
      case(_GL_TEX_NUMCOORDS): numTexCoords=gem::any_cast<int>(value); break;
      case(_GL_TEX_COORDS): texCoords=gem::any_cast<TexCoord*>(value); break;
      case(_GL_LIGHTING): lighting=gem::any_cast<bool>(value); break;
      case(_GL_SMOOTH): smooth=gem::any_cast<bool>(value); break;
      case(_GL_TEX_TYPE): texture=gem::any_cast<int>(value); break;
      case(_GL_TEX_UNITS): multiTexUnits=gem::any_cast<int>(value); break;
      case(_TIMING_TICK): tickTime=gem::any_cast<float>(value); break;
      case(_GL_DRAWTYPE): drawType=gem::any_cast<GLenum>(value); break;
      case(_GL_DISPLAYLIST): inDisplayList=gem::any_cast<bool>(value); break;
      default: break;
      }
    } CATCH_ANY(key);
  }
  data->data[key]=value;
  return true;
}

  //   in_value must either hold an object of value_type or a string that
  //   can be converted to value_type via iostreams.
  void do_put(const any& in_key, const any& in_value, mpl::bool_<true>)
  {
#if !(defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 95))
    using boost::put;
#endif

    key_type key = any_cast<key_type>(in_key);
    if (in_value.type() == typeid(value_type)) {
#if defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 95)
      boost::put(property_map, key, any_cast<value_type>(in_value));
#else
      put(property_map, key, any_cast<value_type>(in_value));
#endif
    } else {
      //  if in_value is an empty string, put a default constructed value_type.
      std::string v = any_cast<std::string>(in_value);
      if (v.empty()) {
#if defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 95)
        boost::put(property_map, key, value_type());
#else
        put(property_map, key, value_type());
#endif
      } else {
#if defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 95)
        boost::put(property_map, key, detail::read_value<value_type>(v));
#else
        put(property_map, key, detail::read_value<value_type>(v));
#endif
      }
    }
  }

any descriptor::cast (const any& value) const
{
    if (value.type() == this->type())
    {
        return any(value);
    }
    throw new LAURENA_UNIMPLEMENTED_EXCEPTION("recast not implemented for this class");
}

// 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);

}

void field::froms(any& object, const std::string& svalue) const
{
any value;
void* ptrObject = object.ptr();
void* ptrAttribute = this->ptr(ptrObject);

	value = svalue;
    this->_descriptor->set(ptrAttribute,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);
	    }
    }

  //   in_value must either hold an object of value_type or a string that
  //   can be converted to value_type via iostreams.
  void do_put(const any& in_key, const any& in_value, mpl::bool_<true>)
  {
    using boost::put;

    key_type key = any_cast<key_type>(in_key);
    if (in_value.type() == typeid(value_type)) {
      put(property_map_, key, any_cast<value_type>(in_value));
    } else {
      //  if in_value is an empty string, put a default constructed value_type.
      std::string v = any_cast<std::string>(in_value);
      if (v.empty()) {
        put(property_map_, key, value_type());
      } else {
        put(property_map_, key, detail::read_value<value_type>(v));
      }
    }
  }

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;
}