Example #1
0
    //-----------------------------------------------------------------------------------
    void HlmsJsonCompute::loadBasedOnTextureOrUav( const rapidjson::Value &objValue,
                                                   const String &jobName, HlmsComputeJob *job,
                                                   int _threadGroupsBasedOn )
    {
        HlmsComputeJob::ThreadGroupsBasedOn threadGroupsBasedOn =
                static_cast<HlmsComputeJob::ThreadGroupsBasedOn>( _threadGroupsBasedOn );

        if( objValue.IsUint() )
        {
            job->setNumThreadGroupsBasedOn( threadGroupsBasedOn,
                                            static_cast<uint8>( objValue.GetUint() ),
                                            1u, 1u, 1u );
        }
        else if( objValue.IsObject() )
        {
            uint8 slot = 0;
            uint8 divisors[3] = { 1u, 1u, 1u };

            bool hasError = false;

            const rapidjson::Value &subobj = objValue;
            rapidjson::Value::ConstMemberIterator itor = subobj.FindMember( "slot" );

            if( itor != subobj.MemberEnd() && itor->value.IsUint() )
                slot = static_cast<uint8>( itor->value.GetUint() );
            else
                hasError = true;

            itor = subobj.FindMember( "divisor" );

            if( itor != subobj.MemberEnd() && itor->value.IsArray() )
            {
                const rapidjson::Value &divArray = itor->value;
                const rapidjson::SizeType arraySize = std::min( 3u, divArray.Size() );
                for( rapidjson::SizeType i=0; i<arraySize; ++i )
                {
                    if( divArray[i].IsUint() )
                    {
                        divisors[i] = divArray[i].GetUint();
                    }
                    else
                    {
                        hasError = true;
                        LogManager::getSingleton().logMessage(
                                    "Array with 3 integers expected in " + jobName + ". "
                                    "Syntax is thread_groups_based_on_texture : { \"slot\" "
                                    ": 0, \"divisor\" : [1, 1, 1] } or the short form: "
                                    "thread_groups_based_on_texture : 0 (with no divisors)" );
                    }
                }
            }

            if( !hasError )
            {
                job->setNumThreadGroupsBasedOn( threadGroupsBasedOn,
                                                slot, divisors[0], divisors[1], divisors[2] );
            }
        }
    }
Example #2
0
// Convert rapidjson value to JSON value.
static void ToJSONValue(JSONValue& jsonValue, const rapidjson::Value& rapidjsonValue)
{
    switch (rapidjsonValue.GetType())
    {
    case kNullType:
        // Reset to null type
        jsonValue.SetType(JSON_NULL);
        break;

    case kFalseType:
        jsonValue = false;
        break;

    case kTrueType:
        jsonValue = true;
        break;

    case kNumberType:
        if (rapidjsonValue.IsInt())
            jsonValue = rapidjsonValue.GetInt();
        else if (rapidjsonValue.IsUint())
            jsonValue = rapidjsonValue.GetUint();
        else
            jsonValue = rapidjsonValue.GetDouble();
        break;

    case kStringType:
        jsonValue = rapidjsonValue.GetString();
        break;

    case kArrayType:
        {
            jsonValue.Resize(rapidjsonValue.Size());
            for (unsigned i = 0; i < rapidjsonValue.Size(); ++i)
            {
                ToJSONValue(jsonValue[i], rapidjsonValue[i]);
            }
        }
        break;

    case kObjectType:
        {
            jsonValue.SetType(JSON_OBJECT);
            for (rapidjson::Value::ConstMemberIterator i = rapidjsonValue.MemberBegin(); i != rapidjsonValue.MemberEnd(); ++i)
            {
                JSONValue& value = jsonValue[String(i->name.GetString())];
                ToJSONValue(value, i->value);
            }
        }
        break;

    default:
        break;
    }
}
Example #3
0
bool getJsonNumber(const rapidjson::Value &v, T &dst) {
    if (v.IsDouble())
        dst = T(v.GetDouble());
    else if (v.IsInt())
        dst = T(v.GetInt());
    else if (v.IsUint())
        dst = T(v.GetUint());
    else if (v.IsInt64())
        dst = T(v.GetInt64());
    else if (v.IsUint64())
        dst = T(v.GetUint64());
    else
        return false;
    return true;
}
std::uint32_t get_value(const rapidjson::Value& root, const char* key)
{
  if (key != nullptr)
  {
    if (root.HasMember(key) && root[key].IsUint())
    {
      return root[key].GetUint();
    }
    else
      throw std::system_error(std::error_code(), "Parse error.");
  }
  else
  {
    if (root.IsUint())
    {
      return root.GetUint();
    }
    else
      throw std::system_error(std::error_code(), "Parse error.");
  }
    
}
void ConvertToMsgPack(const rapidjson::Value& json, msgpack::object& object, msgpack::zone& zone)
{
	switch (json.GetType())
	{
		case rapidjson::kFalseType:
			object = false;
			break;

		case rapidjson::kTrueType:
			object = true;
			break;

		case rapidjson::kNumberType:
		{
			if (json.IsInt())
			{
				object = json.GetInt();
			}
			else if (json.IsUint())
			{
				object = json.GetUint();
			}
			else if (json.IsInt64())
			{
				object = json.GetInt64();
			}
			else if (json.IsUint64())
			{
				object = json.GetUint64();
			}
			else if (json.IsDouble())
			{
				object = json.GetDouble();
			}

			break;
		}

		case rapidjson::kStringType:
			// we allocate with 'zone', otherwise the std::string's raw pointer gets used, which won't work as it gets destructed later on
			object = msgpack::object(std::string(json.GetString(), json.GetStringLength()), zone);
			break;

		case rapidjson::kObjectType:
		{
			std::map<std::string, msgpack::object> list;

			for (auto it = json.MemberBegin(); it != json.MemberEnd(); it++)
			{
				msgpack::object newObject;
				ConvertToMsgPack(it->value, newObject, zone);

				list.insert({ it->name.GetString(), newObject });
			}

			object = msgpack::object(list, zone);

			break;
		}

		case rapidjson::kArrayType:
		{
			std::vector<msgpack::object> list;

			for (auto it = json.Begin(); it != json.End(); it++)
			{
				msgpack::object newObject;
				ConvertToMsgPack(*it, newObject, zone);

				list.push_back(newObject);
			}

			object = msgpack::object(list, zone);

			break;
		}

		default:
			object = msgpack::type::nil();
			break;
	}
}
Example #6
0
template<> inline unsigned
conf_getter<unsigned>(const rapidjson::Value & value)
{
    return value.GetUint();
}