C++ checkValid函数代码示例

static bool randomBlock_r(Board& board, int r, int c, int endR, int endC, int used_mask) {
    if (r == endR) {
        return true;
    }
    int nr = r;
    int nc = c + 1;
    if (nc == endC) {
        nr++;
        nc -= 3;
    }
    int tried_mask = 0;
    while (tried_mask != 0x1ff) {
        int i = rand() % 9;
        tried_mask |= 1 << i;
        if ((used_mask & (1 << i)) == 0) {
            used_mask |= 1 << i;
            board.digits[r][c] = i + 1;
            if (checkValid(board, r, c) && randomBlock_r(board, nr, nc, endR, endC, used_mask)) {
                return true;
            }
            used_mask &= ~(1 << i);
            board.digits[r][c] = 0;
        }
    }
    return false;
}

BP::list GestureGenerator_GetAvailableGestures(xn::GestureGenerator& self) {
    checkValid(self);

    XnUInt16 gestures = self.GetNumberOfAvailableGestures();
    BP::list ret;

    if (gestures > 0) {
        const XnUInt16 gestureNameBufferLength = 100; // pray that this is enough space per gesture name

        XnChar** buf = new XnChar*[gestures];
        for (XnUInt16 i = 0; i < gestures; i++)
            buf[i] = new XnChar[gestureNameBufferLength];

        check( self.EnumerateGestures(*buf, gestures) );

        for (XnUInt16 i = 0; i < gestures; i++)
            if (buf[i])
                ret.append(std::string(buf[i]));

        for (XnUInt16 i = 0; i < gestures; i++)
            delete buf[i];
        delete buf;
    }
    return ret;
}

static bool canFindSolution_r(Board& board, int curR, int curC) {
    while (curR < BOARD_ROWS) {
        int nextR = curR;
        int nextC = curC + 1;
        if (nextC == BOARD_COLS) {
            nextR++;
            nextC = 0;
        }
        if (board.digits[curR][curC] == 0) {
            for (int guess = 1; guess <= 9; ++guess) {
                //LOGI("guess board.digits[%d][%d] = %d", curR, curC, guess);
                board.digits[curR][curC] = guess;
                if (checkValid(board, curR, curC)) {
                    //LOGI("t1");
                    if (canFindSolution_r(board, nextR, nextC)) {
                        //LOGI("t2");
                        return true;
                    }
                }
                //LOGI("t3");
            }
            board.digits[curR][curC] = 0;
            return false;
        } else {
            curR = nextR;
            curC = nextC;
        }
    }
    return true;
}

SRCR_BEGIN_NS

////////////////////////////////////////////////////////////////////////////
// 定数

////////////////////////////////////////////////////////////////////////////
// クラス

//==========================================================================
// EleneVeil メソッド

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// 外部サービス

/*---------------------------------------------------------------------*//**
	結界強化
**//*---------------------------------------------------------------------*/
void EleneVeil::strengthen(const Elene* eeAdd)
{
	_eleneCur.add(eeAdd);

	// 継続時間から１秒当たり減衰量を算出する
	s32 duration = (_eleneCur.getSoil() + (_eleneCur.getWater() / 2)) * 4;
	s32 sum = _eleneCur.sumExceptAethel();
	f32 decayFrame = (f32)(sum / 4) / (f32)duration;
	_cntDecay = (s32)(decayFrame * 30.0f);		// 秒換算
	TRACE("{EleneVeil::strengthe} Veil Param: durf=%d, decayf=%f, dc=%d, sum=%d\n", duration, decayFrame, _cntDecay, sum);
	if(_cntDecay <= 0)	{	_cntDecay = 1;	}

	// 有効判定
	checkValid();
}

/*---------------------------------------------------------------------*//**
	結界弱体
**//*---------------------------------------------------------------------*/
void EleneVeil::weaken(const Elene* eeSub)
{
	_eleneCur.sub(eeSub);

	// 有効判定
	checkValid();
}

RegExpInputDialog::RegExpInputDialog(QWidget *parent, Qt::WindowFlags flags) :
    QDialog(parent)
{
    if(flags!=0)
	{
		setWindowFlags(flags);
	}
     
    QVBoxLayout *l=new QVBoxLayout(this);
     
    label=new QLabel(this);
     
    regExp=QRegExp("*");
    regExp.setPatternSyntax(QRegExp::Wildcard);
    validator=new QRegExpValidator(regExp);
     
    text=new QLineEdit(this);
    text->setValidator(validator);
    connect(text, SIGNAL(textChanged(QString)), this, SLOT(checkValid(QString)));
     
    buttonBox=new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel, Qt::Horizontal, this);
    connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
    connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
     
    l->addWidget(label);
    l->addWidget(text);
    l->addWidget(buttonBox);
}

void Socket::Listen() {
  if (!checkValid("Socket::Listen")) {
    return;
  }
  if (listen(sock, SOMAXCONN)) {
    makeInvalid("listen");
  }
}

 /* {{{ MySQL_ArtResultSet::beforeFirst() -I- */
 void
 MySQL_ArtResultSet::beforeFirst()
 {
     CPP_ENTER("MySQL_ArtResultSet::beforeFirst");
     checkValid();
     row_position = 0;
     seek();
 }

const Q3NetworkOperation *Q3UrlOperator::rename( const QString &oldname, const QString &newname )
{
    if ( !checkValid() )
	return 0;

    Q3NetworkOperation *res = new Q3NetworkOperation( Q3NetworkProtocol::OpRename, oldname, newname, QString() );
    return startOperation( res );
}

/**
***************************************************************************************************
* @requiresTest                The requires keyword functionality is verified in this test.The
                               requires property tells that the property given by requires
                               attribute must be present in the containing instance object.
                               eg:err = checkValid(_T("{\"properties\":{\"foo\":{\"optional\":
                                         true,\"requires\":\"bar\"}}}"), _T("{}"),true);
* @param                      : None
* @retval                     : MojErr
***************************************************************************************************
**/
MojErr MojSchemaTest::requiresTest()
{
	MojErr err = checkValid(_T("{\"properties\":{\"foo\":{\"optional\":true,\"requires\":\"bar\"}}}"),
                    _T("{\"foo\":1,\"bar\":2}"),
                    true);
	MojTestErrCheck(err);
	err = checkValid(_T("{\"properties\":{\"foo\":{\"optional\":true,\"requires\":\"bar\"}}}"),
					 _T("{}"),
					 true);
	MojTestErrCheck(err);
	err = checkValid(_T("{\"properties\":{\"foo\":{\"optional\":true,\"requires\":\"bar\"}}}"),
					 _T("{\"foo\":1}"),
					 false);
	MojTestErrCheck(err);

	return MojErrNone;
}

void Socket::Connect(const sockaddr *addr, socklen_t addrlen) {
  if (!checkValid("Socket::Connect")) {
    return;
  }
  int err = connect(sock, addr, addrlen);
  if (err < 0) {
    makeInvalid("connect");
  }
}

void t_RenderClass::moveRight()
{
   corex++;

   if (!checkValid())
   {
      corex--;
   }
}

void ObjectTypeManager::setupObject(IGObject::Ptr obj, uint32_t type){
  if(checkValid(type)){
    ObjectType* prototype = typeStore[type];
    obj->setType(type);
    prototype->setupObject(obj);
  }else{
    //TODO throw exception?
  }
}

void t_RenderClass::moveLeft()
{
   corex--;

   if (!checkValid())
   {
      corex++;
   }
}

void Socket::Close() {
  if (!checkValid("Close")) {
    return;
  }
  int err = close(sock);
  if (err < 0) {
    makeInvalid("close");
  }
}