Beispiel #1
0
std::vector<PtNode *> ParseTree::getSingleObjAndNodes()
{
    ParseTree &pt(*this);

    std::vector<PtNode *> sobj;

    for ( int i = 0; i < nodeSet().size(); ++i ) {
        PtNode * n = getNodeSet()[i];
        if ( n->idx()[PtNode::IDX_TYPE] != static_cast<int>(Node::T_NODE) )
            continue;

        // Bottom-up: tnode -> and-node -> or-node -> single obj and-node
        PtNode * a1 = n->getInEdge(0, pt)->getFromNode(pt);
        PtNode * o  = a1->getInEdge(0, pt)->getFromNode(pt);
        PtNode * a2 = o->getInEdge(0, pt)->getFromNode(pt);

        if ( a2->idx()[PtNode::IDX_VALID] <= 0 )
            continue;

        bool found = false;
        for ( int j = 0; j < sobj.size(); ++j ) {
            if ( a2 == sobj[j] ) {
                found = true;
                break;
            }
        }
        if ( !found ) {
            sobj.push_back(a2);
        }
    }

    return sobj;
}
Beispiel #2
0
int ParseTree::addNode(int gNode, int type)
{
    int idx = nodeSet().size();

//    for ( int i = 0; i < idx; ++i ) {
//        if ( nodeSet()[i]->idx()[PtNode::IDX_G] == gNode ) {
//            RGM_LOG(error, "duplicated pt node" );
//            return -1;
//        }
//    }

    getNodeSet().push_back( new PtNode(gNode) );

    getNodeSet().back()->getIdx()[PtNode::IDX_MYSELF] = idx;
    getNodeSet().back()->getIdx()[PtNode::IDX_TYPE] = type;

    return idx;
}
Beispiel #3
0
int ParseTree::addEdge(int fromNode, int toNode, int gEdge)
{
    int idx = edgeSet().size();

    for ( int i = 0; i < idx; ++i ) {
        if ( edgeSet()[i]->idx()[PtEdge::IDX_FROM] == fromNode &&
                edgeSet()[i]->idx()[PtEdge::IDX_TO] == toNode ) {
            RGM_LOG(error, "duplicated pt edge" );
            return -1;
        }
    }

    getEdgeSet().push_back( new PtEdge(fromNode, toNode, gEdge));
    getEdgeSet().back()->getIdx()[PtEdge::IDX_MYSELF] = idx;

    getNodeSet()[fromNode]->getIdxOutEdges().push_back(idx);
    getNodeSet()[toNode]->getIdxInEdges().push_back(idx);

    return idx;
}
nsresult
txResultRecycler::getNonSharedNodeSet(txNodeSet* aNodeSet, txNodeSet** aResult)
{
    if (aNodeSet->mRefCnt > 1) {
        return getNodeSet(aNodeSet, aResult);
    }

    *aResult = aNodeSet;
    NS_ADDREF(*aResult);

    return NS_OK;
}
Beispiel #5
0
std::vector<PtNode *> ParseTree::getNode(const int idxG)
{
    std::vector<PtNode *> n;

    for ( int i = 0; i < nodeSet().size(); ++i ) {
        if ( nodeSet()[i]->idx()[PtNode::IDX_G] == idxG ) {
            n.push_back(getNodeSet()[i]);
        }
    }

    return n;
}
CostScalar 
EstLogProp::getCardOfBusiestStream(const PartitioningFunction* partFunc,
                                   Lng32 numOfParts,
                                   GroupAttributes * groupAttr,
                                   Lng32 countOfCPUs,
                                   NABoolean isUnderNestedJoin) 
{
  // if there are no histograms available, return rowCount / number of 
  // partitions as the probesPerStream

  ColStatDescList &colStatsList = this->colStats();
  if ((colStatsList.entries() == 0) || 
      (groupAttr && groupAttr->getIsProbeCacheable()))
  {
	return ( getResultCardinality() / numOfParts).minCsOne();
  }

  CostScalar cardinalityPerStream;
  if (NOT isUnderNestedJoin)
     cardinalityPerStream = colStatsList.getCardOfBusiestStream(
                                         partFunc,
                                         numOfParts,
                                         groupAttr,
                                         countOfCPUs);
  else
  {
    CANodeIdSet* outerNodeSet = getNodeSet();
    cardinalityPerStream = colStatsList.getCardOfBusiestStreamForUnderNJ(
                                    outerNodeSet,
                                    partFunc,
                                    numOfParts,
                                    groupAttr,
                                    countOfCPUs);
  }
  return cardinalityPerStream;

} // EstLogProp::getCardOfBusiestStream
Beispiel #7
0
JNIEXPORT jobjectArray JNICALL Java_com_ireeed_XPathApplier_htmlEvalXPaths(JNIEnv *env, jobject jobj, jstring page, jobjectArray xpaths){
    jboolean isCopy;
    const char *data = env->GetStringUTFChars(page,&isCopy);

    xmlDocPtr doc = parseHTML(data,strlen(data));
    //inform jvm to release the allocated data, no matter copied is true or false
    env->ReleaseStringUTFChars(page,data);

    xmlXPathObjectPtr result;
    xmlNodeSetPtr nodeset;
    std::vector<std::vector<std::string> > ret;

    jsize xpathNum = env->GetArrayLength(xpaths);


    if(doc){
	for(int index = 0; index < xpathNum; index++){

	    jstring string = (jstring)env->GetObjectArrayElement(xpaths,index);

	    const char* xpath = env->GetStringUTFChars(string, &isCopy);

	    std::vector<std::string> output;
	    if(xpath){
		result = getNodeSet(doc,xpath);
		if(result){
		    nodeset = result->nodesetval;
		    for(int i = 0; i < nodeset->nodeNr; i++){
			xmlNodePtr nodePtr = nodeset->nodeTab[i];
			std::string record;
			getTextInNode(nodePtr,record);
		
			output.push_back(record);
		    }
		    xmlXPathFreeObject(result);
		}
		//inform jvm to release the allocated data, no matter copied is true or false
		env->ReleaseStringUTFChars(string,xpath);
	    }
	    ret.push_back(output);

	}
    
	xmlFreeDoc(doc);
    }


    /*
      construct std::vector<std::vector<std::string> > back to java type(array of array)
      construct the final result in order according to the order of given xpaths
    */
    jclass stringArrayCls = env->FindClass("java/lang/Object");
    jobjectArray elemObj = env->NewObjectArray(0,env->FindClass("java/lang/String"),env->NewStringUTF(""));

    jobjectArray retVal = env->NewObjectArray(ret.size(),stringArrayCls,elemObj);
    for(int i = 0; i < ret.size(); i++){
	std::vector<std::string> &elem = ret[i];
	elemObj = env->NewObjectArray(elem.size(),env->FindClass("java/lang/String"),env->NewStringUTF(""));
	for(int j = 0; j < elem.size(); j++){
	    std::string &elemField = elem[j];
	    //create java string
	    env->SetObjectArrayElement(elemObj,j,env->NewStringUTF(elemField.c_str()));
	}
	env->SetObjectArrayElement(retVal,i,elemObj);
    }

    return retVal;  
}
Beispiel #8
0
void SSDPParser::parse(const char * buffer, int size)
{
    xmlDocPtr doc;
    xmlNodePtr root;
    xmlChar* xpathDevice = (xmlChar*) "//ns:device";
    xmlChar* xpathUDN = (xmlChar*) "///ns:UDN";
    xmlXPathObjectPtr deviceList;
    xmlXPathObjectPtr serviceList;
    xmlXPathObjectPtr udnNodeList;
    xmlChar* udn = 0;
    xmlBufferPtr configBuf = 0;
    const xmlChar* ns = 0;

    xmlKeepBlanksDefault(0); 

    doc = xmlParseMemory(buffer, size);
    if (!doc)
        return;

    root = xmlDocGetRootElement(doc);
    if (root)
        ns = root->ns->href;
    
    deviceList = getNodeSet(doc, ns, xpathDevice);
    if (deviceList) {
        int i;
        xmlNodeSetPtr nodeSet = deviceList->nodesetval;

        udnNodeList = getNodeSet(doc, ns, xpathUDN);
        if (!udnNodeList) 
            return;

        /* Loop on <device> contains in the <deviceList> element */
        for (i = 0; i < nodeSet->nodeNr; i++) {
            char xpathService[32];
            xmlNodePtr udnNode = udnNodeList->nodesetval->nodeTab[i];
            xmlNodePtr deviceNode = xmlCopyNode(nodeSet->nodeTab[i], 1);

            udn = xmlNodeListGetString(doc, udnNode->xmlChildrenNode, 1);

            sprintf(xpathService, "//ns:device[%d]//ns:service", i+1);

            configBuf = xmlBufferCreate();
            if (!configBuf)
                break;

            xmlNodeDump(configBuf, doc, deviceNode, 1, 1);

            serviceList = getNodeSet(doc, ns, (xmlChar*)xpathService);
            if (serviceList) {
                /* Loop on <service> contains in the <serviceList> element */
                parseServiceList(doc, ns, udn, serviceList->nodesetval, configBuf);
                xmlXPathFreeObject(serviceList);
            }

            if (udn)
                xmlFree(udn);

            xmlBufferFree(configBuf);
            xmlFreeNode(deviceNode);            
        }

        xmlXPathFreeObject(udnNodeList);
        xmlXPathFreeObject(deviceList);
    }

    xmlFreeDoc(doc);
    xmlCleanupParser();
}
Beispiel #9
0
  FilterSpec parseSpecFile(const char* filename)
  {
    FilterSpec spec;

    xmlDocPtr doc;
    doc = xmlParseFile(filename);

    if (doc == NULL)
    {
      throw OptfirException(std::string("Error: file ") + filename + " not found");
    }

    xmlXPathObjectPtr result = getNodeSet(doc, BAD_CAST "/amplitudespec");

    if(result != NULL)
    {
      xmlNodeSetPtr nodeset = result->nodesetval;

      xmlChar* temp;
      temp = xmlGetProp(nodeset->nodeTab[0], BAD_CAST "order");
      if (temp != NULL)
      {
        spec.order = atoi((const char*)temp);
      }

      temp = xmlGetProp(nodeset->nodeTab[0], BAD_CAST "symmetric");
      if (temp != NULL)
      {
        spec.symmetric = std::string("yes") == (const char*)temp;
      }

      temp = xmlGetProp(nodeset->nodeTab[0], BAD_CAST "max_coeff_abs_value");
      if (temp != NULL)
      {
        spec.maxCoeffAbsValue = atof((const char*)temp);
      }

      temp = xmlGetProp(nodeset->nodeTab[0], BAD_CAST "max_gain");
      if (temp != NULL)
      {
        spec.maxGain = atof((const char*)temp);
      }

      xmlXPathFreeObject(result);

      result = getNodeSet(doc, BAD_CAST "/amplitudespec/sample");
      if (result != NULL)
      {
        nodeset = result->nodesetval;
        for (int i=0; i < nodeset->nodeNr; i++)
        {
          if ((temp = xmlGetProp(nodeset->nodeTab[i], BAD_CAST "omega")) != NULL)
          {
            double& sample = spec.samples[atof((const char*)temp)];

            temp = xmlGetProp(nodeset->nodeTab[i], BAD_CAST "gain");
            if (temp != NULL)
            {
              sample = atof((const char*)temp);
            }
          }
        }
       xmlXPathFreeObject(result);
      }
    }
    else
    {
      throw OptfirException(std::string("Error: file ") + filename + " not a valid specfile");
    }

    xmlFreeDoc(doc);
    xmlCleanupParser();
    return spec;
  }
Beispiel #10
0
void *getxmlvalue( xmlDocPtr doc, char *tranid, char *name, int i, void *rvalue )
{
    xml_element ele;
    int         ret;
    void        *value;

    ret=getxmlele( tranid, name, &ele);
    if (ret)
    {
        printf("%d\n", ret);
        return NULL;
    }

    xmlXPathObjectPtr result;
    printf("tranid=[%s]name=[%s],path=[%s]\n", tranid, name, ele.path);
    result = getNodeSet( doc, ele.path );
    if (!result)
    {
        printf("%s\n", ele.path);
        return NULL;
    }

    if (i>result->nodesetval->nodeNr)
    {
        printf("nodeNr=%d need=%d\n", result->nodesetval->nodeNr, i );
        return NULL;
    }


    if (!strcmp( "content", ele.type ))
    {
        xmlNodePtr cur;
        cur = result->nodesetval->nodeTab[i];
        if(cur) value=(char *)xmlNodeGetContent(cur);
    }
    else if (!strcmp( "prop", ele.type ))
    {
        xmlNodePtr cur;
        cur = result->nodesetval->nodeTab[i];
        if(cur) value=xmlGetProp(cur,(const xmlChar *)ele.prop);
    }
    else if (!strcmp( "nodenr", ele.type ))
    {
        value=(void *)result->nodesetval->nodeNr;
        if (rvalue)
            *(int *)rvalue=(int)value;
        return value;
    }
    else
    {
        printf("type err tranid=[%s] name=[%s] type=[%s]\n", tranid, name, ele.type);
        return NULL;
    }


    if (value)
    {
        if (rvalue)
        {
            strcpy( rvalue, value );
            xmlFree(value);
            return rvalue;
        }
        else
            return value;
    }
    return NULL;
}