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

@param entityTypeName
allowed object is {@link String}

@return
returned object is {@link List}
543995
public static synchronized List getPropertyNames(String entityTypeName) {
        if (propertyNames != null) {
            return propertyNames;
        } else {
            {
                List names = new ArrayList();
                names.add(PROP_PRINCIPAL_NAME);
                names.add(PROP_PASSWORD);
                names.add(PROP_REALM);
                names.add(PROP_CERTIFICATE);
                names.addAll(Party.getPropertyNames("Party"));
                propertyNames = Collections.unmodifiableList(names);
                return propertyNames;
            }
        }
    }
466728
public List<EjbRefType<ApplicationType<T>>> getAllEjbRef()
   {
      List<EjbRefType<ApplicationType<T>>> list = new ArrayList<EjbRefType<ApplicationType<T>>>();
      List<Node> nodeList = childNode.get("ejb-ref");
      for(Node node: nodeList)
      {
         EjbRefType<ApplicationType<T>>  type = new EjbRefTypeImpl<ApplicationType<T>>(this, "ejb-ref", childNode, node);
         list.add(type);
      }
      return list;
   }
73505
public static Class<?> toIdType(EntityType entityType) {
    AttributeType attributeType = entityType.getIdAttribute().getDataType();
    //noinspection EnumSwitchStatementWhichMissesCases
    switch (attributeType) {
      case EMAIL:
      case HYPERLINK:
      case STRING:
        return String.class;
      case INT:
        return Integer.class;
      case LONG:
        return Long.class;
      default:
        throw new UnexpectedEnumException(attributeType);
    }
  }
376149
private List<ModelProperty> propertiesFor(ResolvedType type, ModelContext givenContext, String namePrefix) {
    Set<ModelProperty> properties = new TreeSet<>(byPropertyName());
    BeanDescription beanDescription = beanDescription(type, givenContext);
    Map<String, BeanPropertyDefinition> propertyLookup = beanDescription.findProperties().stream().collect(toMap(
        beanPropertyByInternalName(), identity()));
    for (Map.Entry<String, BeanPropertyDefinition> each : propertyLookup.entrySet()) {
      LOG.debug("Reading property {}", each.getKey());
      BeanPropertyDefinition jacksonProperty = each.getValue();
      Optional<AnnotatedMember> annotatedMember
          = ofNullable(safeGetPrimaryMember(jacksonProperty, givenContext));
      annotatedMember.ifPresent(
          member -> properties.addAll(
              candidateProperties(
                  type,
                  member,
                  jacksonProperty,
                  givenContext,
                  namePrefix)));
    }
    return new ArrayList<>(properties);
  }
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);
  }
911227
public List<PropertyType<ValidationConfigurationDescriptor>> getAllProperty()
   {
      List<PropertyType<ValidationConfigurationDescriptor>> list = new ArrayList<PropertyType<ValidationConfigurationDescriptor>>();
      List<Node> nodeList = model.get("property");
      for(Node node: nodeList)
      {
         PropertyType<ValidationConfigurationDescriptor>  type = new PropertyTypeImpl<ValidationConfigurationDescriptor>(this, "property", model, node);
         list.add(type);
      }
      return list;
   }
69421
public List<ModelServiceInstance> getModelInstancesByMetadataKey(String keyName){
        ModelMetadataKey key = getModelMetadataKey(keyName);
        if(key == null || key.getServiceInstances().isEmpty()){
            return Collections.<ModelServiceInstance>emptyList();
        }else{
            return new ArrayList<ModelServiceInstance>(key.getServiceInstances());
        }
    }
167911
public static List<String> getPropNameList(final Class<?> cls) {
        List<String> propNameList = entityDeclaredPropNameListPool.get(cls);

        if (propNameList == null) {
            loadPropGetSetMethodList(cls);
            propNameList = entityDeclaredPropNameListPool.get(cls);
        }

        return propNameList;
    }
190827
public List<Series> retrieveMetricSeries(String metricName, String entityName) {
        return retrieveMetricSeries(metricName, Collections.singletonMap("entity", entityName));
    }
1206784
@GetMapping(value = "/{entityTypeId}/meta", produces = APPLICATION_JSON_VALUE)
  public EntityTypeResponse retrieveEntityType(
      @PathVariable("entityTypeId") String entityTypeId,
      @RequestParam(value = "attributes", required = false) String[] attributes,
      @RequestParam(value = "expand", required = false) String[] attributeExpands) {
    Set<String> attributeSet = toAttributeSet(attributes);
    Map<String, Set<String>> attributeExpandSet = toExpandMap(attributeExpands);

    EntityType meta = dataService.getEntityType(entityTypeId);
    return new EntityTypeResponse(
        meta, attributeSet, attributeExpandSet, permissionService, dataService);
  }
476528
protected final boolean entityExists(final String entityName) {
        final Set<EntityType<?>> entityTypes = getEm().getMetamodel().getEntities();
        for (final EntityType<?> entityType : entityTypes) {
            if (entityType.getName().equals(entityName)) {
                return true;
            }
        }
        return false;
    }
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;
	}
139384
public Set<InternalQName> getSubtypes(final InternalQName nodeTypeName)
   {
      Set<InternalQName> resultSet = new HashSet<InternalQName>();
      for (InternalQName ntName : nodeTypes.keySet())
      {
         if (getSupertypes(ntName).contains(nodeTypeName))
         {
            resultSet.add(ntName);
         }
      }
      return resultSet;
   }
1296974
public static List<EntityField> getAll(Class<?> entityClass) {
        List<EntityField> fields = fieldHelper.getFields(entityClass);
        List<EntityField> properties = fieldHelper.getProperties(entityClass);
        //拼到一起，名字相同的合并
        List<EntityField> all = new ArrayList<EntityField>();
        Set<EntityField> usedSet = new HashSet<EntityField>();
        for (EntityField field : fields) {
            for (EntityField property : properties) {
                if (!usedSet.contains(property) && field.getName().equals(property.getName())) {
                    field.copyFromPropertyDescriptor(property);
                    usedSet.add(property);
                    break;
                }
            }
            all.add(field);
        }
        for (EntityField property : properties) {
            if (!usedSet.contains(property)) {
                all.add(property);
            }
        }
        return all;
    }
429482
def properties_for_entity(entity_name)
      type_definition = metadata.xpath("//EntityType[@Name='#{entity_name}']").first
      raise ArgumentError, "Unknown EntityType: #{entity_name}" if type_definition.nil?
      properties_to_return = {}
      type_definition.xpath('./Property').each do |property_xml|
        property_name, property = process_property_from_xml(property_xml)
        properties_to_return[property_name] = property
      end
      properties_to_return
    end
143493
private Properties getGlobalLoginBasicProps() throws Exception {
        String realm = getWebAppSecurityConfig().getBasicAuthRealmName();
        Properties props = new Properties();
        if (realm == null) {
            if (tc.isDebugEnabled()) {
                Tr.debug(tc, "basicAuthenticationMechanismRealmName is not set. the default value " + JavaEESecConstants.DEFAULT_REALM + " is used.");
            }
        } else {
            if (tc.isDebugEnabled()) {
                Tr.debug(tc, "The container provided BasicAuthenticationMechanism will be used with the realm name  : " + realm);
            }
            props.put(JavaEESecConstants.REALM_NAME, realm);
        }
        return props;
    }