kopiert von model, da in row _getSiblingRows überschrieben sein kann
354762
public function hasColumn($col)
    {
        if (!$this->getModel()->getOwnColumns()) return true;
        if (in_array($col, $this->getModel()->getOwnColumns())) return true;
        if (in_array($col, $this->getModel()->getExprColumns())) return true;
        foreach ($this->_getSiblingRows() as $r) {
            if ($r->hasColumn($col)) return true;
        }
        return false;
    }
264094
public Object getValue(Object row, int rowIndex, int columnIndex) {
        if (valueModel instanceof NestedValueModel) {
            NestedValueModel nestedModel = (NestedValueModel) valueModel;
            nestedModel.getSourceModel().setValue(row);
        }
        return valueModel.getValue();
    }
1011339
@SafeVarargs
  public final TypedDataSet<T> rows(T... rows)  {
    for (T rowObj : rows) {
      super.row(conv.convert(rowObj));
    }
    return this;
  }
57808
function(model) {
    const maxLen = model.get("seq").length;
    const selection = [];
    const sels = this.g.selcol.getSelForRow(model.get("id"));
    const rows = find(sels, function(el) { return el.get("type") === "row"; });
    if ((typeof rows !== "undefined" && rows !== null)) {
      // full match
      const end = maxLen - 1;
      for (let n = 0; n <= end; n++) {
        selection.push(n);
      }
    } else if (sels.length > 0) {
      for (let i = 0, sel; i < sels.length; i++) {
        sel = sels[i];
        const start = sel.get("xStart");
        const end = sel.get("xEnd");
        for (let n = start; n <= end; n++) {
          selection.push(n);
        }
      }
    }

    return selection;
  }
1361941
public IconRow queryForRow(StyleMappingRow styleMappingRow) {
		IconRow iconRow = null;

		UserCustomRow userCustomRow = queryForIdRow(styleMappingRow
				.getRelatedId());
		if (userCustomRow != null) {
			iconRow = getRow(userCustomRow);
		}

		return iconRow;
	}
1111369
public function getCurrentRow()
    {
        if (isset($this->_currentRow) && $this->_currentRow->isFilled()) {
            $this->_currentRow = null;
        }
        if (is_null($this->_currentRow)) {
            $this->_currentRow = Yii::createObject(array_merge(['class' => $this->rowClass], $this->baseRow));
            $this->_rows[] = $this->_currentRow;
        }

        return $this->_currentRow;
    }
425407
def row(row, val = nil)
      if val.nil?
        get_row(row)
      else
        set_row(row, val)
      end
    end
935330
def __get_ac_row(self, ac: model.AssetClass) -> AssetAllocationViewModel:
        
        view_model = AssetAllocationViewModel()

        view_model.depth = ac.depth
        
        # Name
        view_model.name = ac.name

        view_model.set_allocation = ac.allocation
        view_model.curr_allocation = ac.curr_alloc
        view_model.diff_allocation = ac.alloc_diff
        view_model.alloc_diff_perc = ac.alloc_diff_perc

        # value
        view_model.curr_value = ac.curr_value
        # expected value
        view_model.set_value = ac.alloc_value
        # diff
        view_model.diff_value = ac.value_diff

        return view_model
516916
protected function _getRelatedRowset(
        Garp_Model $model, Garp_Db_Table_Row $row, Garp_Util_Configuration $options
    ) {
        /**
         * An optional passed SELECT object will be passed by reference after every query.
         * This results in an error when 'clone' is not used, because correlation names will be
         * used twice (since they were set during the first iteration). Using 'clone' makes sure
         * a brand new SELECT object is used every time that hasn't been soiled by a possible
         * previous query.
         */
        $conditions = is_null($options['conditions']) ? null : clone $options['conditions'];
        $otherModel = $options['modelClass'];
        if (!$otherModel instanceof Zend_Db_Table_Abstract) {
            $otherModel = new $otherModel();
        }
        // Bound models should respect the CMS context settings of the root model
        $otherModel->setCmsContext($model->isCmsContext());
        /**
         * Do not cache related queries. The "outside" query should be the only
         * query that's cached.
         */
        $originalCacheQueriesFlag = $otherModel->getCacheQueries();
        $otherModel->setCacheQueries(false);
        $modelName = get_class($otherModel);
        $relatedRowset = null;

        // many to many
        if (!empty($options['bindingModel'])) {
            $relatedRowset = $row->findManyToManyRowset(
                $otherModel,
                $options['bindingModel'],
                $options['rule2'],
                $options['rule'],
                $conditions
            );
        } else {
            /**
             * 'mode' is used to clear ambiguity with homophilic relationships. For example,
             * a Model_Doc can have have child Docs and one parent Doc.
             * The conditionals below can never tell which method to call
             * (findParentRow or findDependentRowset) from the referenceMap.
             *
             * Therefore, we can help the decision-making by passing "mode". This can either be
             * "parent" or "dependent", which will then force a call to
             * findParentRow and findDependentRowset, respectively.
             */
            if (is_null($options['mode'])) {
                // belongs to
                try {
                    $model->getReference($modelName, $options['rule']);
                    $relatedRowset = $row->findParentRow(
                        $otherModel, $options['rule'], $conditions
                    );
                } catch(Exception $e) {
                    if (!Garp_Content_Relation_Manager::isInvalidReferenceException($e)) {
                        throw $e;
                    }
                    try {
                        // one to many - one to one
                        // The following line triggers an exception if no reference is available
                        $otherModel->getReference(get_class($model), $options['rule']);
                        $relatedRowset = $row->findDependentRowset(
                            $otherModel,
                            $options['rule'],
                            $conditions
                        );
                    } catch (Exception $e) {
                        if (!Garp_Content_Relation_Manager::isInvalidReferenceException($e)) {
                            throw $e;
                        }
                        $bindingModel = $model->getBindingModel($modelName);
                        $relatedRowset = $row->findManyToManyRowset(
                            $otherModel,
                            $bindingModel,
                            $options['rule2'],
                            $options['rule'],
                            $conditions
                        );
                    }
                }
            } else {
                switch ($options['mode']) {
                case 'parent':
                    $relatedRowset = $row->findParentRow(
                        $otherModel,
                        $options['rule'],
                        $conditions
                    );
                    break;
                case 'dependent':
                    $relatedRowset = $row->findDependentRowset(
                        $otherModel,
                        $options['rule'],
                        $conditions
                    );
                    break;
                default:
                    throw new Garp_Model_Exception(
                        'Invalid value for "mode" given. Must be either "parent" or ' .
                            '"dependent", but "' . $options['mode'] . '" was given.'
                    );
                    break;
                }
            }
        }
        // Reset the cacheQueries value. It's a static property,
        // so leaving it FALSE will affect all future fetch() calls to this
        // model. Not good.
        $otherModel->setCacheQueries($originalCacheQueriesFlag);
        return $relatedRowset;
    }
260161
protected function _getRow()
    {
        if (!isset($this->_row)) {
            $model = $this->getOwnModel();
            if (!$model) return null;
            $dbId = $this->getData()->dbId;
            $sharedDataClass = self::getFlag($this->getData()->componentClass, 'sharedDataClass');
            if ($sharedDataClass) {
                $component = $this->getData();
                while ($component) {
                    if (is_instance_of($component->componentClass, $sharedDataClass))
                        $dbId = $component->dbId;
                    $component = $component->parent;
                }
            }

            $this->_row = $model->getRow($dbId);
            if (!$this->_row) {
                $this->_row = $model->createRow();
                $this->_row->component_id = $dbId;
            }
        }
        return $this->_row;
    }
819311
public SDVariable eye(SDVariable rows, SDVariable cols, SDVariable batchDimension) {
        return eye(null, rows, cols, batchDimension);
    }
1023980
public int getRow() {
        if(_currentRow != null) {
            int row = _currentRow.intValue();

            /* if the row is out of range, simply adjust to the last row */
            if(_dataSetSize != null && (row > _dataSetSize.intValue()))
                row = _dataSetSize.intValue();

            if(row % getPageSize() != 0) {
                int adjustedPage = row - (row % getPageSize());
                return adjustedPage;
            }
            else return row;
        }
        else return DEFAULT_ROW;
    }
846273
def model_row index
      array = @list[index]
      array.each_with_index { |c,i|
        # if columns added later we could be overwriting the width
        ch = get_column(i)
        ch.width = c.to_s.length + 2
      }
      # maintains index in current pointer and gives next or prev
      @column_pointer = Circular.new array.size()-1
      self
    end
309672
public List<Row> getRowsCopy()
    {
        final List<Row> rows = new ArrayList<>(this.getRowsCount());

        for (Row cells : this)
        {
            rows.add(cells);
        }

        return rows;
    }
663977
def operate_selected_rows(self, operator):
        '''
        '''
        model, tree_paths = self.selection.get_selected_rows()
        if not tree_paths:
            return
        fs_ids = []
        for tree_path in tree_paths:
            fs_ids.append(model[tree_path][FSID_COL])
        for fs_id in fs_ids:
            row = self.get_row_by_fsid(fs_id)
            if not row:
                return
            operator(row, scan=False)
        self.check_commit(force=True)
        self.scan_tasks(ignore_shutdown=True)
1217877
@Override
  public org.apache.spark.unsafe.KVIterator<UnsafeRow, UnsafeRow> rowIterator() {
    return new org.apache.spark.unsafe.KVIterator<UnsafeRow, UnsafeRow>() {
      private final UnsafeRow key = new UnsafeRow(keySchema.length());
      private final UnsafeRow value = new UnsafeRow(valueSchema.length());

      private long offsetInPage = 0;
      private int recordsInPage = 0;

      private boolean initialized = false;

      private void init() {
        if (page != null) {
          offsetInPage = page.getBaseOffset();
          recordsInPage = numRows;
        }
        initialized = true;
      }

      @Override
      public boolean next() {
        if (!initialized) init();
        //searching for the next non empty page is records is now zero
        if (recordsInPage == 0) {
          freeCurrentPage();
          return false;
        }

        key.pointTo(base, offsetInPage, klen);
        value.pointTo(base, offsetInPage + klen, vlen);

        offsetInPage += recordLength;
        recordsInPage -= 1;
        return true;
      }

      @Override
      public UnsafeRow getKey() {
        return key;
      }

      @Override
      public UnsafeRow getValue() {
        return value;
      }

      @Override
      public void close() {
        // do nothing
      }

      private void freeCurrentPage() {
        if (page != null) {
          freePage(page);
          page = null;
        }
      }
    };
  }
575185
public void doWithRows(Consumer<Row> doable) {
        Row row = new Row(this);
        while (row.hasNext()) {
            doable.accept(row.next());
        }
    }