Esempio n. 1
0
void from_json(const json& j, ToolConfig& a) {
    std::vector<std::string>& files = a.getSourceFiles();
    try {
        files = j.at("source_files").get<std::vector<std::string>>();
    } catch (...) {
        files = {};
    }

    try {
        a.setExecutable(j.at("executable"));
    } catch (...) {
        a.setExecutable("");
    }

    try {
        a.setToolID(j.at("tool_id"));
    } catch (...) {
        a.setToolID("None");
    }

    try {
        a.setVersion(j.at("version"));
    } catch (...) {
        a.setVersion(newVersion);
    }

    std::vector<ToolAction>& actions = a.getActions();
    try {
        actions = j.at("actions").get<std::vector<ToolAction>>();
    } catch (...) {
        actions = {};
    }
}
Esempio n. 2
0
void Faunus::Energy::from_json(const json &j, EwaldData &d) {
    d.alpha = j.at("alpha");
    d.rc = j.at("cutoff");
    d.kc = j.at("kcutoff");
    d.ipbc = j.value("ipbc", false);
    d.spherical_sum = j.value("spherical_sum", true);
    d.lB = pc::lB( j.at("epsr") );
    d.eps_surf = j.value("epss", 0.0);
    d.const_inf = (d.eps_surf < 1) ? 0 : 1; // if unphysical (<1) use epsr infinity for surrounding medium
}
Esempio n. 3
0
	json JsonUtil::filterExactValues(const json& aNew, const json& aCompareTo) noexcept {
		json ret = aNew;
		for (const auto& v: json::iterator_wrapper(aCompareTo)) {
			auto key = v.key();
			auto i = aNew.find(key);
			if (i != aNew.end() && aNew.at(key) == aCompareTo.at(key)) {
				ret.erase(key);
			}
		}

		return ret;
	}
Esempio n. 4
0
void PPM (const json &j)
{
	PMParams params;
	params.LoadFrom(j.at("pm_params"));

	omp_set_num_threads(params.n_threads);
	Scene scene = Scene::Load(j);
	Image image(scene.Width() * 2, scene.Height(), "tmp/ph_last", params.display);
	PM pm(scene, image, params);

	if (j.at("pm_params").at("algo").get<string>() == "ppm")
		pm.PPM();
	else
		pm.PPPM();

	image.Show();
	image.Dump(-1);
	image.Show();
}
Esempio n. 5
0
bool RPCMethod::ValidateArguments(json j) {
  if (j.size() != this->paramTypes->size()) {
    return false;
  }

  for (unsigned int c = 0; c < this->paramTypes->size(); c++) {
    if (!this->checkType(this->paramTypes->at(c), j.at(c))) {
      return false;
    }
  }
  return true;
}
Esempio n. 6
0
Srs::Srs(const json& j)
{
    if (j.is_null()) return;

    if (j.is_string())
    {
        *this = Srs(j.get<std::string>());
        return;
    }

    m_authority = j.value("authority", "");
    m_horizontal = j.value("horizontal", "");
    m_vertical = j.value("vertical", "");

    if (j.count("wkt"))
    {
        m_wkt = j.at("wkt").get<std::string>();
        m_spatialReference.set(m_wkt);
    }
}
Esempio n. 7
0
void PT (const json &j)
{
	PTParams params;
	params.LoadFrom(j.at("pt_params"));

	omp_set_num_threads(params.n_threads);
	Scene scene = Scene::Load(j);
	Image image(scene.Width() * 2, scene.Height(), "tmp/im_last", params.display);
	PathTracer pathTracer(scene, image, params);

	Ray ray;
	rand_data rd;
	rand_init(&rd);
	scene.GetCamera()->Project(&rd, 818, 1800 - 1043, ray);
	pathTracer.Trace(&rd, ray);

	pathTracer.PT();
	image.Show();
	image.Dump(-1);
	image.Show();
}
int main()
{
    // create JSON object
    json object =
    {
        {"the good", "il buono"},
        {"the bad", "il cattivo"},
        {"the ugly", "il brutto"}
    };

    // output element with key "the ugly"
    std::cout << object.at("the ugly") << '\n';


    // exception type_error.304
    try
    {
        // use at() on a non-object type
        const json str = "I am a string";
        std::cout << str.at("the good") << '\n';
    }
    catch (json::type_error& e)
    {
        std::cout << e.what() << '\n';
    }

    // exception out_of_range.401
    try
    {
        // try to read from a nonexisting key
        std::cout << object.at("the fast") << '\n';
    }
    catch (json::out_of_range)
    {
        std::cout << "out of range" << '\n';
    }
}
Esempio n. 9
0
  void IPCClientPrivate::processSignalJSON(const json& jobj)
  {
    try {
      const std::string name = jobj["_s"];
      if (name == "DeviceInserted") {
	const json attributes_json = jobj.at("attributes");
	std::map<std::string,std::string> attributes;

	for (auto it = attributes_json.begin(); it != attributes_json.end(); ++it) {
	  const std::string key = it.key();
	  const std::string value = it.value();
	  attributes[key] = value;
	}

	std::vector<USBInterfaceType> interfaces;
	for (auto const& jitem : jobj["interfaces"]) {
	  const std::string type_string = jitem;
	  interfaces.push_back(USBInterfaceType(type_string));
	}

	_p_instance.DeviceInserted(jobj["seqn"],
				   attributes,
				   interfaces,
				   jobj["rule_match"],
				   jobj["rule_seqn"]);
      }
      else if (name == "DevicePresent") {
	const json attributes_json = jobj.at("attributes");
	std::map<std::string,std::string> attributes;

	for (auto it = attributes_json.begin(); it != attributes_json.end(); ++it) {
	  const std::string key = it.key();
	  const std::string value = it.value();
	  attributes[key] = value;
	}

	std::vector<USBInterfaceType> interfaces;
	for (auto const& jitem : jobj["interfaces"]) {
	  const std::string type_string = jitem;
	  interfaces.push_back(USBInterfaceType(type_string));
	}

	_p_instance.DevicePresent(jobj["seqn"],
				  attributes,
				  interfaces,
				  Rule::targetFromString(jobj["target"]));
      }
      else if (name == "DeviceRemoved") {
	const json attributes_json = jobj.at("attributes");
	std::map<std::string,std::string> attributes;

	for (auto it = attributes_json.begin(); it != attributes_json.end(); ++it) {
	  const std::string key = it.key();
	  const std::string value = it.value();
	  attributes[key] = value;
	}

	_p_instance.DeviceRemoved(jobj["seqn"],
				  attributes);
      }
      else if (name == "DeviceAllowed") {
	const json attributes_json = jobj.at("attributes");
	std::map<std::string,std::string> attributes;

	for (auto it = attributes_json.begin(); it != attributes_json.end(); ++it) {
	  const std::string key = it.key();
	  const std::string value = it.value();
	  attributes[key] = value;
	}

	_p_instance.DeviceAllowed(jobj["seqn"],
				  attributes,
				  jobj["rule_match"],
				  jobj["rule_seqn"]);
      }
      else if (name == "DeviceBlocked") {
	const json attributes_json = jobj.at("attributes");
	std::map<std::string,std::string> attributes;

	for (auto it = attributes_json.begin(); it != attributes_json.end(); ++it) {
	  const std::string key = it.key();
	  const std::string value = it.value();
	  attributes[key] = value;
	}

	_p_instance.DeviceBlocked(jobj["seqn"],
				  attributes,
				  jobj["rule_match"],
				  jobj["rule_seqn"]);
      }
      else if (name == "DeviceRejected") {
	const json attributes_json = jobj.at("attributes");
	std::map<std::string,std::string> attributes;

	for (auto it = attributes_json.begin(); it != attributes_json.end(); ++it) {
	  const std::string key = it.key();
	  const std::string value = it.value();
	  attributes[key] = value;
	}

	_p_instance.DeviceRejected(jobj["seqn"],
				   attributes,
				   jobj["rule_match"],
				   jobj["rule_seqn"]);
      }
      else {
	throw 0;
      }
    } catch(...) {
      disconnect();
      throw IPCException(IPCException::ProtocolError, "Invalid IPC signal data");
    }
    return;
  }
Esempio n. 10
0
 void ChainRotationMovebase::_from_json(const json &j) {
     molname = j.at("molecule");
     dprot = j.at("dprot");
     allow_small_box = j.value("skiplarge", true); // todo rename the json attribute and make false default
 }
int main()
{
    // create a JSON value
    const json j =
    {
        {"number", 1}, {"string", "foo"}, {"array", {1, 2}}
    };

    // read-only access

    // output element with JSON pointer "/number"
    std::cout << j.at("/number"_json_pointer) << '\n';
    // output element with JSON pointer "/string"
    std::cout << j.at("/string"_json_pointer) << '\n';
    // output element with JSON pointer "/array"
    std::cout << j.at("/array"_json_pointer) << '\n';
    // output element with JSON pointer "/array/1"
    std::cout << j.at("/array/1"_json_pointer) << '\n';

    // out_of_range.109
    try
    {
        // try to use an array index that is not a number
        json::const_reference ref = j.at("/array/one"_json_pointer);
    }
    catch (json::parse_error& e)
    {
        std::cout << e.what() << '\n';
    }

    // out_of_range.401
    try
    {
        // try to use a an invalid array index
        json::const_reference ref = j.at("/array/4"_json_pointer);
    }
    catch (json::out_of_range& e)
    {
        std::cout << e.what() << '\n';
    }

    // out_of_range.402
    try
    {
        // try to use the array index '-'
        json::const_reference ref = j.at("/array/-"_json_pointer);
    }
    catch (json::out_of_range& e)
    {
        std::cout << e.what() << '\n';
    }

    // out_of_range.404
    try
    {
        // try to use a JSON pointer that cannot be resolved
        json::const_reference ref = j.at("/number/foo"_json_pointer);
    }
    catch (json::out_of_range& e)
    {
        std::cout << e.what() << '\n';
    }
}
Esempio n. 12
0
#include "json.hpp"
using nlohmann::json;

TEST_CASE("element access 1")
{
    SECTION("array")
    {
        json j = {1, 1u, true, nullptr, "string", 42.23, json::object(), {1, 2, 3}};
        const json j_const = j;

        SECTION("access specified element with bounds checking")
        {
            SECTION("access within bounds")
            {
                CHECK(j.at(0) == json(1));
                CHECK(j.at(1) == json(1u));
                CHECK(j.at(2) == json(true));
                CHECK(j.at(3) == json(nullptr));
                CHECK(j.at(4) == json("string"));
                CHECK(j.at(5) == json(42.23));
                CHECK(j.at(6) == json(json::object()));
                CHECK(j.at(7) == json({1, 2, 3}));

                CHECK(j_const.at(0) == json(1));
                CHECK(j_const.at(1) == json(1u));
                CHECK(j_const.at(2) == json(true));
                CHECK(j_const.at(3) == json(nullptr));
                CHECK(j_const.at(4) == json("string"));
                CHECK(j_const.at(5) == json(42.23));
                CHECK(j_const.at(6) == json(json::object()));
Esempio n. 13
0
void from_json(const json& j, ToolAction& a) {
    try {
        a.setActionType(j.at("action"));
    } catch(...) {
        a.setActionType("None");
    }

    try {
        a.setName(j.at("name"));
    } catch(...) {
        a.setName("");
    }

    try {
        char buff[MAXPATHLEN];
        std::string pwd = getcwd(buff, MAXPATHLEN);
        std::string handle = j.at("handle");
        size_t loc = handle.find("${PWD}");
        if (loc != std::string::npos) {
            handle.replace(loc, 6, pwd);
        }
        a.setHandle(handle);
    } catch(...) {
        a.setHandle("");
    }

    try {
        a.setScope(j.at("scope"));
    } catch(...) {
        a.setScope("");
    }

    try {
        a.setSourceInfo(j.at("source_info"));
    } catch(...) {
        a.setSourceInfo("");
    }

    try {
        a.setFromType(j.at("from_type"));
    } catch(...) {
        a.setFromType("");
    }

    try {
        a.setToType(j.at("to_type"));
    } catch(...) {
        a.setToType("");
    }

    try {
        a.setError(j.at("error"));
    } catch(...) {
        a.setError(-1);
    }

    try {
        a.setAssignments(j.at("dynamic_assignments"));
    } catch(...) {
        a.setAssignments(-1);
    }
}
Esempio n. 14
0
void from_json(const json& j, Post& p) {
    p.userId = j.at("userId").get<int>();
    p.id = j.at("id").get<int>();
    p.title = j.at("title").get<string>();
    p.body = boost::algorithm::replace_all_copy(j.at("body").get<string>(), "\n", "\\n");
}
Esempio n. 15
0
*/

#include "catch.hpp"

#include <nlohmann/json.hpp>
using nlohmann::json;

TEST_CASE("version information")
{
    SECTION("meta()")
    {
        json j = json::meta();

        CHECK(j["name"] == "JSON for Modern C++");
        CHECK(j["copyright"] == "(C) 2013-2017 Niels Lohmann");
        CHECK(j["url"] == "https://github.com/nlohmann/json");
        CHECK(j["version"] == json(
        {
            {"string", "3.2.0"},
            {"major", 3},
            {"minor", 2},
            {"patch", 0}
        }));

        CHECK(j.find("platform") != j.end());
        CHECK(j.at("compiler").find("family") != j.at("compiler").end());
        CHECK(j.at("compiler").find("version") != j.at("compiler").end());
        CHECK(j.at("compiler").find("c++") != j.at("compiler").end());
    }
}
Esempio n. 16
0
 ReadQuery(const Reader& reader, const json& j)
     : Query(reader, j)
     , m_schema(j.count("schema") ?
             Schema(j.at("schema")) : m_metadata.outSchema())
 { }