Get the list of properties and their various options for the supplied
 Entity name.
 @param entity_name [to_s]
 @return [Hash]
 @api private
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
840510
def get_title_property_name(entity_name)
      node = metadata.xpath("//EntityType[@Name='#{entity_name}']/Property[@FC_TargetPath='SyndicationTitle']").first
      node.nil? ? nil : node.attributes['Name'].value
    end
564120
public function get($property_name) {
    if ($property_name === 'entity' && !isset($this->values[$property_name])) {
      $value = $this->values[$property_name] = SKU::loadFromSku($this->values['value'], $this->getLangcode());
      $this->properties[$property_name] = $this->getTypedDataManager()->getPropertyInstance($this, $property_name, $value);
    }
    return parent::get($property_name);
  }
948172
def entity_schema
      @entity_schema ||= begin
        if superclass.respond_to?(:entity_schema)
          superschema = superclass.entity_schema

          unless superschema.is_a?(Schema)
            raise Exception, "class-level method `#{superclass}.entity_schema` is required " \
                              'by gem "entity_schema" and must return instance of ' \
                              "`#{Schema}`, but returns a `#{superschema.class}`"
          end

          Schema.new(owner_name: to_s, extends: superschema)
        else
          Schema.new(owner_name: to_s)
        end
      end
    end
184978
def list_entity_types(namespace, workspace):
    
    headers = _fiss_agent_header({"Content-type":  "application/json"})
    uri = "workspaces/{0}/{1}/entities".format(namespace, workspace)
    return __get(uri, headers=headers)
112978
def build(properties = {})
      entity = self.class.entity_class.new(:session => session)

      entity.update_properties(properties)
      entity.partial = false

      append(entity)
      initialize_properties_with_values_from_owner(entity)

      entity
    end
802245
def get_spaces(self):
        
        self.spaces = []
        for resource in self._get_spaces()['resources']:
            self.spaces.append(resource['entity']['name'])

        return self.spaces
1272867
def extract_entity(found):
    """"""
    obj = dict()
    for prop in found.entity.property:
        obj[prop.name] = prop.value.string_value
    return obj
1185530
def get_entity_names(self, data):
        """"""
        entities = self._filter_queryset('view_entity', data.entity_set.all())
        return list(entities.values_list('name', flat=True))
1204009
def _extract_tag_value(self, entity, tag_name):
        
        if tag_name not in TAG_EXTRACTORS:
            self.warning("{0} isn't a supported tag".format(tag_name))
            return

        # Check for already extracted tags
        if "_tag_values" not in entity:
            entity["_tag_values"] = {}

        if tag_name not in entity["_tag_values"]:
            entity["_tag_values"][tag_name] = TAG_EXTRACTORS[tag_name](entity)

        return entity["_tag_values"][tag_name]
1222145
public static Map<String, Object> getKeyPropertyValues(EntityType entityType, Object entity) {
        Map<String, Object> keyPropertyValues = new HashMap<>();
        for (PropertyRef propertyRef : entityType.getKey().getPropertyRefs()) {
            String propertyName = propertyRef.getPath();
            Object propertyValue = getPropertyValue(entityType.getStructuralProperty(propertyName), entity);
            keyPropertyValues.put(propertyName, propertyValue);
        }
        return keyPropertyValues;
    }
90075
def get_base_attributes(entity):
    
    attributes = {}
    cls = entity.__class__
    for attr, _ in inspect.getmembers(cls, lambda o: not isinstance(o, property) and not inspect.isroutine(o)):
        if not attr.startswith("_"):
            attributes[attr] = getattr(entity, attr)
    return attributes
760521
public final String getNameAndMeta(ResourceBundle rb, ParserProperties properties) {
    	String str = option.isArgument() ? "" : option.toString();
    	String meta = getMetaVariable(rb);
    	if (meta != null) {
    		if (str.length() > 0) {
    			str += properties.getOptionValueDelimiter();
    		}
    		str += meta;
    	}
    	return str;
    }
260574
def get_entity_loaded_propnames(entity):
    
    ins = inspect(entity)
    keynames = get_entity_propnames(ins)

    # If the entity is not transient -- exclude unloaded keys
    # Transient entities won't load these anyway, so it's safe to include all columns and get defaults
    if not ins.transient:
        keynames -= ins.unloaded

    # If the entity is expired -- reload expired attributes as well
    # Expired attributes are usually unloaded as well!
    if ins.expired:
        keynames |= ins.expired_attributes

    # Finish
    return keynames
477740
def get_data(handle)
      handle = Entity::Handle.new(handle)
      entity_hash = request(:get_data, "entityHandle" => handle.to_hash)
      entity_hash
    end
657266
def to_s
      props = {
        property: property,
        type: type,
        status: status,
        section: section
      }
      "DataCriteria#{props}"
    end
1140483
def [](k)
      if RESERVED_FIELDS.include? k.to_sym
        super
      else
        r = attributes.find {|a| a.key.to_s == k.to_s }.value
      end
    end