Property to provide instance of HPEAccountCollection
19647
def accounts(self):
        """"""
        return account.HPEAccountCollection(
            self._conn, utils.get_subresource_path_by(self, 'Accounts'),
            redfish_version=self.redfish_version)
258579
private void countPropertyReference(PropertyIdValue property, int count) {
		PropertyRecord propertyRecord = getPropertyRecord(property);
		propertyRecord.referenceCount = propertyRecord.referenceCount + count;
	}
1096772
public <A, E extends SimpleExpression<A>> CollectionPath<A, E> getCollection(String property, Class<A> type, Class<? super E> queryType) {
        validate(property, Collection.class);
        return super.createCollection(property, type, queryType, PathInits.DIRECT);
    }
938032
public Object getObjectInstance(Object object, Name name, Context context, Hashtable<?, ?> table) throws Exception {

		Reference ref = (Reference) object;
		Enumeration<RefAddr> addrs = ref.getAll();
		Properties props = new Properties();
		while (addrs.hasMoreElements()) {
			RefAddr addr = addrs.nextElement();
			if (addr.getType().equals("driverClassName")){
				Class.forName((String) addr.getContent());
			} else {
				props.put(addr.getType(), addr.getContent());
			}
		}		
		BoneCPConfig config = new BoneCPConfig(props);

		return new BoneCPDataSource(config);
	}
1336390
function getNeighbor(owner, item, dataPropertyName) {
	const data = validateAttached(owner)
	return obtainTrueValue(item[data[dataPropertyName]])
}
875132
private Object addOrUpdateCollectionEntry(AtlasVertex instanceVertex, AttributeInfo attributeInfo,
                                              IDataType elementType, Object newAttributeValue, Object currentValue,
                                              String propertyName, Operation operation)
            throws AtlasException {

        switch (elementType.getTypeCategory()) {
        case PRIMITIVE:
        case ENUM:
            return newAttributeValue != null ? newAttributeValue : null;

        case ARRAY:
        case MAP:
        case TRAIT:
            // do nothing
            return null;

        case STRUCT:
        case CLASS:
            final String edgeLabel = GraphHelper.EDGE_LABEL_PREFIX + propertyName;
            return addOrUpdateReference(instanceVertex, attributeInfo, elementType, newAttributeValue, (AtlasEdge)currentValue,
                    edgeLabel, operation);

        default:
            throw new IllegalArgumentException("Unknown type category: " + elementType.getTypeCategory());
        }
    }
307023
@ManyToOne(targetEntity = org.openprovenance.prov.sql.QualifiedName.class, cascade = {
        CascadeType.ALL
    })
    @JoinColumn(name = "COLLECTION")
    public org.openprovenance.prov.model.QualifiedName getCollection() {
        return collection;
    }
130397
public static <N> HCounterColumn<N> createCounterColumn(N name, long value, Serializer<N> nameSerializer) {
    return new HCounterColumnImpl<N>(name, value, nameSerializer);
  }
166515
function (connectionName, collectionName, obj, cb) {
        if (_.isObject(obj)) {
            try {
                var modelInstance = new this._model(obj);
                return cb(null, modelInstance);
            }
            catch (err) {
                return cb(err, null);
            }
        }
    }
338868
function PropertyReference(parentReference, propertyKey) {
      _classCallCheck(this, PropertyReference);

      _CachedReference.call(this);

      var parentReferenceTag = parentReference.tag;
      var parentObjectTag = new _glimmerReference.UpdatableTag(_glimmerReference.CURRENT_TAG);

      this.tag = _glimmerReference.combine([parentReferenceTag, parentObjectTag]);
      this._parentReference = parentReference;
      this._parentObjectTag = parentObjectTag;
      this._propertyKey = propertyKey;
    }
140788
@Override
    public Object setEL(PageContext pc, Collection.Key name, Object value) {
	try {
	    return set(pc, name, value);
	}
	catch (PageException e) {
	    return null;
	}
    }
1335723
public <A> CollectionPath<A, PathBuilder<A>> getCollection(String property, Class<A> type) {
        return this.<A, PathBuilder<A>>getCollection(property, type, PathBuilder.class);
    }
473655
@Override
    public Object setEL(PageContext pc, Collection.Key propertyName, Object value) {
	return setEL(propertyName, value);
    }
275219
@Override
  public boolean provablyNotInstanceOf(KbCollection col, Context ctx) {
    return wrapped().provablyNotInstanceOf(col, ctx);
  }
808560
protected void associateBatched(Collection owners, Collection children)
    {
        ObjectReferenceDescriptor ord = getObjectReferenceDescriptor();
        ClassDescriptor cld = getOwnerClassDescriptor();
        Object owner;
        Object relatedObject;
        Object fkValues[];
        Identity id;
        PersistenceBroker pb = getBroker();
        PersistentField field = ord.getPersistentField();
        Class topLevelClass = pb.getTopLevelClass(ord.getItemClass());
        HashMap childrenMap = new HashMap(children.size());


        for (Iterator it = children.iterator(); it.hasNext(); )
        {
            relatedObject = it.next();
            childrenMap.put(pb.serviceIdentity().buildIdentity(relatedObject), relatedObject);
        }

        for (Iterator it = owners.iterator(); it.hasNext(); )
        {
            owner = it.next();
            fkValues = ord.getForeignKeyValues(owner,cld);
            if (isNull(fkValues))
            {
                field.set(owner, null);
                continue;
            }
            id = pb.serviceIdentity().buildIdentity(null, topLevelClass, fkValues);
            relatedObject = childrenMap.get(id);
            field.set(owner, relatedObject);
        }
    }
403038
function ObjectCollection(parent) {
    tr.model.EventContainer.call(this);
    this.parent = parent;
    this.instanceMapsById_ = {}; // id -> TimeToObjectInstanceMap
    this.instancesByTypeName_ = {};
    this.createObjectInstance_ = this.createObjectInstance_.bind(this);
  }
153886
@Override
  public boolean isInstanceOf(KbCollection collection, Context context) {
    return wrapped().isInstanceOf(collection, context);
  }