import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@Override
public void initChildTable() {
    this.childContainer = new BeanContainer<Long, VirtualSystemDto>(VirtualSystemDto.class);
    this.childTable.setContainerDataSource(this.childContainer);
    // Creating table
    this.childTable.setVisibleColumns("name", "virtualizationConnectorName", "virtualizationType", "domainName",
            "markForDeletion");

    this.childTable.addGeneratedColumn("virtualizationConnectorName", new ColumnGenerator() {
        @Override
        public Object generateCell(CustomTable source, Object itemId, Object columnId) {
            VirtualSystemDto vsDto = DistributedApplianceView.this.childContainer.getItem(itemId).getBean();
            return ViewUtil.generateObjectLink(
                    new LockObjectDto(vsDto.getVcId(), vsDto.getVirtualizationConnectorName(),
                            ObjectTypeDto.VIRTUALIZATION_CONNECTOR), DistributedApplianceView.this.server);
        }
    });

    // re-naming table header columns
    this.childTable.setColumnHeader("name", "VSS Name");
    this.childTable.setColumnHeader("virtualizationConnectorName", "Virtualization Connector");
    this.childTable.setColumnHeader("virtualizationType", "Virtualization Type");
    this.childTable.setColumnHeader("domainName", "Domain");
    this.childTable.setColumnHeader("markForDeletion", "Deleted");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@SuppressWarnings("serial")
@Override
public void initTable() {
    this.tableContainer = new BeanContainer<Long, DeploymentSpecDto>(DeploymentSpecDto.class);
    this.table.setContainerDataSource(this.tableContainer);
    this.table.setVisibleColumns("name", "projectName", "managementNetworkName", "markForDeletion",
            "lastJobStatus");

    // Customizing column header names
    this.table.setColumnHeader("name", "Name");
    this.table.setColumnHeader("projectName", "Project");
    this.table.setColumnHeader("managementNetworkName", "Network");
    this.table.setColumnHeader("markForDeletion", "Deleted");
    this.table.addGeneratedColumn("lastJobStatus", new ColumnGenerator() {
        @Override
        public Object generateCell(CustomTable source, Object itemId, Object columnId) {
            DeploymentSpecDto dsDto = DeploymentSpecSubView.this.tableContainer.getItem(itemId).getBean();
            return ViewUtil.generateJobLink(dsDto.getLastJobStatus(), dsDto.getLastJobState(),
                    dsDto.getLastJobId(), DeploymentSpecSubView.this.server);
        }

    });
    this.table.setColumnHeader("lastJobStatus", "Last Job Status");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@Override
public void initParentTable() {
    this.parentContainer = new BeanContainer<>(VirtualizationConnectorDto.class);
    this.parentTable.setContainerDataSource(this.parentContainer);
    this.parentTable.setVisibleColumns("name", "type", "controllerIP", "providerIP");

    this.parentTable.addGeneratedColumn("providerIP", (ColumnGenerator) (source, itemId, columnId) -> {
        VirtualizationConnectorDto vcDto = VirtualizationConnectorView.this.parentContainer.getItem(itemId).getBean();

        return ViewUtil.generateMgrLink("http://", vcDto.getProviderIP(), "", "");
    });

    // Customizing header names
    this.parentTable.setColumnHeader("name", "Name");
    this.parentTable.setColumnHeader("type", "Type");
    this.parentTable.setColumnHeader("controllerIP", "Controller IP");
    this.parentTable.setColumnHeader("providerIP", "Provider IP");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@Override
public void initChildTable() {
    this.childContainer = new BeanContainer<>(SecurityGroupDto.class);
    this.childTable.setContainerDataSource(this.childContainer);
    this.childTable.setVisibleColumns("name", "projectName", "memberDescription", "servicesDescription",
            "markForDeletion", "lastJobStatus");
    this.childTable.addGeneratedColumn("lastJobStatus", (source, itemId, columnId) -> {
        SecurityGroupDto SGDto = VirtualizationConnectorView.this.childContainer.getItem(itemId).getBean();
        return ViewUtil.generateJobLink(SGDto.getLastJobStatus(), SGDto.getLastJobState(),
                SGDto.getLastJobId(), VirtualizationConnectorView.this.server);
    });

    // re-naming table header columns
    this.childTable.setColumnHeader("name", "Name");
    this.childTable.setColumnHeader("projectName", "Project");
    this.childTable.setColumnHeader("memberDescription", "Members");
    this.childTable.setColumnHeader("servicesDescription", "Services");
    this.childTable.setColumnHeader("markForDeletion", "Deleted");
    this.childTable.setColumnHeader("lastJobStatus", "Last Job Status");

}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@Override
	public void enter(ViewChangeEvent event) {
		quotes = new BeanContainer<String, Quote>(Quote.class);
		    
	    // Use the name property as the item ID of the bean
		quotes.setBeanIdProperty(Quote.PROPERTY_SYMBOL_ID);
		
		List<Quote> quotesList = tradingService.getQuotes();
		quotes.addAll(quotesList);
//		quoteSelector.setContainerDataSource(quotes);
//		quoteSelector.setInputPrompt(quotesList.get(0).getName());
		
		for (Quote quote : quotesList) {
			quoteSelector.addItem(quote.getSymbol());
			quoteSelector.setItemCaption(quote.getSymbol(), quote.getName());
		}
		
		chartToolbar.getTimeSteps().getChildren().get(chart.getTimeStep().ordinal()*2).setChecked(true);
		chart.setChartDrawType(LiveChart.ChartDrawType.LINE);
		chartToolbar.getCharts().getChildren().get(LiveChart.ChartDrawType.LINE.ordinal()*2).setChecked(true);
		quoteSelector.select(quotesList.get(0).getSymbol());
		
		
	}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
public MilestoneListSelect() {
    this.setItemCaptionMode(ItemCaptionMode.PROPERTY);

    MilestoneSearchCriteria criteria = new MilestoneSearchCriteria();
    criteria.setProjectIds(new SetSearchField<>(CurrentProjectVariables.getProjectId()));

    MilestoneService milestoneService = AppContextUtil.getSpringBean(MilestoneService.class);
    List<SimpleMilestone> milestones = (List<SimpleMilestone>) milestoneService.findPageableListByCriteria(new BasicSearchRequest<>(criteria));

    BeanContainer<String, SimpleMilestone> beanItem = new BeanContainer<>(SimpleMilestone.class);
    beanItem.setBeanIdProperty("id");

    milestones.forEach(beanItem::addBean);

    this.setContainerDataSource(beanItem);
    this.setItemCaptionPropertyId("name");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
public RoleComboBox() {
    this.setNullSelectionAllowed(false);
    this.setItemCaptionMode(ItemCaptionMode.PROPERTY);

    RoleSearchCriteria criteria = new RoleSearchCriteria();

    RoleService roleService = AppContextUtil.getSpringBean(RoleService.class);
    List<SimpleRole> roles = (List<SimpleRole>) roleService.findPageableListByCriteria(new BasicSearchRequest<>(criteria));

    BeanContainer<String, SimpleRole> beanItem = new BeanContainer<>(SimpleRole.class);
    beanItem.setBeanIdProperty("id");
    this.setContainerDataSource(beanItem);
    this.setItemCaptionPropertyId("rolename");

    SimpleRole ownerRole = new SimpleRole();
    ownerRole.setId(-1);
    ownerRole.setRolename(UserUIContext.getMessage(RoleI18nEnum.OPT_ACCOUNT_OWNER));
    beanItem.addBean(ownerRole);

    roles.forEach(role -> {
        beanItem.addBean(role);
        if (Boolean.TRUE.equals(role.getIsdefault())) {
            this.setValue(role.getId());
        }
    });
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
private void buildQuerySelectComponent() {
    SaveSearchResultCriteria searchCriteria = new SaveSearchResultCriteria();
    searchCriteria.setType(StringSearchField.and(searchCategory));
    searchCriteria.setCreateUser(StringSearchField.and(UserUIContext.getUsername()));
    searchCriteria.setSaccountid(new NumberSearchField(AppUI.getAccountId()));

    SaveSearchResultService saveSearchResultService = AppContextUtil.getSpringBean(SaveSearchResultService.class);
    List<SaveSearchResult> result = (List<SaveSearchResult>) saveSearchResultService.findPageableListByCriteria(new BasicSearchRequest<>(searchCriteria));
    beanItem = new BeanContainer<>(SaveSearchResult.class);
    beanItem.setBeanIdProperty("id");

    for (SaveSearchResult searchResult : result) {
        beanItem.addBean(searchResult);
    }
    this.setContainerDataSource(beanItem);
    this.setItemCaptionPropertyId("queryname");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public EntityTable(final Class<T> type, Collection<T> set, EmbeddedCrudComponent<T> crudComponent) {
	this.type = type;
	this.set = set;
	this.crudComponent = crudComponent;
	
	container = (BeanContainer<Long, T>) crudComponent.getContainer();
	container.setBeanIdProperty("id");
	container.addAll(set);
	
	if(set == null) {
		this.set = new HashSet<T>();
	}
	
	crudComponent.getTable().setPageLength(0);
	crudComponent.getTable().setColumnCollapsed("id", true);
	crudComponent.getTable().setValidationVisible(false);
	crudComponent.getTableLayout().setMargin(false);
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@Override
public void initChildTable() {
    this.childContainer = new BeanContainer<Long, PolicyDto>(PolicyDto.class);
    this.childTable.setContainerDataSource(this.childContainer);
    this.childTable.setVisibleColumns("policyName", "mgrDomainName");

    this.childTable.setColumnHeader("policyName", "Name");
    this.childTable.setColumnHeader("mgrDomainName", "Domain");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@Override
public void initParentTable() {
    this.parentContainer = new BeanContainer<Long, ApplianceDto>(ApplianceDto.class);
    this.parentTable.setContainerDataSource(this.parentContainer);
    this.parentTable.setVisibleColumns("model", "managerType", "managerVersion");

    // renaming column header
    this.parentTable.setColumnHeader("model", "Model");
    this.parentTable.setColumnHeader("managerType", "Manager Type");
    this.parentTable.setColumnHeader("managerVersion", "Manager Software Version");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@Override
public void initChildTable() {
    this.childContainer = new BeanContainer<Long, ApplianceSoftwareVersionDto>(ApplianceSoftwareVersionDto.class);
    this.childTable.setContainerDataSource(this.childContainer);
    this.childTable.setVisibleColumns("swVersion", "virtualizationType", "imageUrl");

    // re-naming table header columns
    this.childTable.setColumnHeader("swVersion", "Software");
    this.childTable.setColumnHeader("virtualizationType", "Virtualization Type");
    this.childTable.setColumnHeader("imageUrl", "Image Name");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@Override
public void initParentTable() {
    this.parentContainer = new BeanContainer<Long, AlarmDto>(AlarmDto.class);
    this.parentTable.setContainerDataSource(this.parentContainer);
    this.parentTable.setVisibleColumns("name", "enabledAlarm", "eventType", "severity", "alarmAction");

    // Customizing header names
    this.parentTable.setColumnHeader("name", "Name");
    this.parentTable.setColumnHeader("enabledAlarm", "Enabled");
    this.parentTable.setColumnHeader("eventType", "Event Type");
    this.parentTable.setColumnHeader("severity", "Severity");
    this.parentTable.setColumnHeader("alarmAction", "Action");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@Override
public void initParentTable() {
    this.parentContainer = new BeanContainer<Long, UserDto>(UserDto.class);
    this.parentTable.setContainerDataSource(this.parentContainer);
    this.parentTable.setVisibleColumns("loginName", "firstName", "lastName", "role", "email");

    // Customizing header names
    this.parentTable.setColumnHeader("loginName", "User Name");
    this.parentTable.setColumnHeader("firstName", "First");
    this.parentTable.setColumnHeader("lastName", "Last");
    this.parentTable.setColumnHeader("role", "Role");
    this.parentTable.setColumnHeader("email", "Email");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
/**
 * @param container
 *            BeanContainer of the table which needs to be updated
 * @param dto
 *            BeanItem(DTO)
 * @param table
 *            Table this dto belongs to
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void updateTableContainer(BeanContainer container, BaseDto dto, FilterTable table) {
    int indexOfItem = container.indexOfId(dto.getId());
    boolean wasSelected = table.isSelected(dto.getId());
    container.removeItem(dto.getId());
    container.addItemAt(indexOfItem, dto.getId(), dto);
    if (wasSelected) {
        table.select(dto.getId());
    }
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@SuppressWarnings("serial")
@Override
public void initParentTable() {
    this.parentContainer = new BeanContainer<Long, AlertDto>(AlertDto.class);

    this.parentTable.setContainerDataSource(this.parentContainer);
    this.parentTable.setVisibleColumns(ALERT_ID_COLUMN, ALERT_NAME_COLUMN_ID, ALERT_OBJECTS_COLUMN_ID,
            ALERT_SEVERITY_COLUMN_ID, ALERT_MESSAGE_COLUMN, ALERT_TIME_CREATED_COLUMN_ID, ALERT_STATUS_COLUMN_ID,
            ALERT_TIME_ACKNOWLEDGED_COLUMN_ID, ALERT_USER_ACKNOWLEDGED_COLUMN_ID);

    this.parentTable.addGeneratedColumn(ALERT_OBJECTS_COLUMN_ID, new ColumnGenerator() {
        @Override
        public Object generateCell(CustomTable source, Object itemId, Object columnId) {
            AlertDto alertDto = AlertView.this.parentContainer.getItem(itemId).getBean();
            if (alertDto.getObject() != null) {
                return ViewUtil.generateObjectLink(alertDto.getObject(), AlertView.this.server);
            }
            return null;
        }
    });

    this.parentTable.setColumnHeader(ALERT_ID_COLUMN, "Id");
    this.parentTable.setColumnHeader(ALERT_NAME_COLUMN_ID, "Name");
    this.parentTable.setColumnHeader(ALERT_OBJECTS_COLUMN_ID, "Objects");
    this.parentTable.setColumnHeader(ALERT_SEVERITY_COLUMN_ID, "Severity");
    this.parentTable.setColumnHeader(ALERT_MESSAGE_COLUMN, "Message");
    this.parentTable.setColumnHeader(ALERT_TIME_CREATED_COLUMN_ID, "Created");
    this.parentTable.setColumnHeader(ALERT_STATUS_COLUMN_ID, "Status");
    this.parentTable.setColumnHeader(ALERT_TIME_ACKNOWLEDGED_COLUMN_ID, "Acknowledged");
    this.parentTable.setColumnHeader(ALERT_USER_ACKNOWLEDGED_COLUMN_ID, "Acknowledged By");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void moveItems(CustomTable fromTable, CustomTable toTable) {
    if (fromTable.equals(toTable)) {
        return;
    }
    BeanContainer<String, SecurityGroupMemberItemDto> fromContainer = (BeanContainer<String, SecurityGroupMemberItemDto>) fromTable
            .getContainerDataSource();
    BeanContainer<String, SecurityGroupMemberItemDto> toContainer = (BeanContainer<String, SecurityGroupMemberItemDto>) toTable
            .getContainerDataSource();

    boolean isMovingToSelectedItemList = toTable == this.selectedItemsTable;

    String memberType = (String) this.protectionEntityType.getValue();
    Set<String> itemIdsSelected = (Set<String>) fromTable.getValue();
    for (String itemId : itemIdsSelected) {
        if (fromContainer.getItem(itemId) != null) {
            SecurityGroupMemberItemDto memberItem = fromContainer.getItem(itemId).getBean();
            // Add the item to the 'to' container, if the 'to' container is the selected items table
            if (isMovingToSelectedItemList) {
                toContainer.addBean(memberItem);
                handleProtectExternal(toTable, itemId, memberItem);
            } else if (memberItem.getType().equals(memberType)) {
                // If the 'to' container is not the selected list, we need to check the current selected type
                // from the UI and add the member only if it matches the selected type
                toContainer.addBean(memberItem);
            }
        }
        fromContainer.removeItem(itemId);
        fromTable.removeItem(itemId);
    }

    toTable.setValue(itemIdsSelected);
    updateCountFooter(fromTable, fromTable.getItemIds().size());
    updateCountFooter(toTable, toTable.getItemIds().size());

    toTable.sort(new Object[] { toTable.getSortContainerPropertyId() }, new boolean[] { toTable.isSortAscending() });
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
private BeanContainer<String, SecurityGroupMemberItemDto> createItemContainer() {
    BeanContainer<String, SecurityGroupMemberItemDto> container = new BeanContainer<String, SecurityGroupMemberItemDto>(
            SecurityGroupMemberItemDto.class);
    container.setBeanIdProperty("openstackId");
    container.setItemSorter(ViewUtil.getCaseInsensitiveItemSorter());
    return container;
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
public SimpleGraphContainer() {
	m_vertexContainer = new VertexContainer();
	m_edgeContainer = new BeanContainer<String, SimpleEdge>(SimpleEdge.class);
	m_edgeContainer.setBeanIdProperty("id");
	m_zoomLevelProperty = new MethodProperty<Integer>(Integer.class, this, "getSemanticZoomLevel", "setSemanticZoomLevel");
	m_scaleProperty = new MethodProperty<Double>(Double.class, this, "getScale", "setScale");
}
 

import com.vaadin.data.util.BeanContainer; //导入依赖的package包/类
private <T> List<T> getBeans(BeanContainer<?, T> container) {
	Collection<?> itemIds = container.getItemIds();
	List<T> beans = new ArrayList<T>(itemIds.size());
	
	for(Object itemId : itemIds) {
		beans.add(container.getItem(itemId).getBean());
	}
	
	return beans;
}