C++ Document::IsObject方法代码示例

 bool etcd_packer::parse_object(rapidjson::Document &doc, const char *data) {
     try {
         doc.Parse(data);
         return doc.IsObject();
     } catch (...) {
         return false;
     }
 }

bool FileSystem::ReadJSON( const char* filePath, rapidjson::Document& json )
{
	using namespace rapidjson;

	int fileSize;
	char* jsonString = ReadFile( filePath, fileSize );
	if (jsonString == NULL)	return false;

	json.Parse<0>( jsonString );
	if (!json.IsObject())	return false;

	return true;
}

int SettingRegistry::loadJSONsettingsFromDoc(rapidjson::Document& json_document, SettingsBase* settings_base, bool warn_duplicates)
{
    
    if (!json_document.IsObject())
    {
        cura::logError("JSON file is not an object.\n");
        return 3;
    }

    { // handle machine name
        std::string machine_name = "Unknown";
        if (json_document.HasMember("name"))
        {
            const rapidjson::Value& machine_name_field = json_document["name"];
            if (machine_name_field.IsString())
            {
                machine_name = machine_name_field.GetString();
            }
        }
        SettingConfig& machine_name_setting = addSetting("machine_name", "Machine Name");
        machine_name_setting.setDefault(machine_name);
        machine_name_setting.setType("string");
    }

    if (json_document.HasMember("settings"))
    {
        std::list<std::string> path;
        handleChildren(json_document["settings"], path, settings_base, warn_duplicates);
    }
    
    if (json_document.HasMember("overrides"))
    {
        const rapidjson::Value& json_object_container = json_document["overrides"];
        for (rapidjson::Value::ConstMemberIterator override_iterator = json_object_container.MemberBegin(); override_iterator != json_object_container.MemberEnd(); ++override_iterator)
        {
            std::string setting = override_iterator->name.GetString();
            SettingConfig* conf = getSettingConfig(setting);
            if (!conf) //Setting could not be found.
            {
                logWarning("Trying to override unknown setting %s.\n", setting.c_str());
                continue;
            }
            _loadSettingValues(conf, override_iterator, settings_base);
        }
    }
    
    return 0;
}

JSON_API void read_json(std::string const &fname, rapidjson::Document &d)
{
    FILE* fp = fopen(fname.c_str(), "rb"); // non-Windows use "r"
    if(!fp)
    {
        std::stringstream str; str << "ERROR [read_json]: file " << fname << " not found!";
        throw std::runtime_error(str.str());
    }

    fseek(fp, 0, SEEK_END);
    size_t length = static_cast<size_t>(ftell(fp));
    //std::cout << "file size = " << length << std::endl;
    fseek(fp, 0, SEEK_SET);
    char* readBuffer = static_cast<char*>(malloc(length + 1));
    size_t readLength = fread(readBuffer, 1, length, fp);
    readBuffer[readLength] = '\0';
    fclose(fp);

    d.Parse<rapidjson::kParseCommentsFlag>(readBuffer);

    if(d.HasParseError())
    {
        std::stringstream str;
        str << "ERROR [read_json]: json document cannot be parsed!" << std::endl;
        str << "\t Parse Error " << d.GetParseError() << " (" << GetParseError_En(d.GetParseError()) << ")" << std::endl;
        str << "\t Error offset = " << d.GetErrorOffset() << '\n';
        throw std::runtime_error(str.str());
    }    

    if(!d.IsObject())
    {
        std::stringstream str;
        str << "ERROR [read_json]: json document is not an object!";
        throw std::runtime_error(str.str());
    }
}

void MapInfo::load(const std::string& json_file)
{
  std::ifstream file(json_file);
  if (!file) {
    logger << Log::WARN << "Did not find minimap: " << json_file << Log::ENDL;
    map_json.Parse("{}");
    // disable map entirely
    this->tex = nullptr;
    this->current_map = "";
    return;
  }

  const std::string str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
  const auto& res = map_json.Parse(str.c_str());
  DM_ASSERT(map_json.IsObject(), "Could not parse map JSON file properly!");
  if (res.HasParseError()) {
    DM_ASSERT(false, "Could not parse map JSON file properly!");
  }

  if (map_json.HasMember("filename")) {
    this->set_map(map_json["filename"].GetString());
  }

  this->mask.enabled = map_json.HasMember("mask");
  if (this->mask.enabled)
  {
    auto mask_json = map_json["mask"].GetObject();
    if (mask_json.HasMember("active")) {
      this->mask.enabled = mask_json["active"].GetBool();
    }
    if (this->mask.enabled)
    {
      this->mask.radius = mask_json["radius"].GetInt();
      this->mask.border = mask_json["border"].GetInt();
      if (this->map_changed) {
        // create new mask
        this->mask.reset(tex->getWidth(), tex->getHeight());
      }
    }
  }

  // play area is used to restrict the player icon
  // the player location is transformed from the world into this area
  if (map_json.HasMember("play_area"))
  {
    auto area = map_json["play_area"].GetArray();
    this->play_area = glm::ivec4(area[0].GetInt(), area[1].GetInt(),
                                 area[2].GetInt(), area[3].GetInt());
  }
  else {
    // use whole image if play area is not specified
    this->play_area = glm::ivec4(0, 0, tex->getWidth(), tex->getHeight());
  }

  this->gridmode = map_json.HasMember("grid");
  if (this->gridmode)
  {
    auto& grid = map_json["grid"];
    this->grid_base_coord = glm::ivec2(grid["base_x"].GetInt(),
                                       grid["base_y"].GetInt());
    this->grid_dimensions = glm::ivec2(grid["size_x"].GetInt(),
                                       grid["size_y"].GetInt());
    // grid to pixel multiplier
    const int w = this->grid_pixel_multiplier().x;
    const int h = this->grid_pixel_multiplier().y;
    logger << Log::INFO << "Map screen is a grid of " << w << "x" << h << " pixels" << Log::ENDL;
  }
  else
  {
    const int w = this->tex->getWidth();
    const int h = this->tex->getHeight();
    // not a grid
    logger << Log::INFO << "Map screen is a bitmap of size " << w << "x" << h << " pixels" << Log::ENDL;
  }
  
  this->icons.clear();
  if (map_json.HasMember("icons") == false) return;
  auto& icon_json = map_json["icons"];
  const std::string icon_file = icon_json["filename"].GetString();
  this->sprite_texid = textures.add(icon_file);
  
  for (auto& m : icon_json.GetObject())
  {
    if (std::string("icon") == m.name.GetString())
    {
      const auto icon = m.value.GetObject();
      int px = icon["x"].GetInt();
      int py = icon["y"].GetInt();
      assert(icon.HasMember("sprite") && "Icons must have a sprite object");
      const auto sprite = icon["sprite"].GetObject();
      short x = sprite["x"].GetInt();
      short y = sprite["y"].GetInt();
      short w = sprite["w"].GetInt();
      short h = sprite["h"].GetInt();
      
      const Sprite spr {x, y, w, h, sprite_texid};
      this->icons.push_back(Icon{spr, glm::ivec2(px, py)});
    }
  }
  
//.........这里部分代码省略.........

int SettingRegistry::loadJSONsettingsFromDoc(rapidjson::Document& json_document, bool warn_duplicates)
{
    
    if (!json_document.IsObject())
    {
        cura::logError("JSON file is not an object.\n");
        return 3;
    }

    if (json_document.HasMember("machine_extruder_trains"))
    {
        categories.emplace_back("machine_extruder_trains", "Extruder Trains Settings Objects");
        SettingContainer* category_trains = &categories.back();
        const rapidjson::Value& trains = json_document["machine_extruder_trains"];
        if (trains.IsArray()) 
        {
            if (trains.Size() > 0 && trains[0].IsObject())
            {
                unsigned int idx = 0;
                for (auto it = trains.Begin(); it != trains.End(); ++it)
                {
                    SettingConfig* child = category_trains->addChild(std::to_string(idx), std::to_string(idx));
                    
                    for (rapidjson::Value::ConstMemberIterator setting_iterator = it->MemberBegin(); setting_iterator != it->MemberEnd(); ++setting_iterator)
                    {
                        _addSettingToContainer(child, setting_iterator, warn_duplicates, false);
                    }
                    
                    idx++;
                }
            }
        }
        else 
        {
            logError("Error: JSON machine_extruder_trains is not an array!\n");
        }
    }
    if (json_document.HasMember("machine_settings"))
    {
        categories.emplace_back("machine_settings", "Machine Settings");
        SettingContainer* category_machine_settings = &categories.back();
        
        const rapidjson::Value& json_object_container = json_document["machine_settings"];
        for (rapidjson::Value::ConstMemberIterator setting_iterator = json_object_container.MemberBegin(); setting_iterator != json_object_container.MemberEnd(); ++setting_iterator)
        {
            _addSettingToContainer(category_machine_settings, setting_iterator, warn_duplicates);
        }
    }
    
    if (json_document.HasMember("categories"))
    {
        for (rapidjson::Value::ConstMemberIterator category_iterator = json_document["categories"].MemberBegin(); category_iterator != json_document["categories"].MemberEnd(); ++category_iterator)
        {
            if (!category_iterator->value.IsObject())
            {
                continue;
            }
            if (!category_iterator->value.HasMember("label") || !category_iterator->value["label"].IsString())
            {
                continue;
            }
            if (!category_iterator->value.HasMember("settings") || !category_iterator->value["settings"].IsObject())
            {
                continue;
            }
            
            categories.emplace_back(category_iterator->name.GetString(), category_iterator->value["label"].GetString());
            SettingContainer* category = &categories.back();
            
            const rapidjson::Value& json_object_container = category_iterator->value["settings"];
            for (rapidjson::Value::ConstMemberIterator setting_iterator = json_object_container.MemberBegin(); setting_iterator != json_object_container.MemberEnd(); ++setting_iterator)
            {
                _addSettingToContainer(category, setting_iterator, warn_duplicates);
            }
        }
    }
    
    if (false && json_document.HasMember("overrides"))
    {
        const rapidjson::Value& json_object_container = json_document["overrides"];
        for (rapidjson::Value::ConstMemberIterator override_iterator = json_object_container.MemberBegin(); override_iterator != json_object_container.MemberEnd(); ++override_iterator)
        {
            SettingConfig* conf = getSettingConfig(override_iterator->name.GetString());
            _addSettingToContainer(conf, override_iterator, false);
        }
    }
    
    return 0;
}