to join the data that does not fit into memory.
@param masterLabels label of master data
@param masterColumn master column
@param dataColumn data column
@param masterSeparator separator
@param masterData master data
967549
protected void setBigJoin(String[] masterLabels, String masterColumn,
                              String dataColumn, String masterSeparator, List<String> masterData) {
        this.conf.setInt(SimpleJob.READER_TYPE, SimpleJob.SINGLE_COLUMN_JOIN_READER);
        this.conf.setStrings(SimpleJob.MASTER_LABELS, masterLabels);
        this.conf.set(SimpleJob.JOIN_MASTER_COLUMN, masterColumn);
        this.conf.set(SimpleJob.JOIN_DATA_COLUMN, dataColumn);
        this.masterSeparator = masterSeparator;
        this.masterData = masterData;
        this.bigJoin = true;
    }
98889
public void setMergedDatasetNames(java.util.Collection<String> mergedDatasetNames) {
        if (mergedDatasetNames == null) {
            this.mergedDatasetNames = null;
            return;
        }

        this.mergedDatasetNames = new com.amazonaws.internal.SdkInternalList<String>(mergedDatasetNames);
    }
540186
protected void onSuperColumn(EntityMetadata m, boolean isRelation, List<String> relations, List<Object> entities,
        List<SuperColumn> superColumns, ByteBuffer key) {
        Object e = null;
        Object id = PropertyAccessorHelper.getObject(m.getIdAttribute().getJavaType(), key.array());

        ThriftRow tr = new ThriftRow(id, m.getTableName(), new ArrayList<Column>(0), superColumns,
            new ArrayList<CounterColumn>(0), new ArrayList<CounterSuperColumn>(0));

        e = getDataHandler().populateEntity(tr, m, KunderaCoreUtils.getEntity(e), relations, isRelation);
        if (log.isInfoEnabled()) {
            log.info("Populating data for super column family of clazz {} and row key {}.", m.getEntityClazz(),
                tr.getId());
        }

        if (e != null) {
            entities.add(e);
        }
    }
882460
public static void mergeNodes(TreeNode master, TreeNode slave) {
        DefaultMutableTreeNode masterNode = (DefaultMutableTreeNode) master;
        DefaultMutableTreeNode slaveNode = (DefaultMutableTreeNode) slave;

        int masterCnt = masterNode.getChildCount();

        // loop thru the slaves
        while (slaveNode.getChildCount() > 0) {
            DefaultMutableTreeNode slaveNodeChild = (DefaultMutableTreeNode) slaveNode.getFirstChild();

            // loop thru the master children
            for (int m = 0; m < masterCnt; m++) {
                DefaultMutableTreeNode masterAtM = (DefaultMutableTreeNode) masterNode.getChildAt(m);

                if (doCustomMerge(slaveNodeChild, masterAtM)) {
                    slaveNodeChild = null;
                    break;
                }

                // see if the names are the same
                if (MergeHelpUtilities.compareNames(masterAtM, slaveNodeChild) == 0) {
                    if (MergeHelpUtilities.haveEqualID(masterAtM, slaveNodeChild)) {
                        // ID and name the same merge the slave node in
                        MergeHelpUtilities.mergeNodes(DEFAULT_MERGE_TYPE, masterAtM, slaveNodeChild);
                        // Need to remove the slaveNodeChild from the list
                        slaveNodeChild.removeFromParent();
                        slaveNodeChild = null;
                        break;
                    }
                    // Names are the same but the ID are not
                    // Mark the nodes and add the slaveChild
                    MergeHelpUtilities.markNodes(masterAtM, slaveNodeChild);
                    masterNode.add(slaveNodeChild);
                    MergeHelpUtilities.mergeNodeChildren(DEFAULT_MERGE_TYPE, slaveNodeChild);
                    slaveNodeChild = null;
                    break;
                }
            }
            if (slaveNodeChild != null) {
                masterNode.add(slaveNodeChild);
                MergeHelpUtilities.mergeNodeChildren(DEFAULT_MERGE_TYPE, slaveNodeChild);
            }
        }
        // There are no more children.
        // Remove slaveNode from it's parent
        slaveNode.removeFromParent();
        slaveNode = null;
    }
575595
public void addJKTableColumn(String keyLabel) {
		JKTableColumn col = new JKTableColumn();
		col.setName(keyLabel);
		addJKTableColumn(col);
	}
959661
@SuppressWarnings("unchecked")
  public static Map<String, String> getLabels(ObjectMeta metadata) {
    if (metadata != null) {
      Map<String, String> labels = metadata.getLabels();
      if (labels != null) {
        return labels;
      }
    }
    return Collections.EMPTY_MAP;
  }
699453
public void add(Collection<Label> labels)
    {
        for(Label label : labels)
            this.labels.put(label.getKey(), label);
    }
85226
public void addRelationLabel(Relation e0, HashMap<String,String> properties) {
        String label=null;
        if (!(e0 instanceof QualifiedRelation)) return;
        QualifiedRelation e=(QualifiedRelation)e0;
        List<Type> type=pf.getType(e);
        if ((type!=null) && (!type.isEmpty())) {
            label=type.get(0).getValue().toString();
        } else if (getRelationPrintRole(e)) {
            String role=pf.getRole(e);
            if (role!=null) {
                label=displayRole(role);
                properties.put("fontsize","8");
            }
        }
        if (label!=null) {
            properties.put("label",convertRelationLabel(label));
            if (properties.get("fontsize")==null) {
                properties.put("fontsize","10");
            }
        }
    }
708989
public final void setSelectionList(Object[] keys, Object[] labels)
    {
        selectionListKeys = keys;
        selectionListLabelMessages = createLabels(getId(), labels);
        combobox.setModel(new DefaultComboBoxModel(selectionListLabelMessages));
        selectItem(getValue());
    }
1016394
public void setLabel(final String label) {
        if (label != null)
            attrMixin.setAttribute(LABEL, label);
        else
            attrMixin.removeAttribute(LABEL);
    }
783101
public static JavaRDD<DataSet> fromLabeledPoint(JavaRDD<LabeledPoint> data, final long numPossibleLabels) {
        return fromLabeledPoint(data, numPossibleLabels, false);
    }
286875
public void addTableField(String fieldLabel, JTable field, List<JButton> buttons) {
		validateNotTabbed();
		JScrollPane scrollPane = new JScrollPane();
		scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
		scrollPane.setViewportView(field);
		field.setFillsViewportHeight(true);
		
		// Tables are a special case - they don't have labels and are accessed via the model
		if (this.fieldList.contains(field)) {
			throw new IllegalArgumentException("Field already added: " + field);
		}
		
		if (buttons == null || buttons.size() == 0) {
			if (fieldLabel == null) {
				this.getMainPanel().add(scrollPane,
						LayoutHelper.getGBC(1, this.fieldList.size(), 1, fieldWeight, 1.0D, 
								GridBagConstraints.BOTH, new Insets(4,4,4,4)));
			} else {
				this.addField(fieldLabel, field, scrollPane, 1.0D);
			}
		} else {
			JPanel tablePanel = new JPanel();
			tablePanel.setLayout(new GridBagLayout());
			tablePanel.add(scrollPane,
					LayoutHelper.getGBC(0, 0, 1, 1.0D, 1.0D, GridBagConstraints.BOTH, new Insets(4,4,4,4)));

			JPanel buttonPanel = new JPanel();
			buttonPanel.setLayout(new GridBagLayout());
			int buttonId = 0;
			for (JButton button : buttons) {
				buttonPanel.add(button,
						LayoutHelper.getGBC(0, buttonId++, 1, 0D, 0D, GridBagConstraints.BOTH, new Insets(2,2,2,2)));
			}
			// Add spacer to force buttons to the top
			buttonPanel.add(new JLabel(),
					LayoutHelper.getGBC(0, buttonId++, 1, 0D, 1.0D, GridBagConstraints.BOTH, new Insets(2,2,2,2)));
			
			tablePanel.add(buttonPanel,
					LayoutHelper.getGBC(1, 0, 1, 0D, 0D, GridBagConstraints.BOTH, new Insets(2,2,2,2)));

			if (fieldLabel == null) {
				this.getMainPanel().add(tablePanel,
						LayoutHelper.getGBC(1, this.fieldList.size(), 1, fieldWeight, 1.0D, 
								GridBagConstraints.BOTH, new Insets(4,4,4,4)));
			} else {
				this.addField(fieldLabel, field, tablePanel, 1.0D);
			}
		}
		this.fieldList.add(field);
	}
31524
@Override
    public void fit(INDArray data, INDArray labels) {
        fit(data, labels, null, null);
    }
1339780
@Deprecated
    public static JavaRDD<DataSet> fromLabeledPoint(JavaSparkContext sc, JavaRDD<LabeledPoint> data,
                    final long numPossibleLabels) {
        return data.map(new Function<LabeledPoint, DataSet>() {
            @Override
            public DataSet call(LabeledPoint lp) {
                return fromLabeledPoint(lp, numPossibleLabels);
            }
        });
    }
573010
synchronized public void addLabel(String label) {
        if (!labelMap.contains(label)) {
            labelMap.add(labelCounter++, label);
        }
    }
565906
private void initGridLabels() {
        int dim = base.getDimension();
        double[] offset = new double[dim];
        for (int j = 0; j < dim; j++) {
            if (j != index) {
                offset[j] = -(base.getUpperBounds()[j] - base.getLowerBounds()[j]) / 100;
            }
        }

        int decimal = 0;
        String label;

        gridLabels = new Label[labelsSlicing.length];

        for (int i = 0; i < gridLabels.length; i++) {

            double[] labelCoord = new double[base.getDimension()];
            System.arraycopy(base.getCoordinateSpace()[index + 1], 0, labelCoord, 0, base.getDimension());
            labelCoord[index] = labelsSlicing[i];

            if (dim == 3) {
                if (index == 0) {
                    labelCoord[2] = base.getUpperBounds()[2] - 2 * offset[2];
                } else if (index == 1) {
                    labelCoord[0] = base.getUpperBounds()[0] - 2 * offset[0];
                } else if (index == 2) {
                    labelCoord[1] = base.getUpperBounds()[1] - 2 * offset[1];
                }
            }

            decimal = base.getPrecisionDigits()[index];

            if (gridLabelStrings != null) {
                label = gridLabelStrings[i % gridLabelStrings.length];
            } else {
                String format = "%.0f";
                if (decimal < 0) {
                    format = String.format("%%.%df", -decimal);
                }
                label = String.format(format, labelsSlicing[i]);
            }

            for (int j = 0; j < dim; j++) {
                labelCoord[j] += offset[j];
            }

            if (base.getDimension() == 2) {
                if (index == 0) {
                    if (rotation == 0.0) {
                        gridLabels[i] = new Label(label, 0.5, 1.0, labelCoord);
                    } else {
                        gridLabels[i] = new Label(label, 1.0, 0.5, rotation, labelCoord);
                    }
                } else {
                    gridLabels[i] = new Label(label, 1.0, 0.5, labelCoord);
                }
            } else {
                if (index == 0) {
                    gridLabels[i] = new Label(label, 0.5, -0.5, labelCoord);
                } else if (index == 1) {
                    gridLabels[i] = new Label(label, 0.5, 1.0, labelCoord);
                } else if (index == 2) {
                    gridLabels[i] = new Label(label, 0.0, 0.5, labelCoord);
                }
            }

            gridLabels[i].setFont(gridLabelFont);
        }

        gridLabelStrings = null;
    }
197156
protected void buildMeta() {
    if(haslabels) {
      meta = new BundleMeta(2);
      meta.add(getTypeInformation(mindim, maxdim));
      meta.add(TypeUtil.LABELLIST);
    }
    else {
      meta = new BundleMeta(1);
      meta.add(getTypeInformation(mindim, maxdim));
    }
  }