获取或创建某一行的样式，返回样式后可以设置样式内容

@param y Y坐标，从0计数，既行号
@return {@link CellStyle}
@since 4.1.4
496065
public CellStyle getOrCreateRowStyle(int y) {
		final Row row = getOrCreateRow(y);
		CellStyle rowStyle = row.getRowStyle();
		if (null == rowStyle) {
			rowStyle = this.workbook.createCellStyle();
			row.setRowStyle(rowStyle);
		}
		return rowStyle;
	}
387060
function yy_r4(){
    if ($this->compiler->has_code) {
        $tmp =''; foreach ($this->compiler->prefix_code as $code) {$tmp.=$code;} $this->compiler->prefix_code=array();
        $this->_retvalue = new _smarty_tag($this, $this->compiler->processNocacheCode($tmp.$this->yystack[$this->yyidx + -1]->minor,true));
    } else { 
        $this->_retvalue = null;
    }  
    $this->compiler->has_variable_string = false;
    $this->block_nesting_level = count($this->compiler->_tag_stack);
    }
581745
public void getEachCellContent(int YNum, int cc, TableCandidate tc) {
    	int footnoteLineIndex = tc.getFootnoteBeginRow();
    	String[] contentsInRows = new String[footnoteLineIndex];
    	float[] leftX_tableColumns = tc.getLeftX_tableColumns();
    	float[] rightX_tableColumns = tc.getRightX_tableColumns();
    	String[][] cells = new String[YNum][cc];
		boolean[][] crossCells = new boolean[YNum][cc];
		for (int tt=0; tt<tc.getRows().size(); tt++) {
			for (int qq=0; qq<cc; qq++) {
				cells[tt][qq] = "";
				crossCells[tt][qq]=false; 
			}
		}
    	for (int tt=0; tt<footnoteLineIndex; tt++) {
			String cellsThisLine = "";
			TableRow row = tc.getRows().get(tt);
			int cellThisLine = row.getCells().size(); //  pmoj.objectNum_eachY[tt];
			for (int zz=0; zz<cellThisLine; zz++) {
				for (int qq=0; qq<cc; qq++) {
					if ( (row.getCells().get(zz).getX()>=leftX_tableColumns[qq]) 
					&& (row.getCells().get(zz).getEndX()<=rightX_tableColumns[qq]) ) 
							cells[tt][qq] =cells[tt][qq] + row.getCells().get(zz).getText() + " ";
					if ((row.getCells().get(zz).getX()<leftX_tableColumns[qq]) 
					&&(leftX_tableColumns[qq]<=row.getCells().get(zz).getEndX()) )
							cells[tt][qq] = cells[tt][qq] +  row.getCells().get(zz).getText() + " ";
					if ((leftX_tableColumns[qq]>=row.getCells().get(zz).getX()) 
					&& (row.getCells().get(zz).getX()>=rightX_tableColumns[qq]) 
					&&(rightX_tableColumns[qq]<row.getCells().get(zz).getEndX()) )
						cells[tt][qq] = cells[tt][qq] +  row.getCells().get(zz).getText() + " ";
				}
			}
			for (int zz=0; zz<cellThisLine; zz++) {
				int crossCellBegin = 1000;
				int crossCellEnd=0;
				for (int qq=0; qq<cc; qq++) {
					if ( (qq>0) && (cells[tt][qq-1].length()==0) 
					&& (row.getCells().get(zz).getX()<=rightX_tableColumns[qq-1]) 
					&& (row.getCells().get(zz).getX()<leftX_tableColumns[qq]) 
					&& (leftX_tableColumns[qq]<=row.getCells().get(zz).getEndX()) ) {
						crossCells[tt][qq]=true;
						crossCells[tt][qq-1]=true;
						cells[tt][qq-1] = row.getCells().get(zz).getText();
						crossCellBegin=qq-1;
					}
					if ((qq<(cc-1)) && (cells[tt][qq+1].length()==0) 
					&& (row.getCells().get(zz).getEndX()>=leftX_tableColumns[qq+1]) 
					&& (row.getCells().get(zz).getX()<=rightX_tableColumns[qq]) 
					&& (rightX_tableColumns[qq]<row.getCells().get(zz).getEndX()) ) {
						crossCells[tt][qq]=true;
						crossCells[tt][qq+1]=true;
						cells[tt][qq+1] = row.getCells().get(zz).getText();
						crossCellEnd=qq+1;
					}
				}
			}
			for (int qq=0; qq<cc; qq++) {
				cellsThisLine = cellsThisLine + cells[tt][qq] + "; ";
			}
			contentsInRows[tt]=cellsThisLine;
		}
    	tc.setCells(cells);
    	tc.setCrossCells(crossCells);
    }
624791
public void addChildCellStyle(final TableCellStyle style, final TableCell.Type type) {
        this.contentElement.addChildCellStyle(style, type);
    }
1308652
public Cell getCell(int x, int y, boolean isCreateIfNotExist) {
		final Row row = isCreateIfNotExist ? RowUtil.getOrCreateRow(this.sheet, y) : this.sheet.getRow(y);
		if (null != row) {
			return isCreateIfNotExist ? CellUtil.getOrCreateCell(row, x) : row.getCell(x);
		}
		return null;
	}
479189
protected void genCell(int columnMaxLen, String preChar, String value, String fillChar, String postChar, StringBuilder ret) {
		ret.append(preChar);
		ret.append(value);
		for (int i=0, n=columnMaxLen-value.length() + 1; i<n; i++) {
			ret.append(fillChar);	// 值后的填充字符，值为 " "、"-"
		}
		ret.append(postChar);
	}
1355450
def _yCellParams(self):
        '''
        
        '''
        #cell type specific parameters going into LFPy.Cell        
        yCellParams = {}
        for layer, morpho, _, _ in self.y_zip_list:
            yCellParams.update({layer : self.cellParams.copy()})
            yCellParams[layer].update({
                'morphology' : os.path.join(self.PATH_m_y, morpho),
            })
        return yCellParams
962048
function yy_r2()
    {
        if ($this->yystack[ $this->yyidx + 0 ]->minor != null) {
            // because of possible code injection
            $this->current_buffer->append_subtree($this, $this->yystack[ $this->yyidx + 0 ]->minor);
        }
    }
53090
public static double findMaxRow( final int blockLength ,
                                          final DSubmatrixD1 Y ,
                                          final int row , final int colStart ) {
        final int height = Math.min(blockLength , Y.row1-Y.row0);

        final double dataY[] = Y.original.data;

        double max = 0;

        for( int j = Y.col0; j < Y.col1; j += blockLength ) {
            int width = Math.min( blockLength , Y.col1 - j );

            int index = Y.row0*Y.original.numCols + height*j + row*width;

            if( j == Y.col0 ) {
                index += colStart;

                for( int k = colStart; k < width; k++ ) {
                    double v = Math.abs(dataY[index++]);
                    if( v > max ) {
                        max = v;
                    }
                }
            } else {
                for( int k = 0; k < width; k++ ) {
                    double v = Math.abs(dataY[index++]);
                    if( v > max ) {
                        max = v;
                    }
                }
            }
        }

        return max;
    }
529763
@Deprecated
	public CellStyle createStyleForCell(int x, int y) {
		final Cell cell = getOrCreateCell(x, y);
		final CellStyle cellStyle = this.workbook.createCellStyle();
		cell.setCellStyle(cellStyle);
		return cellStyle;
	}
590567
function yy_r98(){ 
    $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor; 
    $keys   = [];
    $values = [];
    foreach ($this->yystack[$this->yyidx + -1]->minor->getExprs() as $field) {
        $member = $field->getMembers();
        $keys[]   = $member[0];
        $values[] = $member[1];
    }
    $this->yystack[$this->yyidx + -2]->minor->values([$values])->fields($keys);
    if ($this->yystack[$this->yyidx + 0]->minor) $this->_retvalue->onDuplicate($this->yystack[$this->yyidx + 0]->minor);
    }
855481
function vGrow(yy, edge) {
      const c = matrix.findCellAt(sheetName, yy, cell.col);
      if (!c || !c.mark) { return false; }
      range[edge] = yy;
      c.mark = false;
      return true;
    }
1245220
function yy_r4()
    {
        if ($this->compiler->has_code) {
            $this->_retvalue = $this->mergePrefixCode($this->yystack[ $this->yyidx + 0 ]->minor);
        } else {
            $this->_retvalue = null;
        }
        $this->compiler->has_variable_string = false;
        $this->block_nesting_level = count($this->compiler->_tag_stack);
    }
1014629
public ExcelWriter writeCellValue(int x, int y, Object value) {
		final Cell cell = getOrCreateCell(x, y);
		CellUtil.setCellValue(cell, value, this.styleSet, false);
		return this;
	}
1178193
public TableCellStyle findDefaultCellStyle(final int columnIndex) {
        TableCellStyle s = this.defaultCellStyle;
        if (s == null) {
            s = this.parent.findDefaultCellStyle(columnIndex);
        }
        return s;
    }
936335
def _get_y(self, kwargs):
        '''
        
        '''
        if 'y' in kwargs:
            return round(float(kwargs['y']), 6)
        elif self._element_y in kwargs:
            return round(float(kwargs[self._element_y]), 6)
        elif self._type == 3 and self._element_1my in kwargs:
            return round(1. - float(kwargs[self._element_1my]), 6)
        else:
            raise TypeError()
1272450
public Yytoken yylex() throws java.io.IOException, ParseException {
    int zzInput;
    int zzAction;

    // cached fields:
    int zzCurrentPosL;
    int zzMarkedPosL;
    int zzEndReadL = zzEndRead;
    char [] zzBufferL = zzBuffer;
    char [] zzCMapL = ZZ_CMAP;

    int [] zzTransL = ZZ_TRANS;
    int [] zzRowMapL = ZZ_ROWMAP;
    int [] zzAttrL = ZZ_ATTRIBUTE;

    while (true) {
      zzMarkedPosL = zzMarkedPos;

      yychar+= zzMarkedPosL-zzStartRead;

      zzAction = -1;

      zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
  
      zzState = ZZ_LEXSTATE[zzLexicalState];


      zzForAction: {
        while (true) {
    
          if (zzCurrentPosL < zzEndReadL)
            zzInput = zzBufferL[zzCurrentPosL++];
          else if (zzAtEOF) {
            zzInput = YYEOF;
            break zzForAction;
          }
          else {
            // store back cached positions
            zzCurrentPos  = zzCurrentPosL;
            zzMarkedPos   = zzMarkedPosL;
            boolean eof = zzRefill();
            // get translated positions and possibly new buffer
            zzCurrentPosL  = zzCurrentPos;
            zzMarkedPosL   = zzMarkedPos;
            zzBufferL      = zzBuffer;
            zzEndReadL     = zzEndRead;
            if (eof) {
              zzInput = YYEOF;
              break zzForAction;
            }
            else {
              zzInput = zzBufferL[zzCurrentPosL++];
            }
          }
          int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
          if (zzNext == -1) break zzForAction;
          zzState = zzNext;

          int zzAttributes = zzAttrL[zzState];
          if ( (zzAttributes & 1) == 1 ) {
            zzAction = zzState;
            zzMarkedPosL = zzCurrentPosL;
            if ( (zzAttributes & 8) == 8 ) break zzForAction;
          }

        }
      }

      // store back cached position
      zzMarkedPos = zzMarkedPosL;

      switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
        case 11: 
          { sb.append(yytext());
          }
        case 25: break;
        case 4: 
          { sb = null; sb = new StringBuffer(); yybegin(STRING_BEGIN);
          }
        case 26: break;
        case 16: 
          { sb.append('\b');
          }
        case 27: break;
        case 6: 
          { return new Yytoken(Yytoken.TYPE_RIGHT_BRACE,null);
          }
        case 28: break;
        case 23: 
          { Boolean val=Boolean.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
          }
        case 29: break;
        case 22: 
          { return new Yytoken(Yytoken.TYPE_VALUE, null);
          }
        case 30: break;
        case 13: 
          { yybegin(YYINITIAL);return new Yytoken(Yytoken.TYPE_VALUE, sb.toString());
          }
        case 31: break;
        case 12: 
          { sb.append('\\');
          }
        case 32: break;
        case 21: 
          { Double val=Double.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
          }
        case 33: break;
        case 1: 
          { throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_CHAR, new Character(yycharat(0)));
          }
        case 34: break;
        case 8: 
          { return new Yytoken(Yytoken.TYPE_RIGHT_SQUARE,null);
          }
        case 35: break;
        case 19: 
          { sb.append('\r');
          }
        case 36: break;
        case 15: 
          { sb.append('/');
          }
        case 37: break;
        case 10: 
          { return new Yytoken(Yytoken.TYPE_COLON,null);
          }
        case 38: break;
        case 14: 
          { sb.append('"');
          }
        case 39: break;
        case 5: 
          { return new Yytoken(Yytoken.TYPE_LEFT_BRACE,null);
          }
        case 40: break;
        case 17: 
          { sb.append('\f');
          }
        case 41: break;
        case 24: 
          { try{
														int ch=Integer.parseInt(yytext().substring(2),16);
														sb.append((char)ch);
													}
													catch(Exception e){
														throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_EXCEPTION, e);
													}
          }
        case 42: break;
        case 20: 
          { sb.append('\t');
          }
        case 43: break;
        case 7: 
          { return new Yytoken(Yytoken.TYPE_LEFT_SQUARE,null);
          }
        case 44: break;
        case 2: 
          { Long val=Long.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
          }
        case 45: break;
        case 18: 
          { sb.append('\n');
          }
        case 46: break;
        case 9: 
          { return new Yytoken(Yytoken.TYPE_COMMA,null);
          }
        case 47: break;
        case 3: 
          { 
          }
        case 48: break;
        default: 
          if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
            zzAtEOF = true;
            return null;
          } 
          else {
            zzScanError(ZZ_NO_MATCH);
          }
      }
    }
  }