Helper method to make a property definition queryable and orderable.<p>

@param propDef the property definition

@return the modified property definition
503459
private static AbstractPropertyDefinition<?> queryableAndOrderable(AbstractPropertyDefinition<?> propDef) {

        propDef.setIsQueryable(Boolean.TRUE);
        propDef.setIsOrderable(Boolean.TRUE);
        return propDef;
    }
700926
function getPropArray(classDef) {
  // Translate the property names into definitions with property/attribute names
  return Object.keys(classDef.properties).map(propertyName => ({
    propertyName,
    attributeName: Util.hyphenate(propertyName),
    type: classDef.properties[propertyName].type,
    order: classDef.properties[propertyName].order,
    noGetterFromSetter: classDef.properties[propertyName].noGetterFromSetter,
    propagateToChildren: classDef.properties[propertyName].propagateToChildren,
    value: classDef.properties[propertyName].value,
  }))
    .sort((a, b) => {
      if (a.order !== undefined && b.order !== undefined) {
        return a.order - b.order;
      } else if (a.order !== undefined) {
        return -1;
      } else if (b.order !== undefined) {
        return 1;
      } else {
        return 0;
      }
    });
}
585703
protected void editPropertyDefinition() {

        CmsRpcAction<ArrayList<String>> action = new CmsRpcAction<ArrayList<String>>() {

            @Override
            public void execute() {

                start(200, true);
                CmsCoreProvider.getVfsService().getDefinedProperties(this);
            }

            @Override
            protected void onResponse(ArrayList<String> result) {

                stop(false);
                CmsPropertyDefinitionDialog dialog = new CmsPropertyDefinitionDialog(result);
                dialog.center();
                dialog.addCloseHandler(new CloseHandler<PopupPanel>() {

                    public void onClose(CloseEvent<PopupPanel> event) {

                        onClosePropertyDefinitionDialog();
                    }

                });
            }

        };
        action.execute();
    }
379795
public static String getProperty( Properties props, String key, String def )
    {
        String value = props.getProperty( key, def );
        if( value == null )
        {
            return null;
        }
        if( "".equals( value ) )
        {
            return value;
        }
        value = PropertyResolver.resolve( props, value );
        return value;
    }
590821
public TableDefinition getLinkExtentTableDef(FieldDefinition linkDef) {
        assert linkDef != null;
        assert linkDef.isLinkType();
        assert m_appDef != null;
        
        TableDefinition tableDef = m_appDef.getTableDef(linkDef.getLinkExtent());
        assert tableDef != null;
        return tableDef;
    }
736571
private ColumnInfo getColumn(TableInfo tableInfo, Attribute column, PropertyIndex indexedColumn,
            String[] orderByColumns)
    {
        ColumnInfo columnInfo = new ColumnInfo();

        if (column.getJavaType().isAnnotationPresent(OrderBy.class))
        {
            OrderBy order = (OrderBy) column.getJavaType().getAnnotation(OrderBy.class);
            orderByColumns = order.value().split("\\s*,\\s*");

        }
        columnInfo.setOrderBy(getOrderByColumn(orderByColumns, column));

        if (column.getJavaType().isEnum())
        {
            columnInfo.setType(String.class);
        }
        else
        {
            columnInfo.setType(column.getJavaType());
        }
        columnInfo.setColumnName(((AbstractAttribute) column).getJPAColumnName());
        if (indexedColumn != null && indexedColumn.getName() != null)
        {
            columnInfo.setIndexable(true);
            IndexInfo indexInfo = new IndexInfo(((AbstractAttribute) column).getJPAColumnName(), indexedColumn.getMax(),
                    indexedColumn.getMin(), indexedColumn.getIndexType(), indexedColumn.getName());
            tableInfo.addToIndexedColumnList(indexInfo);
            // Add more if required
        }

        return columnInfo;
    }
1052377
def p_propertyDeclaration_5(p):
    """'"""
    quals = OrderedDict([(x.name, x) for x in p[1]])
    p[0] = CIMProperty(p[3], None, type=p[2], qualifiers=quals)
1257640
public static AbstractTableModel getProperties(final CSProperties p) {

        return new AbstractTableModel() {

            @Override
            public int getRowCount() {
                return p.keySet().size();
            }

            @Override
            public int getColumnCount() {
                return 2;
            }

            @Override
            public Object getValueAt(int rowIndex, int columnIndex) {
                if (columnIndex == 0) {
                    return " " + p.keySet().toArray()[rowIndex];
                } else {
                    return p.values().toArray()[rowIndex];
                }
            }

            @Override
            public boolean isCellEditable(int rowIndex, int columnIndex) {
                return columnIndex == 1;
            }

            @Override
            public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
                if (columnIndex == 1) {
                    String[] keys = p.keySet().toArray(new String[0]);
                    p.put(keys[rowIndex], aValue.toString());
                }
            }

            @Override
            public String getColumnName(int column) {
                return column == 0 ? "Name" : "Value";
            }

            @Override
            public Class<?> getColumnClass(int columnIndex) {
                return String.class;
            }
        };
    }
1079635
protected A_CmsPropertyEditor createEntryEditor(
        I_CmsPropertyEditorHandler handler,
        Map<String, CmsXmlContentProperty> propConfig) {

        if (CmsSitemapView.getInstance().isNavigationMode()) {
            return new CmsNavModePropertyEditor(propConfig, handler);
        } else {
            boolean isFolder = handler.isFolder();
            CmsVfsModePropertyEditor result = new CmsVfsModePropertyEditor(propConfig, handler);
            result.setShowResourceProperties(!isFolder);
            return result;
        }
    }
775362
@Override
    public Object get(String propName) {
        if (propName.equals(PROP_C)) {
            return getC();
        }
        if (propName.equals(PROP_COUNTRY_NAME)) {
            return getCountryName();
        }
        if (propName.equals(PROP_DESCRIPTION)) {
            return getDescription();
        }
        return super.get(propName);
    }
852515
@Override
    public Object get(String propName) {
        if (propName.equals("modifyMode")) {
            return getModifyMode();
        }
        return super.get(propName);
    }
681239
public static <E extends Enum<E>> EnumCliParam<E> fromDef(EnumParamDef<E> def) {
        return new EnumCliParam<>(def.getIdentifier(), def.getDefaultValueSupplier(), def.isNullable(), def.getEnumClass());
    }
302901
public DescribableList<ViewProperty,ViewPropertyDescriptor> getProperties() {
        // readResolve was the best place to do this, but for compatibility reasons,
        // this class can no longer have readResolve() (the mechanism itself isn't suitable for class hierarchy)
        // see JENKINS-9431
        //
        // until we have that, putting this logic here.
        synchronized (PropertyList.class) {
            if (properties == null) {
                properties = new PropertyList(this);
            } else {
                properties.setOwner(this);
            }
            return properties;
        }
    }
192727
public static PropertyDescriptor getPropertyDescriptor(Object bean, String propertyName)
	{
		BeanInfo beanInfo = getBeanInfo(bean);
		
		PropertyDescriptor propertyDescriptor = getFeatureDescriptor(propertyName, beanInfo.getPropertyDescriptors());

		checkArgument(propertyDescriptor != null, "No such property '%s' on bean: %s", propertyName, bean);
		
		return propertyDescriptor;
	}
222271
private void addTableFor(ClassDescriptorDef classDef)
    {
        String                  name     = classDef.getProperty(PropertyHelper.OJB_PROPERTY_TABLE);
        TableDef                tableDef = getTable(name);
        FieldDescriptorDef      fieldDef;
        ReferenceDescriptorDef  refDef;
        CollectionDescriptorDef collDef;
        ColumnDef               columnDef;
        IndexDef                indexDef;

        if (tableDef == null)
        {
            tableDef = new TableDef(name);
            addTable(tableDef);
        }
        if (classDef.hasProperty(PropertyHelper.OJB_PROPERTY_DOCUMENTATION))
        {
            tableDef.setProperty(PropertyHelper.OJB_PROPERTY_DOCUMENTATION,
                                 classDef.getProperty(PropertyHelper.OJB_PROPERTY_DOCUMENTATION));
        }
        if (classDef.hasProperty(PropertyHelper.OJB_PROPERTY_TABLE_DOCUMENTATION))
        {
            tableDef.setProperty(PropertyHelper.OJB_PROPERTY_TABLE_DOCUMENTATION,
                                 classDef.getProperty(PropertyHelper.OJB_PROPERTY_TABLE_DOCUMENTATION));
        }
        for (Iterator fieldIt = classDef.getFields(); fieldIt.hasNext();)
        {
            fieldDef = (FieldDescriptorDef)fieldIt.next();
            if (fieldDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_IGNORE, false) ||
                fieldDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_VIRTUAL_FIELD, false))
            {
                continue;
            }
            columnDef = addColumnFor(fieldDef, tableDef);
            if (fieldDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_INDEXED, false))
            {
                // add the field to the default index
                indexDef = tableDef.getIndex(null);
                if (indexDef == null)
                {
                    indexDef = new IndexDef(null, false);
                    tableDef.addIndex(indexDef);
                }
                indexDef.addColumn(columnDef.getName());
            }
        }
        for (Iterator refIt = classDef.getReferences(); refIt.hasNext();)
        {
            refDef = (ReferenceDescriptorDef)refIt.next();
            if (!refDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_IGNORE, false))
            {
                addForeignkeys(refDef, tableDef);
            }
        }
        for (Iterator collIt = classDef.getCollections(); collIt.hasNext();)
        {
            collDef = (CollectionDescriptorDef)collIt.next();
            if (!collDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_IGNORE, false))
            {
                if (collDef.hasProperty(PropertyHelper.OJB_PROPERTY_INDIRECTION_TABLE))
                {
                    addIndirectionTable(collDef);
                }
                else
                {
                    addForeignkeys(collDef, tableDef);
                }
            }
        }
        for (Iterator indexIt = classDef.getIndexDescriptors(); indexIt.hasNext();)
        {
            addIndex((IndexDescriptorDef)indexIt.next(), tableDef);
        }
    }
1340525
@Override
    public ProtocolDef property(String name, String value) {
        protocol.getOrCreate("property@name=" + name).attribute("name", name).text(value);
        return this;
    }
452830
public function getModifyTableDDL(PropelTableDiff $tableDiff)
    {
        $ret = '';

        // drop indices, foreign keys
        if ($tableDiff->hasModifiedPk()) {
            $ret .= $this->getDropPrimaryKeyDDL($tableDiff->getFromTable());
        }
        foreach ($tableDiff->getRemovedFks() as $fk) {
            $ret .= $this->getDropForeignKeyDDL($fk);
        }
        foreach ($tableDiff->getModifiedFks() as $fkName => $fkModification) {
            list($fromFk, $toFk) = $fkModification;
            $ret .= $this->getDropForeignKeyDDL($fromFk);
        }
        foreach ($tableDiff->getRemovedIndices() as $index) {
            $ret .= $this->getDropIndexDDL($index);
        }
        foreach ($tableDiff->getModifiedIndices() as $indexName => $indexModification) {
            list($fromIndex, $toIndex) = $indexModification;
            $ret .= $this->getDropIndexDDL($fromIndex);
        }

        // alter table structure
        foreach ($tableDiff->getRenamedColumns() as $columnRenaming) {
            $ret .= $this->getRenameColumnDDL($columnRenaming[0], $columnRenaming[1]);
        }
        if ($modifiedColumns = $tableDiff->getModifiedColumns()) {
            $ret .= $this->getModifyColumnsDDL($modifiedColumns);
        }
        if ($addedColumns = $tableDiff->getAddedColumns()) {
            $ret .= $this->getAddColumnsDDL($addedColumns);
        }
        foreach ($tableDiff->getRemovedColumns() as $column) {
            $ret .= $this->getRemoveColumnDDL($column);
        }

        // add new indices and foreign keys
        if ($tableDiff->hasModifiedPk()) {
            $ret .= $this->getAddPrimaryKeyDDL($tableDiff->getToTable());
        }
        foreach ($tableDiff->getModifiedIndices() as $indexName => $indexModification) {
            list($fromIndex, $toIndex) = $indexModification;
            $ret .= $this->getAddIndexDDL($toIndex);
        }
        foreach ($tableDiff->getAddedIndices() as $index) {
            $ret .= $this->getAddIndexDDL($index);
        }
        foreach ($tableDiff->getModifiedFks() as $fkName => $fkModification) {
            list($fromFk, $toFk) = $fkModification;
            $ret .= $this->getAddForeignKeyDDL($toFk);
        }
        foreach ($tableDiff->getAddedFks() as $fk) {
            $ret .= $this->getAddForeignKeyDDL($fk);
        }

        return $ret;
    }