Returns an UpdatableSketch with the current configuration of this Builder.
@return an UpdatableSketch
186898
public UpdatableSketch<U, S> build() {
    return new UpdatableSketch<>(nomEntries_, resizeFactor_.lg(), samplingProbability_,
        summaryFactory_);
  }
31672
public SqlStatement getPreparedUpdateStatement(ClassDescriptor cld)
    {
        SqlForClass sfc = getSqlForClass(cld);
        SqlStatement result = sfc.getUpdateSql();
        if(result == null)
        {
            ProcedureDescriptor pd = cld.getUpdateProcedure();

            if(pd == null)
            {
                result = new SqlUpdateStatement(cld, logger);
            }
            else
            {
                result = new SqlProcedureStatement(pd, logger);
            }
            // set the sql string
            sfc.setUpdateSql(result);

            if(logger.isDebugEnabled())
            {
                logger.debug("SQL:" + result.getStatement());
            }
        }
        return result;
    }
213664
protected void updateTables()
   {
      byte[] data = m_model.getData();
      int columns = m_model.getColumns();
      int rows = (data.length / columns) + 1;
      int offset = m_model.getOffset();

      String[][] hexData = new String[rows][columns];
      String[][] asciiData = new String[rows][columns];

      int row = 0;
      int column = 0;
      StringBuilder hexValue = new StringBuilder();
      for (int index = offset; index < data.length; index++)
      {
         int value = data[index];
         hexValue.setLength(0);
         hexValue.append(HEX_DIGITS[(value & 0xF0) >> 4]);
         hexValue.append(HEX_DIGITS[value & 0x0F]);

         char c = (char) value;
         if ((c > 200) || (c < 27))
         {
            c = ' ';
         }

         hexData[row][column] = hexValue.toString();
         asciiData[row][column] = Character.toString(c);

         ++column;
         if (column == columns)
         {
            column = 0;
            ++row;
         }
      }

      String[] columnHeadings = new String[columns];
      TableModel hexTableModel = new DefaultTableModel(hexData, columnHeadings)
      {
         @Override public boolean isCellEditable(int r, int c)
         {
            return false;
         }
      };

      TableModel asciiTableModel = new DefaultTableModel(asciiData, columnHeadings)
      {
         @Override public boolean isCellEditable(int r, int c)
         {
            return false;
         }
      };

      m_model.setSizeValueLabel(Integer.toString(data.length));
      m_model.setHexTableModel(hexTableModel);
      m_model.setAsciiTableModel(asciiTableModel);
      m_model.setCurrentSelectionIndex(0);
      m_model.setPreviousSelectionIndex(0);
   }
705928
private JXTable getHttpSessionsTable() {
		if (sessionsTable == null) {
			sessionsTable = new JXTable(sessionsModel);

			sessionsTable.setColumnSelectionAllowed(false);
			sessionsTable.setCellSelectionEnabled(false);
			sessionsTable.setRowSelectionAllowed(true);
			sessionsTable.setAutoCreateRowSorter(true);
			sessionsTable.setColumnControlVisible(true);
			sessionsTable.setAutoCreateColumnsFromModel(false);

			sessionsTable.getColumnExt(0).setCellRenderer(
					new DefaultTableRenderer(new MappedValue(StringValues.EMPTY, IconValues.NONE), JLabel.CENTER));
			sessionsTable.getColumnExt(0).setHighlighters(new ActiveSessionIconHighlighter(0));

			this.setSessionsTableColumnSizes();

			sessionsTable.setName(PANEL_NAME);
			sessionsTable.setDoubleBuffered(true);
			sessionsTable.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
			sessionsTable.addMouseListener(new java.awt.event.MouseAdapter() {
				@Override
				public void mousePressed(java.awt.event.MouseEvent e) {

					showPopupMenuIfTriggered(e);
				}
				@Override
				public void mouseReleased(java.awt.event.MouseEvent e) {
					showPopupMenuIfTriggered(e);
				}
				private void showPopupMenuIfTriggered(java.awt.event.MouseEvent e) {
					if (e.isPopupTrigger()) {

						// Select table item
						int row = sessionsTable.rowAtPoint(e.getPoint());
						if (row < 0 || !sessionsTable.getSelectionModel().isSelectedIndex(row)) {
							sessionsTable.getSelectionModel().clearSelection();
							if (row >= 0) {
								sessionsTable.getSelectionModel().setSelectionInterval(row, row);
							}
						}

						View.getSingleton().getPopupMenu().show(e.getComponent(), e.getX(), e.getY());
					}
				}
			});
		}
		return sessionsTable;
	}
1280694
function() {
			if (this._bIsUpdatable != null) {
				return this._bIsUpdatable;
			}
			var oUpdatablePropertyNameSet = this._oQueryResult.getEntitySet().getUpdatablePropertyNameSet();

			return (oUpdatablePropertyNameSet[this.getName()] != undefined);
		}
1226731
public Stream<Cursor> getCursors() {
    return LongStream.range(0, getData().cursorCount).mapToObj(i -> {
      return new Cursor((CharTrieIndex) this.trie, ((CharTrieIndex) this.trie).cursors.get((int) (i + getData().firstCursorIndex)), getDepth());
    });
  }
446504
public Record getReference()
    {
        Record record = this.getReferenceRecord();
        if (record != null)
        {
            try   {
                if (this.getData() == null)
                {
                    record.addNew();
                    return record;
                }
                Object bookmark = this.getData();
                if ((record.getEditMode() == Constants.EDIT_IN_PROGRESS)
                    || (record.getEditMode() == Constants.EDIT_CURRENT))
                {
                    Object oldBookmark = record.getHandle(DBConstants.BOOKMARK_HANDLE);
                    if ((bookmark != null) && (bookmark.equals(oldBookmark)))
                        return record;  // This record is already current
                }
                record.setHandle(bookmark, DBConstants.BOOKMARK_HANDLE);
            } catch (DBException ex)    {
                ex.printStackTrace();
                record = null;
            }   
        } 
        return record;
    }
459357
public static HierarchicalConfiguration getCurrentConfig() {
        SiteContext siteContext = SiteContext.getCurrent();
        if (siteContext != null) {
            return siteContext.getConfig();
        } else {
            return null;
        }
    }
1267337
static HeapUpdateDoublesSketch newInstance(final int k) {
    final HeapUpdateDoublesSketch hqs = new HeapUpdateDoublesSketch(k);
    final int baseBufAlloc = 2 * Math.min(DoublesSketch.MIN_K, k); //the min is important
    hqs.n_ = 0;
    hqs.combinedBuffer_ = new double[baseBufAlloc];
    hqs.baseBufferCount_ = 0;
    hqs.bitPattern_ = 0;
    hqs.minValue_ = Double.NaN;
    hqs.maxValue_ = Double.NaN;
    return hqs;
  }
988882
private String getManyToOneFetch() {
        Assert.isTrue(relation.isManyToOne());
        return jpaFetch(this, relation.getFromAttribute().getColumnConfig().getManyToOneConfig(), //
                relation.getFromEntity().getConfig().getCelerio().getConfiguration().getDefaultManyToOneConfig());
    }
891601
public Long getUpdateNumber() {
        Long updateNumber = 0L;
        if (items.size() != 0) {
            for (TableStat item : items) {
                updateNumber += item.getUpdateCount();
            }
        }
        return updateNumber;
    }
543361
CpcSketch copy() {
    final CpcSketch copy = new CpcSketch(lgK, seed);
    copy.numCoupons = numCoupons;
    copy.mergeFlag = mergeFlag;
    copy.fiCol = fiCol;

    copy.windowOffset = windowOffset;
    copy.slidingWindow = (slidingWindow == null) ? null : slidingWindow.clone();
    copy.pairTable = (pairTable == null) ? null : pairTable.copy();

    copy.kxp = kxp;
    copy.hipEstAccum = hipEstAccum;
    return copy;
  }
1373788
static DirectCompactDoublesSketch createFromUpdateSketch(final UpdateDoublesSketch sketch,
                                                           final WritableMemory dstMem) {
    final long memCap = dstMem.getCapacity();
    final int k = sketch.getK();
    final long n = sketch.getN();
    checkDirectMemCapacity(k, n, memCap);

    //initialize dstMem
    dstMem.putLong(0, 0L); //clear pre0
    insertPreLongs(dstMem, 2);
    insertSerVer(dstMem, DoublesSketch.DOUBLES_SER_VER);
    insertFamilyID(dstMem, Family.QUANTILES.getID());
    insertK(dstMem, k);

    final int flags = COMPACT_FLAG_MASK | READ_ONLY_FLAG_MASK; // true for all compact sketches

    if (sketch.isEmpty()) {
      insertFlags(dstMem, flags | EMPTY_FLAG_MASK);
    } else {
      insertFlags(dstMem, flags);
      insertN(dstMem, n);
      insertMinDouble(dstMem, sketch.getMinValue());
      insertMaxDouble(dstMem, sketch.getMaxValue());

      final int bbCount = computeBaseBufferItems(k, n);

      final DoublesSketchAccessor inputAccessor = DoublesSketchAccessor.wrap(sketch);
      assert bbCount == inputAccessor.numItems();

      long dstMemOffset = COMBINED_BUFFER;

      // copy and sort base buffer
      final double[] bbArray = inputAccessor.getArray(0, bbCount);
      Arrays.sort(bbArray);
      dstMem.putDoubleArray(dstMemOffset, bbArray, 0, bbCount);
      dstMemOffset += bbCount << 3;

      long bitPattern = computeBitPattern(k, n);
      for (int lvl = 0; bitPattern > 0; ++lvl, bitPattern >>>= 1) {
        if ((bitPattern & 1L) > 0L) {
          inputAccessor.setLevel(lvl);
          dstMem.putDoubleArray(dstMemOffset, inputAccessor.getArray(0, k), 0, k);
          dstMemOffset += k << 3;
        }
      }
    }

    final DirectCompactDoublesSketch dcds = new DirectCompactDoublesSketch(k);
    dcds.mem_ = dstMem;

    return dcds;
  }
1284880
public java.util.List<InstancePatchState> getInstancePatchStates() {
        if (instancePatchStates == null) {
            instancePatchStates = new com.amazonaws.internal.SdkInternalList<InstancePatchState>();
        }
        return instancePatchStates;
    }
187543
public java.util.List<RecordPatch> getRecordPatches() {
        if (recordPatches == null) {
            recordPatches = new com.amazonaws.internal.SdkInternalList<RecordPatch>();
        }
        return recordPatches;
    }
1002418
public Table newRow()
    {
        unnest();
        nest(row = new Block("tr"));
        if (_defaultRow!=null)
        {
            row.setAttributesFrom(_defaultRow);
            if (_defaultRow.size()>0)
                row.add(_defaultRow.contents());
        }
        cell=null;
        return this;
    }
57586
public RawRowMapper<T> getRawRowMapper() {
		if (rawRowMapper == null) {
			rawRowMapper = new RawRowMapperImpl<T, ID>(dao);
		}
		return rawRowMapper;
	}