C++ JSONNode::end方法代码示例

void ResUtils::ParseJobsResponse(std::list<KP_Job>& jobs, JSONNode &n)
{
    std::string jobId;
    JSONNode::const_iterator i = n.begin();
    if (i != n.end() && i -> name() == TAG_JOBS_STR && i -> type() == JSON_NODE)
    {
        JSONNode::const_iterator ijs = (*i).begin();
        if (ijs != n.end() && ijs -> name() == TAG_ITEMS_STR && ijs -> type() == JSON_ARRAY)
        {
            JSONNode::const_iterator ij = (*ijs).begin();
            while (ij != (*ijs).end())
            {
                if(ij -> type() == JSON_ARRAY || ij -> type() == JSON_NODE)
                {
                    JSONNode::const_iterator ia = (*ij).begin();
                    if (ia != (*ij).end() && ia -> name() == TAG_ID_STR && ia -> type() != JSON_ARRAY && ia -> type() != JSON_NODE)
                    {
                        jobId = ia -> as_string();
                        //cout << "Bp: jobId: " << jobId << endl;
                        jobs.push_back(KP_Job (jobId));
                    }
                }
                ij ++;
            }
        }
    }

}

int Condition::Compile(JSONNode columns)
{
	if (operand1[0] == '\'')
	{
		operand1IsConstant = true;
		operand1 = operand1.substr(1, operand1.length() - 2);
	}
	else
	{
		operand1IsConstant = false;
		bool contains = false;
		for (auto j = columns.begin(); !contains && j != columns.end(); ++j)
			if (j->as_string() == operand1)
				contains = true;
		if (!contains)
			return Errors::ERR_NO_COLUMN;
	}
	if (operand2[0] == '\'')
	{
		operand2IsConstant = true;
		operand2 = operand2.substr(1, operand2.length() - 2);
	}
	else
	{
		operand2IsConstant = false;
		bool contains = false;
		for (auto j = columns.begin(); !contains && j != columns.end(); ++j)
			if (j->as_string() == operand2)
				contains = true;
		if (!contains)
			return Errors::ERR_NO_COLUMN;
	}
	return Errors::ERR_OK;
}

bool Programmer::loadJSON(JSONNode data) {
  auto devices = data.find("devices");
  if (devices == data.end()) {
    Logger::log(ERR, "No devices found in Programmer");
    return false;
  }

  auto it = devices->begin();
  while (it != devices->end()) {
    Device* device = new Device(it->name(), *it);

    // We're overwriting data here, so make sure to actually delete the old data.
    // if there is any
    if (m_devices.count(device->getId()) > 0)
      delete m_devices[device->getId()];

    m_devices[device->getId()] = device;
    it++;
  }

  auto c = data.find("captured");
  if (c == data.end()) {
    Logger::log(WARN, "No captured set found in Programmer");
    captured = DeviceSet(m_rig);
  }
  else {
    captured = DeviceSet(m_rig, *c);
  }

  return true;
}

bool JSONReader::parseAll(const std::string& text, IdType& nextId, std::string& filepath, std::string& checksum,
    std::vector<std::shared_ptr<MetadataStream::VideoSegment>>& segments,
    std::vector<std::shared_ptr<MetadataSchema>>& schemas,
    std::vector<std::shared_ptr<MetadataInternal>>& metadata)
{
    if(text.empty())
    {
        VMF_LOG_ERROR("Empty input JSON string");
        return false;
    }

    schemas.clear();
    metadata.clear();

    JSONNode root;
    try
    {
        root = libjson::parse(text);
    }
    catch(...)
    {
        VMF_LOG_ERROR("Can't get JSON root");
        return false;
    }

    if(root.size() != 1)
    {
        VMF_LOG_ERROR("More than one JSON root");
        return false;
    }

    JSONNode localRootNode = root[0];

    if( localRootNode.name() == TAG_VMF )
    {
        auto nextIdIter = localRootNode.find(ATTR_VMF_NEXTID);
        if(nextIdIter != localRootNode.end() )
            nextId = nextIdIter->as_int();
        auto filepathIter = localRootNode.find(ATTR_VMF_FILEPATH);
        if(filepathIter != localRootNode.end() )
            filepath = filepathIter->as_string();
        auto checksumIter = localRootNode.find(ATTR_VMF_CHECKSUM);
        if(checksumIter != localRootNode.end() )
            checksum = checksumIter->as_string();

	if(!parseVideoSegments(text, segments))
	    return false;
        if(!parseSchemas(text, schemas))
            return false;
        if(!parseMetadata(text, schemas, metadata))
            return false;
    }
    else
    {
        VMF_LOG_ERROR("Root JSON element isn't 'vmf'");
        return false;
    }

    return true;
}

void ParseJSON(const JSONNode & n, std::list<KP_Service > & services){
    
    std::string providerId, serviceId;
	bool isHasServiceId = false, isHasProviderId = false;

	JSONNode::const_iterator i = n.begin();
    while (i != n.end()){
        // recursively call ourselves to dig deeper into the tree
        if (i -> type() == JSON_ARRAY || i -> type() == JSON_NODE){
            ParseJSON(*i, services);
        }
 		
        // get the node name and value as a string
        std::string node_name = i -> name();
 		//std::cout<< "Name: "<< node_name << endl;
        // find out where to store the values
        if (node_name == TAG_SERVICE_STR){
	        isHasServiceId = true;
            serviceId = i -> as_string();
        }
        else if (node_name == TAG_PROVIDER_STR){
        	isHasProviderId = true;
            providerId = i -> as_string();
        }
        
        //increment the iterator
        ++i;
    }
    if(isHasServiceId && isHasProviderId)
	    services.push_back(KP_Service (providerId, serviceId));
}

void ParseJSON(const JSONNode & n){
    JSONNode::const_iterator i = n.begin();
    while (i != n.end()){
        // recursively call ourselves to dig deeper into the tree
        if (i -> type() == JSON_ARRAY || i -> type() == JSON_NODE){
            ParseJSON(*i);
        }

        // get the node name and value as a string
        std::string node_name = i -> name();

        // find out where to store the values
        if (node_name == "RootA"){
            rootA = i -> as_string();
        }
        else if (node_name == "ChildA"){
            childA = i -> as_string();
        }
        else if (node_name == "ChildB")
            childB = i -> as_int();

        //increment the iterator
        ++i;
    }
}

void  baiduparser:: _parserJsonS ( const JSONNode & node_tree )
{
     JSONNode::const_iterator node_iter = node_tree.begin(); 
     while ( node_iter != node_tree.end() )
     {
         
          string  node_name = node_iter->name ();
          if ( node_name == "data" )
          {
               JSONNode::const_iterator arr_first_elem = node_iter->begin();
               JSONNode::const_iterator node_first_elem = arr_first_elem->begin();
               while ( node_first_elem != arr_first_elem->end() )
               {
                    
                    if ( node_first_elem->name() == "dst" )
                    {
                         result_ = node_first_elem->as_string();
                         break;
                    }
                    ++ node_first_elem ;
                     
               }
               break;
                
                              
          }
          
          node_iter ++;
           
     }

}

 static void processModel(const JSONNode & nd, MatModel& model) {
     bool nlayset = false;
     bool rangeset = false;
     bool lengthset = false;
     bool heightset = false;
     bool atomsset = false;
     for (auto i = nd.begin(); i != nd.end(); i++) {
         if (i->name() == JsonNames::numlayers) {
             model.mNumLayers = i->as_int();
             nlayset = true;
         } else if (i->name() == JsonNames::range) {
             model.mRadius = i->as_float();
             rangeset = true;
         } else if (i->name() == JsonNames::length) {
             model.mLength = i->as_float();
             lengthset = true;
         } else if (i->name() == JsonNames::height) {
             model.mHeight = i->as_float();
             heightset = true;
         } else if (i->name() == JsonNames::atoms) {
             BNB_ASSERT(nlayset);
             readIntVector(*i, model.mNumLayers, model.mLayersAtoms);
             atomsset = true;
         } else {
             BNB_ERROR_REPORT("Illegal name on parsing model data");
         }
     }
     BNB_ASSERT(nlayset && rangeset && lengthset && heightset && atomsset);
 }

 static void readDoubleVector(const JSONNode& nd, int vecsz, double * x) {
     int k = 0;
     for (auto i = nd.begin(); i != nd.end(); i++) {
         double u = i->as_float();
         BNB_ASSERT(k < vecsz);
         x[k++] = u;
     }
     BNB_ASSERT(k == vecsz);
 }

 static void readIntVector(const JSONNode& nd, int vecsz, int * x) {
     int k = 0;
     for (auto i = nd.begin(); i != nd.end(); i++) {
         int u = i->as_int();
         BNB_ASSERT(k < vecsz);
         x[k++] = u;
     }
     BNB_ASSERT(k == vecsz);
 }

bool USB_device::processMessage(ClientConn& client, string& cmd, JSONNode& n){
	if (cmd == "controlTransfer"){
		unsigned id = jsonIntProp(n, "id", 0);
		uint8_t bmRequestType = jsonIntProp(n, "bmRequestType", 0xC0);
		uint8_t bRequest = jsonIntProp(n, "bRequest");
		uint16_t wValue = jsonIntProp(n, "wValue", 0);
		uint16_t wIndex = jsonIntProp(n, "wIndex", 0);
	
		bool isIn = bmRequestType & 0x80;
		
		JSONNode reply(JSON_NODE);
		reply.push_back(JSONNode("_action", "return"));
		reply.push_back(JSONNode("id", id));
		
		int ret = -1000;
		
		if (isIn){
			uint16_t wLength = jsonIntProp(n, "wLength", 64);
			if (wLength > 64) wLength = 64;
			if (wLength < 0) wLength = 0;
		
			uint8_t data[wLength];
			ret = controlTransfer(bmRequestType, bRequest, wValue, wIndex, data, wLength);
			
			if (ret >= 0){
				JSONNode data_arr(JSON_ARRAY);
				for (int i=0; i<ret && i<wLength; i++){
					data_arr.push_back(JSONNode("", data[i]));
				}
				data_arr.set_name("data");
				reply.push_back(data_arr);
			}
		}else{
			string datastr;
			JSONNode data = n.at("data");
			if (data.type() == JSON_ARRAY){
				for(JSONNode::iterator i=data.begin(); i!=data.end(); i++){
					datastr.push_back(i->as_int());
				}
			}else{
				datastr = data.as_string();
			}
			ret = controlTransfer(bmRequestType, bRequest, wValue, wIndex, (uint8_t *)datastr.data(), datastr.size());
		}
		
		reply.push_back(JSONNode("status", ret));
	
		client.sendJSON(reply);
	}else if(cmd == "enterBootloader"){
		std::cout << "enterBootloader: ";
		int r = controlTransfer(0x40|0x80, 0xBB, 0, 0, NULL, 100);
		std::cout << "return " <<  r << std::endl;
	}else{
		return false;
	}
	return true;
}

bool CPPModule::init(const std::string& jsonParams) {
	JSONNode n = libjson::parse(jsonParams);
	std::map<std::string, std::string> tmpParams;
	JSONNode::iterator i = n.begin();
	for(; i!=n.end(); ++i) {
		tmpParams[(*i).name()] = (*i).as_string();
	}
	return onInit(tmpParams);
}

Keyframe::Keyframe(JSONNode node) {
  auto jt = node.find("t");
  if (jt == node.end()) {
    Logger::log(ERR, "Keyframe has no assigned time. Defaulting to 0.");
    t = 0;
  }
  else {
    t = jt->as_int();
  }

  auto v = node.find("val");
  if (v == node.end()) {
    val = nullptr;
  }
  else {
    val = shared_ptr<LumiverseType>(LumiverseTypeUtils::loadFromJSON(*v));
  }

  auto ucs = node.find("useCurrentState");
  if (ucs == node.end()) {
    useCurrentState = false;
  }
  else {
    useCurrentState = ucs->as_bool();
  }

  auto tid = node.find("timelineID");
  if (tid == node.end()) {
    timelineID = "";
  }
  else {
    timelineID = tid->as_string();
  }

  auto to = node.find("timelineOffset");
  if (to == node.end()) {
    timelineOffset = 0;
  }
  else {
    timelineOffset = to->as_int();
  }
}

JSONNode JSONNodeHelper::findKey(JSONNode jsonNode, std::string key)
{
    JSONNode returnNode;
    for (JSONNode::const_iterator i = jsonNode.begin(); i != jsonNode.end(); i++){
        if (i->name() == key){
            returnNode = *i;
        }
    }
    // TODO: throw exception if the key is not found
    return returnNode;
}

int ResUtils::ParseStatusResponse(JSONNode &n, JSONNode::const_iterator& i,int &outStatus)
{
    bool result = false;
    //JSONNode::const_iterator i = n.begin();
    if (i != n.end() && i -> name() == TAG_STATUS_STR && i -> type() != JSON_NODE && i -> type() != JSON_ARRAY)
    {
        outStatus = i -> as_int();
        result = true;
    }
    return result;
}