C++ checkIndex函数代码示例

void GBufferedImage::fillRegion(double x, double y, double width, double height, int rgb) {
    checkIndex("fillRegion", x, y);
    checkIndex("fillRegion", x + width - 1, y + height - 1);
    checkColor("fillRegion", rgb);
    for (int r = (int) y; r < y + height; r++) {
        for (int c = (int) x; c < x + width; c++) {
            m_pixels[r][c] = rgb;
        }
    }
    pp->gbufferedimage_fillRegion(this, x, y, width, height, rgb);
}

const unsigned char* SqlStatement::ResultRow::getBlobField(int nField, int& nLen) const {
	require(mpParent->mpVM);
	checkIndex(nField);

	nLen = sqlite3_column_bytes(mpParent->mpVM, nField);
	return (const unsigned char*)sqlite3_column_blob(mpParent->mpVM, nField);
}

QModelIndex TreeModel::indexFromItemHelper(const TreeItem *needle,
    TreeItem *parentItem, const QModelIndex &parentIndex) const
{
    checkIndex(parentIndex);
    if (needle == parentItem)
        return parentIndex;
    for (int i = parentItem->rowCount(); --i >= 0; ) {
        TreeItem *childItem = parentItem->child(i);
        QModelIndex childIndex = index(i, 0, parentIndex);
        QModelIndex idx = indexFromItemHelper(needle, childItem, childIndex);
        checkIndex(idx);
        if (idx.isValid())
            return idx;
    }
    return QModelIndex();
}

/*
 * Removes the element at the given index from the list,
 * shifting elements left to make room.
 * Throws a string exception if the index is out of bounds.
 */
void ArrayIntList::remove(int index) {
    checkIndex(index, 0, mysize - 1);
    for (int i = index; i < mysize - 1; i++) {
        elements[i] = elements[i + 1];
    }
    mysize--;
}

NOX::Abstract::MultiVector&
LOCA::Extended::MultiVector::setBlock(
				   const LOCA::Extended::MultiVector& source, 
				   const std::vector<int>& index)
{
  // Verify dimensions are consistent
  if (source.numMultiVecRows != numMultiVecRows || 
      source.numScalarRows != numScalarRows) 
    globalData->locaErrorCheck->throwError(
	"LOCA::Extended::MultiVector::setBlock()",
	"Size of supplied multivector is incompatible with this multivector");
  if (static_cast<unsigned int>(source.numColumns) != index.size()) {
   globalData->locaErrorCheck->throwError(
	"LOCA::Extended::MultiVector::setBlock()",
	"Size of supplied index vector is incompatible with this multivector");
  }

  // Set block in each multivec
  for (int i=0; i<numMultiVecRows; i++)
    multiVectorPtrs[i]->setBlock(*(source.multiVectorPtrs[i]),index);

  // Set scalar vectors
  for (unsigned int j=0; j<index.size(); j++) {
    checkIndex("LOCA::Extended::MultiVector::augment()", index[j]);
    for (int i=0; i<numScalarRows; i++)
      (*scalarsPtr)(i,index[j]) = (*source.scalarsPtr)(i,j);
  }

  return *this;
}

	bool Joystick::isOpen(int index)
	{
		if (!checkIndex(index))
			return false;

		return joysticks[index] != 0 ? true : false;
	}

Type Stack::getTypeAt(int index) const {
	if (!checkIndex(index)) {
		return kTypeNone;
	}

	switch (lua_type(&_luaState, index)) {
		case LUA_TNONE:
			return kTypeNone;
		case LUA_TNIL:
			return kTypeNil;
		case LUA_TBOOLEAN:
			return kTypeBoolean;
		case LUA_TNUMBER:
			return kTypeNumber;
		case LUA_TSTRING:
			return kTypeString;
		case LUA_TTABLE:
			return kTypeTable;
		case LUA_TFUNCTION:
			return kTypeFunction;
		case LUA_TUSERDATA:
			return kTypeUserType;
		default:
			warning("Unhandled Lua type: %s", lua_typename(&_luaState, index));
			return kTypeNone;
	}
}

bool LinkedList::addAll(int index, LinkedList* ll)
{
  checkIndex(index);
  
  void** new_ptr = static_cast<void**>(calloc(reserve_size + ll->reserve_size, PTR_SIZE));


  for ( int i = 0; i < index; ++i )
    {
      new_ptr[i] = ptr[i];
    }

  for ( int i = 0; i < ll->reserve_size; ++i )
    {
      new_ptr[i + index] = ll->ptr[i];
    }

  for ( int i = 0; i < reserve_size - index; ++i )
    {
      new_ptr[i + index + ll->reserve_size] = ptr[i + index];
    }

  free(ptr);

  ptr = new_ptr;

  reserve_size += ll->reserve_size;
}

 inline const AzTree *tree(int tx) const {
   checkIndex(tx, "tree"); 
   if (t[tx] == NULL) {
     return &empty_tree; 
   }
   return t[tx]; 
 }

// Return a copy of the column data specified by its index starting at 0
// (use the Column copy-constructor)
Column Statement::getColumn(const int aIndex)
{
    checkRow();
    checkIndex(aIndex);

    // Share the Statement Object handle with the new Column created
    return Column(mStmtPtr, aIndex);
}

void LinkedList<T>::pop_front(){
    checkIndex(1);
    ListNode * temp = head->next;
    temp->next->prev = head;
    head->next = temp->next;
    delete temp;
    theSize--;
}

	uint32 Matrix::getBytePos(uint16 row, uint16 col) const
	{
		//check the row and column indicies
		checkIndex(row, col);

		//byte position = (row * (bytes per column * # columns)) + (column * bytes per column)
		return (row * (m_valuesTypeSize * m_numColumns)) + (col * m_valuesTypeSize);
	}

 virtual 
 inline T *tree_u(int tx) const {
   checkIndex(tx, "tree_u"); 
   if (t[tx] == NULL) {
     throw new AzException("AzTrTreeEnsemble::tree_u", "there is no tree"); 
   }
   return t[tx]; 
 }

int OnlineSession::normalizeDataSet(int index)
{
    checkIndex(index);

    dataSets[index]->normalize();

    return 0;
}

void LinkedIntList::set(int index, int value) {
    checkLocked("set");
    checkIndex(index, 0, size() - 1);
    ListNode* current = front;
    for (int i = 0; i < index; i++) {
        current = current->next;
    }
    current->data = value;
}