Пример #1
0
void StageDlg::onIndexNew( wxCommandEvent& event ) {
  int i = findID("NEW");
  if( i == wxNOT_FOUND ) {
    iONode model = wxGetApp().getModel();
    if( model != NULL ) {
      iONode sblist = wPlan.getsblist( model );
      if( sblist == NULL ) {
        sblist = NodeOp.inst( wStageList.name(), model, ELEMENT_NODE );
        NodeOp.addChild( model, sblist );
      }
      if( sblist != NULL ) {
        iONode stage = NodeOp.inst( wStage.name(), sblist, ELEMENT_NODE );
        NodeOp.addChild( sblist, stage );
        wStage.setid( stage, "NEW" );
        wStage.setx( stage, 0 );
        wStage.sety( stage, 0 );
        wStage.setz( stage, 0 );
        m_Props = stage;
        initValues();
        initIndex();
        setSelection(wStage.getid( stage ));
      }
    }
  }
}
Пример #2
0
void Top100::calculate(MiniUser *u)
{
  if (!u) return;

  Cmd::MiniGameScore s = u->getGameScore();

  /*
  for (top_iter i=top100.begin(); i!=top100.end(); i++)
    if (i->id==u->id)
    {
      top100.erase(i);
      return;
    }
    */
  top_iter ti = std::find_if(top100.begin(),top100.end(),findID(u->id));
  if (ti!=top100.end()) top100.erase(ti);

  if (top100.size()>=120 && s<top100.rbegin()->score) return;

  //top_iter i=top100.begin();
  //for (; i!=top100.end() && i->score>s; i++);
  top_iter i = std::find_if(top100.begin(),top100.end(),findScore(s));

  Cmd::MiniUserData d;
  u->full_MiniUserData(0,d);
  top100.insert(i,d);

  if (top100.size()>120)
    top100.erase(--top100.end());

  //for (top_iter i=top100.begin(); i!=top100.end(); i++)
  //  Xlogger->debug("Top100\t%s(%u)\tscore=%d",i->name,i->id,i->score.score);
}
Пример #3
0
void buttonList::editLabel(int id, char* newLabel){
	int tempInt; 
	if(findID(id)){
		delete current->label;
		tempInt = strlen(newLabel);
		current->label = new char [tempInt+1];
		strcpy(current->label, newLabel);
	}
}
Пример #4
0
void PowerManDlg::OnAddBooster( wxCommandEvent& event )
{
    int i = findID("NEW");
    if( i == wxNOT_FOUND ) {
        iONode model = wxGetApp().getModel();
        iONode boosterlist = wPlan.getboosterlist( model );
        iONode booster = NodeOp.inst( wBooster.name(), boosterlist, ELEMENT_NODE );
        wBooster.setid(booster, "NEW");
        NodeOp.addChild( boosterlist, booster );

        m_Props = booster;
        initValues();
        initIndex();
        setSelection(wBooster.getid( booster ));
    }
}
Пример #5
0
void buttonList::removeButton( int id){
	if(findID(id)){
		if(current == start){
			start = current->next;
		}
		if(current == end){
			end = current->prev;
		}
		if(current->next != NULL){
			current->next->prev=current->prev;
		}
		if(current->prev != NULL){
			current->prev->next=current->next;
		}
	}
	delete current;
	current = start;
}
Пример #6
0
void buttonList::addButtonBelow( int w, int h, int buffx, int buffy, char* label, int buttonID, int id){
	button* temp;
	if(id==-1){
		id = size;
	}
	if(buttonID == -2){
		buttonID = size;
	}
	if(start == NULL){
		return;
	}
	else if(findID(buttonID)){
			temp = current->next;
			current->next = new button(current->x+buffx, current->y+current->h+buffy, w, h, label, buttonID, current, temp);
			size++;
	}
	else{
		return;
	}
}
Пример #7
0
void OperatorDlg::onNewOperator( wxCommandEvent& event ) {
  int i = findID("NEW");
  if( i == wxNOT_FOUND ) {
    iONode model = wxGetApp().getModel();
    if( model != NULL ) {
      iONode operatorlist = wPlan.getoperatorlist( model );
      if( operatorlist == NULL ) {
        operatorlist = NodeOp.inst( wOperatorList.name(), model, ELEMENT_NODE );
        NodeOp.addChild( model, operatorlist );
      }
      if( operatorlist != NULL ) {
        iONode op = NodeOp.inst( wOperator.name(), operatorlist, ELEMENT_NODE );
        NodeOp.addChild( operatorlist, op );
        wOperator.setid( op, "NEW" );
        m_Props = op;
        initIndex();
        initValues();
        setSelection(wOperator.getid( op ));
      }
    }
  }
}
Пример #8
0
void VariableDlg::onNew( wxCommandEvent& event )
{
  int i = findID("NEW");
  if( i == wxNOT_FOUND ) {
    iONode model = wxGetApp().getModel();
    if( model != NULL ) {
      iONode varlist = wPlan.getvrlist( model );
      if( varlist == NULL ) {
        varlist = NodeOp.inst( wVariableList.name(), model, ELEMENT_NODE );
        NodeOp.addChild( model, varlist );
      }
      if( varlist != NULL ) {
        iONode var = NodeOp.inst( wVariable.name(), varlist, ELEMENT_NODE );
        NodeOp.addChild( varlist, var );
        wVariable.setid( var, "NEW" );
        m_Props = var;
        initValues();
        initIndex();
        setSelection(wVariable.getid( var ));
      }
    }
  }
}
Пример #9
0
void TextDialog::OnNewtextClick( wxCommandEvent& event )
{
  int i = findID("NEW");
  if( i == wxNOT_FOUND ) {
    iONode model = wxGetApp().getModel();
    if( model != NULL ) {
      iONode txlist = wPlan.gettxlist( model );
      if( txlist == NULL ) {
        txlist = NodeOp.inst( wTextList.name(), model, ELEMENT_NODE );
        NodeOp.addChild( model, txlist );
      }
      if( txlist != NULL ) {
        iONode tx = NodeOp.inst( wText.name(), txlist, ELEMENT_NODE );
        NodeOp.addChild( txlist, tx );
        wText.setid( tx, "NEW" );
        appendItem(tx);
        setIDSelection(wItem.getid(tx));
        m_Props = tx;
        initValues();
      }
    }
  }
}
Пример #10
0
int MAPSJoin::findID(int id_object, int id_target, MATCH_OBJECTS * vector)
{
	int pos = findID(id_object, vector);

	if (pos == -1 || id_target == -1)
	{
		return -1;//Only for control but actually should be implossible 
	}

	for (int j = 0; j < vector->number_matched[pos]; j++)
	{
		if (j > AUTO_MAX_NUM_OBJECTS)
		{
			continue;//Only for control but actually should be implossible 
		}
		if (vector->Matrix_matched[pos][j][0] == id_target)
		{
			return j;
		}
	}

	return -1;
}
Пример #11
0
void AccDecDlg::onAdd( wxCommandEvent& event )
{
    TraceOp.trc( "accdecdlg", TRCLEVEL_INFO, __LINE__, 9999, "Add" );
    int i = findID("NEW");
    if( i == wxNOT_FOUND ) {
        iONode model = wxGetApp().getModel();
        if( model != NULL ) {
            iONode declist = wPlan.getdeclist( model );
            if( declist == NULL ) {
                declist = NodeOp.inst( wDecList.name(), model, ELEMENT_NODE );
                NodeOp.addChild( model, declist );
            }
            if( declist != NULL ) {
                iONode dec = NodeOp.inst( wDec.name(), declist, ELEMENT_NODE );
                NodeOp.addChild( declist, dec );
                wDec.setid( dec, "NEW" );
                m_Props = dec;
                appendItem(dec);
                setIDSelection(wItem.getid(dec));
                initValues();
            }
        }
    }
}
Пример #12
0
int  addcurve(char *id)
/*
**-------------------------------------------------------------
**  Input:   id = curve ID label
**  Output:  returns error code
**  Purpose: adds a new curve to the database
**--------------------------------------------------------------
*/
{
   STmplist *c;

/* Check if ID is same as last one processed */
   if (Curvelist != NULL && strcmp(id,Curvelist->ID) == 0) return(0);

/* Check that curve was not already created */
   if (findID(id,Curvelist) == NULL)
   {

   /* Update curve count & create new list element */
      (MaxCurves)++;
      c = (STmplist *) malloc(sizeof(STmplist));
      if (c == NULL) return(101);

   /* Initialize list element properties */
      else
      {
         c->i = MaxCurves;
         strncpy(c->ID,id,MAXID);
         c->x = NULL;
         c->y = NULL;
         c->next = Curvelist;
         Curvelist = c;
      }
   }
   return(0);
}
Пример #13
0
int  addpattern(char *id)
/*
**-------------------------------------------------------------
**  Input:   id = pattern ID label
**  Output:  returns error code 
**  Purpose: adds a new pattern to the database
**--------------------------------------------------------------
*/
{
   STmplist *p;

/* Check if ID is same as last one processed */
   if (Patlist != NULL && strcmp(id,Patlist->ID) == 0) return(0);

/* Check that pattern was not already created */
   if (findID(id,Patlist) == NULL)
   {

   /* Update pattern count & create new list element */
      (MaxPats)++;
      p = (STmplist *) malloc(sizeof(STmplist));
      if (p == NULL) return(101);

   /* Initialize list element properties */
      else
      {
         p->i = MaxPats;
         strncpy(p->ID,id,MAXID);
         p->x = NULL;
         p->y = NULL;
         p->next = Patlist;
         Patlist = p;
      }
   }
   return(0);
}
static AGArray * getUserInfo()
{
    AGArray * result = NULL;
    HANDLE hFile;
    HANDLE hMapping;
    char usersFile[MAX_PATH];
    char *userData;
    char *current;
    char *maxData;
    int fileSize;
    char *name, *dir;

    usersFile[0] = '\0';

    getUsersFile(usersFile, MAX_PATH);
    hFile = CreateFile(usersFile,
        GENERIC_READ,
        FILE_SHARE_READ,
        NULL,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        NULL);

    if (hFile == INVALID_HANDLE_VALUE)
        return NULL;

    fileSize = GetFileSize(hFile, NULL);
    hMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
    if (NULL != hMapping) {

        userData = (char *)MapViewOfFile(hMapping,
            FILE_MAP_READ,
            0,
            0,
            0);

        maxData = userData + fileSize;

        result = AGArrayNew(AGUnownedPointerElements, 0);
        if (NULL != result) {

            for (current = userData; current < maxData; current++) {

                if ((name = findString(current, maxData)) &&
                    (dir = findString(current + strlen(name) + 1, maxData))) {

                    AGUserInfo * user;
                    int id;
                
                    id = findID(current - 4);
                    user = (AGUserInfo *)malloc(sizeof(AGUserInfo));

                    if (NULL != user) {

                        user->name = name;
                        user->dir = dir;
                        user->id = id;
                        current += strlen(name) + strlen(dir) + 1;

                        AGArrayAppend(result, user);

                    }

                }

            }

        }

        UnmapViewOfFile(userData);

        CloseHandle(hMapping);

    }

    CloseHandle(hFile);

    return result;
}
Пример #15
0
Token * tokenMatch(char & ch, ifstream & file) {
    while ((ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t') && !file.eof()) {
        file.get(ch);
    }

    switch (ch) {
        case ':':       return new Token(COLON) ;
        case ';':       return new Token(SEMICOLON);
        case '.':       return new Token(DOT);
        case ',':       return new Token(COMMA);
        case '!':       return new Token(BANG);
        case '(':       return new Token(LPAREN);
        case ')':       return new Token(RPAREN);
        case '[':       return new Token(LBRACKET);
        case ']':       return new Token(RBRACKET);
        case '{':       return new Token(LBRACE);
        case '}':       return new Token(RBRACE);
        case '<':       return new Token(LESSTHAN);
        case '+':       return new Token(PLUS);
        case '-':       return new Token(MINUS);
        case '*':       return new Token(TIMES);

        case '/':
            file.get(ch);
            if (ch == '/') {
                while (file.peek() != '\n') {
                    file.get(ch);
                }
                file.get(ch); //One extra time to skip the newline
                return tokenMatch(ch, file);
            } else if (ch == '*') {
                while (file.get(ch)) {
                    if (ch == '*') {
                        file.get(ch);
                        if (ch == '/') {
                            file.get(ch);
                            return tokenMatch(ch, file);
                        }
                    }
                }
            }
            return new Token(DIV);

        case '=':
            file.get(ch);
            if (ch == '=')
                return new Token(EQUALS);
            file.seekg (-1, file.cur); //Move file pointer back one step so the loop won't miss a char
            return new Token(EQSIGN);

        case '&':
            file.get(ch);
            if (ch == '&')
                return new Token(AND);
            file.seekg (-1, file.cur); //Move file pointer back one step so the loop won't miss a char
            return new Token(BAD);

        case '|':
            file.get(ch);
            if (ch == '|')
                return new Token(OR);
            file.seekg (-1, file.cur); //Move file pointer back one step so the loop won't miss a char
            return new Token(BAD);

        default: return findID(ch, file);
    }
}
Пример #16
0
int handle_command(int socket)
{
	char message[MESSAGE];
	int result;
	int code;

	//receive message
	if((result = recvall(socket, message, sizeof(message))) == -1){
		printf("handle_command recvall failed\n");
		return -1;
	}

	//if result 0, close connection
	if(result == CLOSED){
		struct peer *closedSocket = findConnection(socket);
		printf("%s closed the connection\n", closedSocket->hostname);
		updateSelect(DELETE, socket, &master_set, &fdmax);
		removeFromConnections(socket);
		if(localInfo.isServer){
		//broadcast new IP list
			sendIPLIST();
		}
		return 0;
	}

	//printf("NEW MESSAGE: %s\n", message);
	
	//EXTRACTING MESSAGE 
	char* newptr = message;
	int nbytes;

	char hostName[200];
	char port[50];
	char ipaddr[INET6_ADDRSTRLEN];

	//extract header
	sscanf(newptr, "%d %n", &code, &nbytes);
	newptr += nbytes;

	//SERVER IP UPDATE
	switch(code) {

		case ADD_IP_LIST :
		{
			DESTROY_IPLIST();
			printf("\n%s UPDATED SERVER IP LIST:\n", getTime());
			while(true){
				//parse out the IP LIST
				sscanf(newptr, "%s %s %s %n", hostName, ipaddr, port, &nbytes);
				if(strcmp(hostName, "EOF") == 0) {break;}
				//printf("%s %s %s\n",hostName, ipaddr, port);
				SAVE_IPLIST(hostName, port, ipaddr);
				newptr += nbytes;
			}
			PRINT_IPLIST();
			printf("\n");
			break;
		}
		case SEND_FILE :
		{
			char filename[50];
			char file_len[50];
			char chunks_num[50];
			sscanf(newptr, "%s %s %s", filename, file_len, chunks_num);
			struct peer *sender = findConnection(socket);
			printf("DOWNLOADING FILE: %s FROM: %s\n", filename, sender->hostname);
			if ((result = receiveFile(socket, filename, file_len, chunks_num)) != 0){
				return result;
			}
			break;
		}
		case REQUEST_FILE : 
		{
			char filename[50];
			int connectionID;
			sscanf(newptr, "%s", filename);

			if((connectionID = findID(socket)) == -1){
				printf("REQUEST_FILE: connection does not exist\n");
				return EHOSTUNREACH;
			}

			char ID[20];
			sprintf(ID, "%d", connectionID);
			int argCount = 3;
			char *arguments[] = {"UPLOAD", ID, filename};

			if((result = cmd_upload(argCount, arguments)) != 0){
				printf("ERROR: Could not upload file.\n");
				char message[MESSAGE];
				sprintf(message, "%d %s\n",NOTIFICATION, "REQUEST FAILED: COULD NOT UPLOAD FILE!");
				sendall(socket, message, sizeof(message));
				return EHOSTUNREACH;
			}
			break;
		}
		case NOTIFICATION :
		{	
			struct peer *sender = findConnection(socket);
			printf("\n**** NOTIFICATION FROM: %s ****\n", sender->hostname);
			printf(">> %s\n", newptr);
			break;
		}
		default :
			printf("Invalid Message Code, cannot understand\n");
			return -1;
	}

	return 0;	
}
Пример #17
0
void buttonList::editDisplay(int id, bool toDisplay){
	if(findID(id)){
		current->display = toDisplay;
	}
}
Пример #18
0
float MAPSJoin::getOverlapScore(AUTO_Object * Object_Laser, AUTO_Object * Object_Camera)
{
	return (float)Laser_Matched.Matrix_matched[findID(Object_Laser->id, &Laser_Matched)][findID(Object_Laser->id, Object_Camera->id, &Laser_Matched)][1];
}
Пример #19
0
void Meshing::splitDiag()
{
    for(int id=0;id<mesh_.size();id++){
        QPolygonF poly = mesh_.at(id);
        if(poly.isEmpty())
            continue;

        if(!poly.isClosed())
            poly << poly.at(0);

        if(poly.size()<=4)
            continue;

        QStringList polyID;
        for(int k=0;k<poly.size();k++)
            polyID << findID(poly.at(k));

        /*for(int i=0;i<poly.size()-2;i++){
            QPointF p = (poly.at(i) + poly.at(i+2))/2.0;
            if(poly.containsPoint(p,Qt::WindingFill)){
                QPolygonF p1,p2;
                for(int k=i;k<i+3;k++){
                    p1 << poly.at(k);
                }
                p1 << poly.at(i);
                for(int k=i+3;k<=poly.size()-1;k++){
                    p2 << poly.at(k);
                }
                for(int k=0;k<i;k++){
                    p2 << poly.at(k);
                }
                p2 << poly.at(i);
                mesh_.push_back(p1);
                mesh_.push_back(p2);
                mesh_.removeAt(id);
                splitDiag();
                return;
            }
        }*/

        //qDebug() << "Split poly" << polyID;
        for(int i=0;i<poly.size()-1;i++){
            for(int j=i+2;j<poly.size()-(i==0?2:1);j++){
                //qDebug() << "Try to split along" << findID(poly.at(i)) << findID(poly.at(j));
                QLineF line(poly.at(i),poly.at(j));
                QPointF middle = (poly.at(i)+poly.at(j))/2.0;
                if(!poly.containsPoint(middle,Qt::WindingFill))
                    continue;
                if(!intersects(poly,line)){
                    QPolygonF p1,p2;
                    //QStringList poly1id,poly2id;

                    for(int k=i;k<=j;k++){
                        p1 << poly.at(k);
                        //poly1id << findID(poly.at(k));
                    }
                    p1 << poly.at(i);
                    //poly1id << findID(poly.at(i));
                    for(int k=j;k<poly.size()-1;k++){
                        p2 << poly.at(k);
                        //poly2id << findID(poly.at(k));
                    }
                    for(int k=0;k<=i;k++){
                        p2 << poly.at(k);
                        //poly2id << findID(poly.at(k));
                    }
                    p2 << poly.at(j);
                    //poly2id << findID(poly.at(j));
                    //qDebug() << poly.size() << QPair<int,QString>(i,findID(poly.at(i))) << QPair<int,QString>(j,findID(poly.at(j))) << p1.size() << p2.size();
                    //qDebug() << "Poly1" << poly1id;
                    //qDebug() << "Poly2" << poly2id;
                    mesh_.push_back(p1);
                    mesh_.push_back(p2);
                    mesh_.removeAt(id);
                    splitDiag();
                    return;
                }
            }
        }
        //qDebug() << "Can't split poly " << polyID;
    }
}
Пример #20
0
void Top100::remove(DWORD id)
{
  top_iter ti = std::find_if(top100.begin(),top100.end(),findID(id));
  if (ti!=top100.end()) top100.erase(ti);
}
Пример #21
0
void buttonList::editCallback(int id, buttonCallback newFunc){
	if(findID(id)){
		current->callbackFunction = newFunc;
	}
}
Пример #22
0
/**
Peforms the processing associated with these transformations.
*/
void MDGeometryXMLParser::execute() {
  Poco::XML::DOMParser pParser;
  Poco::AutoPtr<Poco::XML::Document> pDoc = pParser.parseString(m_xmlToProcess);
  Poco::XML::Element *pRootElem = pDoc->documentElement();
  // Apply root node checking if supplied.
  Poco::XML::Element *geometryXMLElement = nullptr;
  if (!m_rootNodeName.empty()) {
    Poco::XML::Element *temp = pRootElem->getChildElement(m_rootNodeName);
    geometryXMLElement = temp;
    if (geometryXMLElement == nullptr) {
      std::string message =
          "Root node was not found to be the expected value of " +
          m_rootNodeName;
      throw std::runtime_error(message);
    }
  } else {
    // The default is to take the root node to be the geometry xml element.
    geometryXMLElement = pRootElem;
  }

  Poco::AutoPtr<Poco::XML::NodeList> dimensionsXML =
      geometryXMLElement->getElementsByTagName(
          MDGeometryXMLDefinitions::workspaceDimensionElementName());
  size_t nDimensions = dimensionsXML->length();
  VecIMDDimension_sptr vecAllDims(nDimensions);

  ////Extract dimensions
  for (size_t i = 0; i < nDimensions; i++) {
    Poco::XML::Element *dimensionXML = static_cast<Poco::XML::Element *>(
        dimensionsXML->item(static_cast<unsigned long>(i)));
    vecAllDims[i] = createDimension(*dimensionXML);
  }
  VecIMDDimension_sptr vecNonMappedDims = vecAllDims;
  Poco::XML::Element *xDimensionElement = geometryXMLElement->getChildElement(
      MDGeometryXMLDefinitions::workspaceXDimensionElementName());
  std::string xDimId =
      xDimensionElement
          ->getChildElement(
                MDGeometryXMLDefinitions::workspaceRefDimensionElementName())
          ->innerText();
  if (!xDimId.empty()) {
    auto xDimensionIt =
        find_if(vecAllDims.begin(), vecAllDims.end(), findID(xDimId));
    if (xDimensionIt == vecAllDims.end()) {
      throw std::invalid_argument("Cannot determine x-dimension mapping.");
    }
    m_xDimension = *xDimensionIt;
    vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(),
                                          vecNonMappedDims.end(),
                                          findID(xDimId)),
                           vecNonMappedDims.end());
  }

  Poco::XML::Element *yDimensionElement = geometryXMLElement->getChildElement(
      MDGeometryXMLDefinitions::workspaceYDimensionElementName());
  std::string yDimId =
      yDimensionElement
          ->getChildElement(
                MDGeometryXMLDefinitions::workspaceRefDimensionElementName())
          ->innerText();

  if (!yDimId.empty()) {
    auto yDimensionIt =
        find_if(vecAllDims.begin(), vecAllDims.end(), findID(yDimId));
    if (yDimensionIt == vecAllDims.end()) {
      throw std::invalid_argument("Cannot determine y-dimension mapping.");
    }
    m_yDimension = *yDimensionIt;
    vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(),
                                          vecNonMappedDims.end(),
                                          findID(yDimId)),
                           vecNonMappedDims.end());
  }

  Poco::XML::Element *zDimensionElement = geometryXMLElement->getChildElement(
      MDGeometryXMLDefinitions::workspaceZDimensionElementName());
  std::string zDimId =
      zDimensionElement
          ->getChildElement(
                MDGeometryXMLDefinitions::workspaceRefDimensionElementName())
          ->innerText();

  if (!zDimId.empty()) {
    auto zDimensionIt =
        find_if(vecAllDims.begin(), vecAllDims.end(), findID(zDimId));
    if (zDimensionIt == vecAllDims.end()) {
      throw std::invalid_argument("Cannot determine z-dimension mapping.");
    }
    m_zDimension = *zDimensionIt;
    vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(),
                                          vecNonMappedDims.end(),
                                          findID(zDimId)),
                           vecNonMappedDims.end());
  }

  Poco::XML::Element *tDimensionElement = geometryXMLElement->getChildElement(
      MDGeometryXMLDefinitions::workspaceTDimensionElementName());
  std::string tDimId =
      tDimensionElement
          ->getChildElement(
                MDGeometryXMLDefinitions::workspaceRefDimensionElementName())
          ->innerText();
  if (!tDimId.empty()) {
    auto tDimensionIt =
        find_if(vecAllDims.begin(), vecAllDims.end(), findID(tDimId));
    if (tDimensionIt == vecAllDims.end()) {
      throw std::invalid_argument("Cannot determine t-dimension mapping.");
    }
    m_tDimension = *tDimensionIt;
    if (!vecNonMappedDims.empty()) {
      vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(),
                                            vecNonMappedDims.end(),
                                            findID(tDimId)),
                             vecNonMappedDims.end());
    }
  }
  m_vecNonMappedDims = vecNonMappedDims; // Copy with strong guarantee.
  m_vecAllDims = vecAllDims;
  m_executed = true;
}