Gets a list of all supported properties for this model object, <b>Locality</b>

@param entityTypeName
allowed object is {@link String}

@return
returned object is {@link List}
175110
public static synchronized List getPropertyNames(String entityTypeName) {
        if (propertyNames != null) {
            return propertyNames;
        } else {
            {
                List names = new ArrayList();
                names.add(PROP_L);
                names.add(PROP_LOCALITY_NAME);
                names.add(PROP_ST);
                names.add(PROP_STATE_OR_PROVINCE_NAME);
                names.add(PROP_STREET);
                names.add(PROP_SEE_ALSO);
                names.add(PROP_DESCRIPTION);
                names.addAll(GeographicLocation.getPropertyNames("GeographicLocation"));
                propertyNames = Collections.unmodifiableList(names);
                return propertyNames;
            }
        }
    }
650394
public List<Map<String, Object>> listCorpusStats(File databaseProperties)
  {
    List<Map<String, Object>> result = new LinkedList<>();

    DataSource origDataSource = getDataSource().getInnerDataSource();
    try
    {
      if (databaseProperties != null)
      {
        getDataSource().setInnerDataSource(createDataSource(databaseProperties));
      }
      result = getJdbcTemplate().queryForList(
        "SELECT * FROM corpus_info ORDER BY name");
    }
    catch (IOException | URISyntaxException | DataAccessException ex)
    {
      if (databaseProperties == null)
      {
        log.error("Could not query corpus list", ex);
      }
      else
      {
        log.error(
          "Could not query corpus list for the file " + databaseProperties.
          getAbsolutePath(), ex);
      }
    }
    finally
    {
      getDataSource().setInnerDataSource(origDataSource);
    }
    return result;
  }
763592
public <T extends ApiObject> EntityList<T> get(Request<T> request)
    {
        return executeRequest(request,objectMapper.getTypeFactory()
                .constructParametrizedType(EntityList.class,EntityList.class, request.getEntityType()));
    }
840890
@Override
	public Set<PropertyKey> getPropertyKeys(final String propertyView) {

		// check for custom view in content-type field
		if (securityContext != null && securityContext.hasCustomView()) {

			final Set<PropertyKey> keys = new LinkedHashSet<>(StructrApp.getConfiguration().getPropertySet(entityType, PropertyView.All));
			final Set<String> customView = securityContext.getCustomView();

			for (Iterator<PropertyKey> it = keys.iterator(); it.hasNext();) {
				if (!customView.contains(it.next().jsonName())) {

					it.remove();
				}
			}

			return keys;
		}

		// this is the default if no application/json; properties=[...] content-type header is present on the request
		return StructrApp.getConfiguration().getPropertySet(entityType, propertyView);
	}
1088141
private Optional<String> tryGetEntityTypeName(String tableName) {
    EntityTypeDescription entityTypeDescription =
        entityTypeRegistry.getEntityTypeDescription(tableName);
    String entityTypeId = entityTypeDescription != null ? entityTypeDescription.getId() : null;
    return Optional.ofNullable(entityTypeId);
  }
1263796
@SuppressWarnings("unchecked")
    public final <C extends T> PropertyList<C> getProperties(final String name) {
        final PropertyList<C> list = new PropertyList<C>();
        for (final T p : this) {
            if (p.getName().equalsIgnoreCase(name)) {
                list.add((C) p);
            }
        }
        return list;
    }
761586
protected Set<EntityPropertyInfo> getSuperclassEntityPropertyInfo() {
    Set<EntityPropertyInfo> results = new HashSet<EntityPropertyInfo>();
    if (superclass == null) {
      return results;
    }
    for (Class<?> clazz = superclass; clazz != Object.class; clazz = clazz.getSuperclass()) {
      Entity entity = clazz.getAnnotation(Entity.class);
      if (entity == null) {
        continue;
      }
      org.seasar.doma.jdbc.entity.NamingType namingType = entity.naming();
      for (Field field : clazz.getDeclaredFields()) {
        int m = field.getModifiers();
        if (Modifier.isStatic(m)) {
          continue;
        }
        if (field.isAnnotationPresent(Transient.class)) {
          continue;
        }
        EntityPropertyInfo propertyInfo = new EntityPropertyInfo();
        propertyInfo.entityClass = clazz;
        propertyInfo.propertyField = field;
        Column column = field.getAnnotation(Column.class);
        propertyInfo.column = column;
        if (column == null || column.name().isEmpty()) {
          propertyInfo.columnName = namingType.apply(field.getName()).toLowerCase();
        } else {
          propertyInfo.columnName = column.name();
        }
        propertyInfo.id = field.getAnnotation(Id.class);
        propertyInfo.generatedValue = field.getAnnotation(GeneratedValue.class);
        propertyInfo.sequenceGenerator = field.getAnnotation(SequenceGenerator.class);
        propertyInfo.tableGenerator = field.getAnnotation(TableGenerator.class);
        propertyInfo.version = field.getAnnotation(Version.class);
        results.add(propertyInfo);
      }
    }
    return results;
  }
1036124
@PostMapping(
      value = "/{entityTypeId}/{id}/{refAttributeName}",
      params = "_method=GET",
      produces = APPLICATION_JSON_VALUE)
  public Object retrieveEntityAttributePost(
      @PathVariable("entityTypeId") String entityTypeId,
      @PathVariable("id") String untypedId,
      @PathVariable("refAttributeName") String refAttributeName,
      @Valid @RequestBody EntityCollectionRequest request) {
    Set<String> attributesSet = toAttributeSet(request.getAttributes());
    Map<String, Set<String>> attributeExpandSet = toExpandMap(request.getExpand());

    return retrieveEntityAttributeInternal(
        entityTypeId, untypedId, refAttributeName, request, attributesSet, attributeExpandSet);
  }
973907
public Finder<SQLProperty> getEntityBySimpleName(String entityName) {
		if (entityName == null)
			return null;

		SQLiteEntity result = entitiesBySimpleName.get(entityName.toLowerCase());
		if (result != null)
			return result;

		for (GeneratedTypeElement item : this.generatedEntities) {
			if (item.typeSpec.name.toLowerCase().equals(entityName.toLowerCase())) {
				return item;
			}
		}

		return null;
	}
478113
public Object get(Object propertyName) {
        if (propertyName instanceof CharSequence) {
            propertyName = propertyName.toString();
        }

        if (propertyName instanceof List) {
            Map submap = new HashMap();
            List propertyNames = (List)propertyName;
            for (Object currentName : propertyNames) {
                if (currentName != null) {
                    currentName = currentName.toString();
                    if (containsKey(currentName)) {
                        submap.put(currentName, get(currentName));
                    }
                }
            }
            return submap;
        }

        if (NameUtils.isConfigurational(propertyName.toString())) {
            return null;
        }

        Object val = null;
        MetaProperty mp = metaClass.getMetaProperty(propertyName.toString());
        if (mp != null) {
            val = mp.getProperty(instance);
        }
        return val;
    }
159194
@RequestMapping(value = "{entityType}/{id}", method = RequestMethod.GET)
    public Resources<Resource<Property<?>>> getProperties(@PathVariable ProjectEntityType entityType, @PathVariable ID id) {
        ProjectEntity entity = getEntity(entityType, id);
        List<Property<?>> properties = propertyService.getProperties(entity);
        List<Resource<Property<?>>> resources = new ArrayList<>();
        for (Property<?> property : properties) {
            Resource<Property<?>> resource = Resource.of(
                    property,
                    uri(on(getClass()).getPropertyValue(entity.getProjectEntityType(), entity.getId(), property.getType().getClass().getName()))
            );
            // Update
            resource = resource.with(
                    Link.UPDATE,
                    uri(on(getClass()).getPropertyEditionForm(entity.getProjectEntityType(), entity.getId(), property.getType().getClass().getName())));
            // OK
            resources.add(resource);
        }
        return Resources.of(
                resources,
                uri(on(getClass()).getProperties(entityType, id))
        );
    }
270895
public List<SQLProperty> getForeignKeysToEntity(SQLiteEntity entity, String fieldName) {
		List<SQLProperty> result = new ArrayList<>();
		if (StringUtils.hasText(fieldName)) {
			for (SQLProperty item : this.collection) {
				if (item.isForeignKey() && entity.getName().equals(item.foreignParentClassName)
						&& item.getName().equals(fieldName)) {
					result.add(item);
				}
			}
		} else {
			for (SQLProperty item : this.collection) {
				if (item.isForeignKey() && entity.getName().equals(item.foreignParentClassName)) {
					result.add(item);
				}
			}
		}
		return result;
	}
648280
@SuppressWarnings("unchecked")
    public <T> List<T> getAll(Class<T> entityCls) {
        if (entityCls == null) {
            throw new IllegalArgumentException("entityCls cannot be null");
        }
        EntityManager entityManager = this.entityManagerProvider.get();
        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
        CriteriaQuery<T> criteriaQuery
                = builder.createQuery(entityCls);
        criteriaQuery.from(entityCls);
        TypedQuery<T> typedQuery
                = entityManager.createQuery(criteriaQuery);
        List<T> results = typedQuery.getResultList();
        return results;
    }
855575
@RequestMapping(value = "{entityType}/{id}", method = RequestMethod.GET)
    public Callable<Resources<Decoration<?>>> getDecorations(@PathVariable ProjectEntityType entityType, @PathVariable ID id) {
        // Gets the current request attributes
        RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
        return () -> {
            RequestContextHolder.setRequestAttributes(attributes);
            try {
                return Resources.of(
                        decorationService.getDecorations(getEntity(entityType, id)),
                        uri(on(getClass()).getDecorations(entityType, id))
                ).forView(Decoration.class);
            } finally {
                RequestContextHolder.resetRequestAttributes();
            }
        };
    }
806460
public Map<String, Object> getApplicationProperties(Map<String, Object> properties)
    {
        if (properties == null)
            return null;
        Map<String, Object> propApp = new Hashtable<String,Object>();
        if (properties.get(DBParams.LANGUAGE) != null)
            propApp.put(DBParams.LANGUAGE, properties.get(DBParams.LANGUAGE));
        if (properties.get(DBParams.DOMAIN) != null)
            propApp.put(DBParams.DOMAIN, properties.get(DBParams.DOMAIN));
        return propApp;
    }
1187273
public static String whereAllIfColumns(Class<?> entityClass, String entityName, boolean useVersion) {
        StringBuilder sql = new StringBuilder();
        sql.append("<where>");
        //获取全部列
        Set<EntityColumn> columnList = EntityHelper.getColumns(entityClass);
        //当某个列有主键策略时，不需要考虑他的属性是否为空，因为如果为空，一定会根据主键策略给他生成一个值
        for (EntityColumn column : columnList) {
            if (!useVersion || !column.getEntityField().isAnnotationPresent(Version.class)) {
                sql.append(SqlHelper.getIfNotNull(entityName,column, " AND " + column.getColumnEqualsHolder(entityName), false));
            }
        }
        if (useVersion) {
            sql.append(SqlHelper.whereVersion(entityClass));
        }
        sql.append("</where>");
        return sql.toString();
    }
1304166
public Map<String, EmbeddableType> getEmbeddables(Class clazz)
    {
        Map<String, EmbeddableType> embeddableAttibutes = new HashMap<String, EmbeddableType>();

        if (entityTypes != null)
        {
            EntityType entity = entityTypes.get(clazz);
            Iterator<Attribute> iter = entity.getAttributes().iterator();
            while (iter.hasNext())
            {
                Attribute attribute = iter.next();
                if (isEmbeddable(((AbstractAttribute) attribute).getBindableJavaType()))
                {
                    embeddableAttibutes.put(attribute.getName(),
                            embeddable(((AbstractAttribute) attribute).getBindableJavaType()));
                }
            }
        }
        return embeddableAttibutes;
    }