BnxChannel::ConstMemberIterator BnxChannel::GetMember(const std::string &strNickname) const {
ConstMemberIterator memberItr;
for (memberItr = MemberBegin(); memberItr != MemberEnd(); ++memberItr) {
const IrcUser &clUser = memberItr->GetUser();
if (!IrcStrCaseCmp(strNickname.c_str(), clUser.GetNickname().c_str(), m_eCaseMapping))
return memberItr;
}
return MemberEnd();
}
void BnxChannel::UpdateMember(const std::string &strNick, const std::string &strNewNick) {
MemberIterator memberItr = GetMember(strNick);
if (memberItr != MemberEnd())
memberItr->GetUser().SetNickname(strNewNick);
if (IsVoteBanInProgress() && !IrcStrCaseCmp(m_clVoteBanMask.GetNickname().c_str(), strNick.c_str(), m_eCaseMapping))
m_clVoteBanMask.SetNickname(strNewNick);
}
void BnxChannel::VoteNay(const std::string &strNickname) {
MemberIterator memberItr = GetMember(strNickname);
// Only allow those members who were present prior to the voteban
if (memberItr == MemberEnd() || memberItr->GetTimeStamp() > m_voteBanTime)
return;
int iOldVote = memberItr->GetVote();
memberItr->VoteNay();
m_iVoteCount += memberItr->GetVote() - iOldVote;
}
void ShaderCompiler::parseShaderList(const std::string& data, std::vector<ProgramDesc>& programList) const
{
rapidjson::Document doc;
LOGS << "Parsing program list..";
doc.Parse(data.c_str());
for (auto iter = doc.MemberBegin(); iter != doc.MemberEnd(); ++iter) {
ProgramDesc program;
program.name = iter->name.GetString();
if (iter->value.IsArray()) {
for (auto item = iter->value.Begin(); item != iter->value.End(); ++item) {
if (item->IsObject()) {
ShaderDesc shader;
uint_fast32_t flags = 0;
for (auto member = item->MemberBegin(); member != item->MemberEnd(); ++member) {
// Parse attribute, not order does not matter
auto name = std::string{ member->name.GetString() };
if (name == "type")
shader.type = member->value.GetString();
else if (name == "path")
shader.path = member->value.GetString();
else if (name == "main")
shader.main = member->value.GetString();
else if (name == "flags") {
auto type = std::string{ member->value.GetString() };
if (type == "debug")
flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
}
}
if (flags == 0)
shader.flags = D3DCOMPILE_OPTIMIZATION_LEVEL3 | D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR;
program.shaders.push_back(shader);
} else {
throw new std::runtime_error("Shaderlist expected an object to describe shader");
}
}
} else {
throw new std::runtime_error("Shaderlist expected an array after program name");
}
programList.push_back(program);
}
}
std::shared_ptr<TileData> TopoJsonSource::parse(const TileTask& _task,
const MapProjection& _projection) const {
auto& task = static_cast<const DownloadTileTask&>(_task);
std::shared_ptr<TileData> tileData = std::make_shared<TileData>();
// Parse data into a JSON document
const char* error;
size_t offset;
auto document = JsonParseBytes(task.rawTileData->data(), task.rawTileData->size(), &error, &offset);
if (error) {
LOGE("Json parsing failed on tile [%s]: %s (%u)", task.tileId().toString().c_str(), error, offset);
return tileData;
}
// Transform JSON data into a TileData using TopoJson functions
BoundingBox tileBounds(_projection.TileBounds(task.tileId()));
glm::dvec2 tileOrigin = {tileBounds.min.x, tileBounds.max.y*-1.0};
double tileInverseScale = 1.0 / tileBounds.width();
const auto projFn = [&](glm::dvec2 _lonLat){
glm::dvec2 tmp = _projection.LonLatToMeters(_lonLat);
return Point {
(tmp.x - tileOrigin.x) * tileInverseScale,
(tmp.y - tileOrigin.y) * tileInverseScale,
0
};
};
// Parse topology and transform
auto topology = TopoJson::getTopology(document, projFn);
// Parse each TopoJson object as a data layer
auto objectsIt = document.FindMember("objects");
if (objectsIt == document.MemberEnd()) { return tileData; }
auto& objects = objectsIt->value;
for (auto layer = objects.MemberBegin(); layer != objects.MemberEnd(); ++layer) {
tileData->layers.push_back(TopoJson::getLayer(layer, topology, m_id));
}
// Discard JSON object and return TileData
return tileData;
}
void BnxChannel::DeleteMember(const std::string &strNickname) {
MemberIterator memberItr = GetMember(strNickname);
if (memberItr != MemberEnd())
DeleteMember(memberItr);
}
void BnxChannel::AddMember(const IrcUser &clUser) {
if (GetMember(clUser.GetNickname()) != MemberEnd())
return;
m_vMembers.push_back(Member(clUser));
}
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;
}
