Return a list of all object IDs of all persistend objects that this Hash
 is referencing.
 @return [Array of Integer] IDs of referenced objects
15994
def _referenced_object_ids
      @data.each_value.select { |v| v && v.respond_to?(:is_poxreference?) }.
        map { |o| o.id }
    end
715722
def keys
      @hash.deep.each_with_object([]) do |(key_path, value), result|
        result << key_path.to_key_path unless value.is_a?(Hash)
      end
    end
381698
def by_hash_ids(*args)
      cmd_options = args.last.kind_of?(Hash) ? args.last : {}
      
      if args.size == 1 && args.first.kind_of?(Array)
        array = args.first
      else
        array = args
      end      
      return [] if array.empty?

      args = array.map{|hash| " -r#{ hash }"}
      hg_to_array ["log#{ args.join('') } --style ?", style], {:separator => changeset_separator}, cmd_options do |line|
        build(line)
      end
    end
147916
public static function getAllPersistedAttributes() {
    $calledClass = get_called_class();

    if (array_key_exists($calledClass, self::$allPersisted)) {
      return self::$allPersisted[$calledClass];
    } else {
      $persisted = [];
      if(property_exists($calledClass, 'persisted')) {
        $persisted  = $calledClass::$persisted;
      }
      $parent = get_parent_class($calledClass);
      if (method_exists($parent, 'getAllPersistedAttributes')) {
        $persisted = array_merge($persisted, $parent::getAllPersistedAttributes());
      }
    }
    self::$allPersisted[$calledClass] = $persisted;
    return self::$allPersisted[$calledClass];
  }
683889
def C_FindObjects(max_count)
      objs = @pk.C_FindObjects(@sess, max_count)
      objs.map{|obj| Object.new @pk, @sess, obj }
    end
1075089
public List<PersistenceUnit<Persistence<T>>> getAllPersistenceUnit()
   {
      List<PersistenceUnit<Persistence<T>>> list = new ArrayList<PersistenceUnit<Persistence<T>>>();
      List<Node> nodeList = childNode.get("persistence-unit");
      for(Node node: nodeList)
      {
         PersistenceUnit<Persistence<T>>  type = new PersistenceUnitImpl<Persistence<T>>(this, "persistence-unit", childNode, node);
         list.add(type);
      }
      return list;
   }
1108926
def find_all_hash(options = {})
      options.assert_valid_keys(:request_level)
      level = find_level(options[:request_level])

      query = self
      level.scope_field.each do |s, args|
        query = args.nil? ? query.send(s) : query = query.send(s, *args)
      end

      records = query.all(:select => level.select_field.join(', '), :include => level.include_field)
      records.map { |r| level.receive(r) }
    end
1133116
public List<PersistenceContextRefType<ApplicationDescriptor>> getAllPersistenceContextRef()
   {
      List<PersistenceContextRefType<ApplicationDescriptor>> list = new ArrayList<PersistenceContextRefType<ApplicationDescriptor>>();
      List<Node> nodeList = model.get("persistence-context-ref");
      for(Node node: nodeList)
      {
         PersistenceContextRefType<ApplicationDescriptor>  type = new PersistenceContextRefTypeImpl<ApplicationDescriptor>(this, "persistence-context-ref", model, node);
         list.add(type);
      }
      return list;
   }
621483
def habtm_assoc_ids(habtm_assoc)
      current = @record.send(habtm_assoc.name).to_a.map(&:id) # TODO: `pluck` would use less memory
      removed = @record.paper_trail_habtm.try(:[], habtm_assoc.name).try(:[], :removed) || []
      added = @record.paper_trail_habtm.try(:[], habtm_assoc.name).try(:[], :added) || []
      current + removed - added
    end
689152
def get_es_object_ids(self, objects):
        
        id_field = self.clean_id_name
        ids = [getattr(obj, id_field, obj) for obj in objects]
        return list(set(str(id_) for id_ in ids))
1366131
def attributes
      fields.each_with_object(HashWithIndifferentAccess.new) do |field, acc|
        acc[field.alias] = field.value
      end
    end
1343867
def GetHashers(cls, hasher_names):
    
    hashers = []
    for hasher_name, hasher_class in iter(cls._hasher_classes.items()):
      if hasher_name in hasher_names:
        hashers.append(hasher_class())

    return hashers
454809
function getAllReferences() {
  return _.reduce(
    this.getInheritanceChain(),
    (acc, cls) => _.reduce(cls.references, (acc2, v, k) => {acc2[k] = v; return acc2}, acc),
    {})
}
856047
private Iterable<PersistentNoSqlIdentifierGenerator> getPersistentGenerators() {
		Map<String, EntityPersister> entityPersisters = factory.getMetamodel().entityPersisters();

		Set<PersistentNoSqlIdentifierGenerator> persistentGenerators = new HashSet<PersistentNoSqlIdentifierGenerator>( entityPersisters.size() );
		for ( EntityPersister persister : entityPersisters.values() ) {
			if ( persister.getIdentifierGenerator() instanceof PersistentNoSqlIdentifierGenerator ) {
				persistentGenerators.add( (PersistentNoSqlIdentifierGenerator) persister.getIdentifierGenerator() );
			}
		}

		return persistentGenerators;
	}
180926
def persistentValues(self):
        
        return dict((k, getattr(self, k)) for (k, attr) in self.getSchema())
282607
public List<PersistenceUnit<PersistenceDescriptor>> getAllPersistenceUnit()
   {
      List<PersistenceUnit<PersistenceDescriptor>> list = new ArrayList<PersistenceUnit<PersistenceDescriptor>>();
      List<Node> nodeList = model.get("persistence-unit");
      for(Node node: nodeList)
      {
         PersistenceUnit<PersistenceDescriptor>  type = new PersistenceUnitImpl<PersistenceDescriptor>(this, "persistence-unit", model, node);
         list.add(type);
      }
      return list;
   }
1095611
def component ref
    self.all_series.collect { |c| c if c.persistentId == ref }.compact.first
  end