public List<? extends ResultType> checkCache(KeyType key) throws NotCachedException { List<EntityType> oldItems = mapper.queryExisting(key); if (oldItems.isEmpty()) throw new NotCachedException(); long now = System.currentTimeMillis(); boolean outdated = false; boolean haveNoResultsMarker = false; for (EntityType d : oldItems) { if ((d.getLastUpdated().getTime() + getExpirationTime()) < now) { outdated = true; } if (d.isNoResultsMarker()) { haveNoResultsMarker = true; } } if (outdated) { logger.debug("Cache appears outdated for key {}", key); throw new ExpiredCacheException(); } if (haveNoResultsMarker) { logger.debug("Negative result cached for key {}", key); return Collections.emptyList(); } sort(oldItems); return formResultTypeList(oldItems); }
private void introspectSecondaryTable(EntityType entityType, Class type) { getInternalSecondaryTableConfig(type, _annotationCfg); SecondaryTable secondaryTableAnn = (SecondaryTable) _annotationCfg.getAnnotation(); SecondaryTableConfig secondaryTableConfig = _annotationCfg.getSecondaryTableConfig(); AmberTable secondaryTable = null; if ((secondaryTableAnn != null) || (secondaryTableConfig != null)) { String secondaryName; if (secondaryTableAnn != null) secondaryName = secondaryTableAnn.name(); else secondaryName = secondaryTableConfig.getName(); secondaryTable = _persistenceUnit.createTable(secondaryName); entityType.addSecondaryTable(secondaryTable); // XXX: pk } if (secondaryTableAnn != null) { PrimaryKeyJoinColumn[] joinAnn = secondaryTableAnn.pkJoinColumns(); linkSecondaryTable(entityType.getTable(), secondaryTable, joinAnn); } }
private void addCollection(AmberType targetType) { ElementCollectionField eltCollectionField; eltCollectionField = new ElementCollectionField(_sourceType, _fieldName); eltCollectionField.setType(targetType); eltCollectionField.setLazy(isFetchLazy()); CollectionTableConfig collectionTableConfig = _collectionTable; AmberPersistenceUnit persistenceUnit = _sourceType.getPersistenceUnit(); String sqlTable = collectionTableConfig.getName(); AmberTable mapTable = persistenceUnit.createTable(sqlTable); HashMap<String, JoinColumnConfig> joinColumnsConfig = collectionTableConfig.getJoinColumnMap(); ArrayList<ForeignColumn> sourceColumns = null; sourceColumns = calculateColumns( _field, _fieldName, mapTable, _sourceType.getTable().getName() + "_", _sourceType, joinColumnsConfig); eltCollectionField.setAssociationTable(mapTable); eltCollectionField.setTable(sqlTable); eltCollectionField.setSourceLink( new LinkColumns(mapTable, _sourceType.getTable(), sourceColumns)); _sourceType.addField(eltCollectionField); }
void addWidgets() { widget( "EntityTypeList", WidgetType.EntityTypeSet, new PortRest("entity_type_item", EntityType.name())); widget("EntityTypeItem", EntityType, new PortRest("entity_type_page", EntityType.name())); widget("EntityTitle", EntityType); }
private void introspectTableCache(EntityType entityType, Class type) { AmberTableCache tableCache = (AmberTableCache) type.getAnnotation(AmberTableCache.class); if (tableCache != null) { entityType.getTable().setReadOnly(tableCache.readOnly()); long cacheTimeout = Period.toPeriod(tableCache.timeout()); entityType.getTable().setCacheTimeout(cacheTimeout); } }
private void serialize(Serializer serializer, Collection<EntityType> models) { for (EntityType model : models) { try { Type type = conf.getTypeMappings().getPathType(model, model, true); String packageName = type.getPackageName(); String className = !packageName.isEmpty() ? (packageName + "." + type.getSimpleName()) : type.getSimpleName(); // skip if type is excluded class or in excluded package if (conf.isExcludedPackage(model.getPackageName()) || conf.isExcludedClass(model.getFullName())) { continue; } Set<TypeElement> elements = context.typeElements.get(model.getFullName()); if (elements == null) { elements = new HashSet<TypeElement>(); } for (Property property : model.getProperties()) { if (property.getType().getCategory() == TypeCategory.CUSTOM) { Set<TypeElement> customElements = context.typeElements.get(property.getType().getFullName()); if (customElements != null) { elements.addAll(customElements); } } } processingEnv .getMessager() .printMessage(Kind.NOTE, "Generating " + className + " for " + elements); JavaFileObject fileObject = processingEnv .getFiler() .createSourceFile(className, elements.toArray(new Element[elements.size()])); Writer writer = fileObject.openWriter(); try { SerializerConfig serializerConfig = conf.getSerializerConfig(model); serializer.serialize(model, serializerConfig, new JavaWriter(writer)); } finally { if (writer != null) { writer.close(); } } } catch (IOException e) { System.err.println(e.getMessage()); processingEnv.getMessager().printMessage(Kind.ERROR, e.getMessage()); } } }
private void processProjectionTypes(Set<TypeElement> elements) { Set<Element> visited = new HashSet<Element>(); for (Element element : getElements(QueryProjection.class)) { Element parent = element.getEnclosingElement(); if (!elements.contains(parent) && !visited.contains(parent)) { EntityType model = elementHandler.handleProjectionType((TypeElement) parent); registerTypeElement(model.getFullName(), (TypeElement) parent); context.projectionTypes.put(model.getFullName(), model); visited.add(parent); } } }
private void addSupertypeFields(EntityType model, Set<EntityType> handled) { if (handled.add(model)) { for (Supertype supertype : model.getSuperTypes()) { EntityType entityType = context.allTypes.get(supertype.getType().getFullName()); if (entityType != null) { addSupertypeFields(entityType, handled); supertype.setEntityType(entityType); model.include(supertype); } } } }
private EntityType introspectEntityType(Class type, EntityType parentType) throws SQLException { getInternalEntityConfig(type, _annotationCfg); Entity entityAnn = (Entity) _annotationCfg.getAnnotation(); EntityConfig entityConfig = _annotationCfg.getEntityConfig(); boolean isEntity = !_annotationCfg.isNull(); if (!isEntity) return null; EntityType entityType; String typeName; if (entityConfig != null) typeName = entityConfig.getClassName(); else typeName = entityAnn.name(); // Validates the type String entityName; Inheritance inheritanceAnn = null; InheritanceConfig inheritanceConfig = null; Class rootClass = type; Entity rootEntityAnn = null; EntityConfig rootEntityConfig = null; validateType(type, true); // jpa/0ge2 // if (hasInheritance) { if (entityConfig == null) entityName = entityAnn.name(); else { entityName = entityConfig.getClassName(); int p = entityName.lastIndexOf('.'); if (p > 0) entityName = entityName.substring(p + 1); } if ((entityName == null) || "".equals(entityName)) { entityName = type.getSimpleName(); } entityType = _persistenceUnit.createEntity(entityName, type); _configManager.addType(type, new EntityConfig(type.getName(), this, entityType)); boolean isField = isField(type, entityConfig, false); if (isField) entityType.setFieldAccess(true); return entityType; }
public void process(RelationContainer container) { for (RelationMember member : container.getEntity().getMembers()) { EntityType memberType = member.getMemberType(); if (memberType.equals(EntityType.Way)) { requiredWays.set(member.getMemberId()); } else if (memberType.equals(EntityType.Node)) { requiredNodes.set(member.getMemberId()); } } allRelations.add(container); }
@Override void addWidgets() { widget("EntityTypeList", EntityTypeSet, new PortRest("entity_type_item", EntityType.name())); widget("EntityTypeItem", EntityType, new PortRest("entity_type_page", EntityType.name())); widget("EntityTitle2", EntityType, new PortRest("entity_list", EntityType.name())); widget("EntityOrderedList", EntityType, new PortRest("entity_item", Entity.name())); widget("EntityItem2", Entity, new PortRest("property_value", Property.name())); widget("SimpleValue", Property); widget("SimpleValue2", Property); widget("SimpleValue3", Property); widget("SimpleValue4", Property); widget("SimpleValue5", Property); }
@Override void addWidgets() { widget("EntityTypeList", EntityTypeSet, new PortRest("entity_type_item", EntityType.name())); widget("EntityTypeItem", EntityType, new PortRest("entity_type_page", EntityType.name())); widget( "ListingTable", EntityType, new PortRest("table_head", PropertyType.name()), new PortRest("table_line", Entity.name())); widget("TableHead", PropertyType); widget("TableLine", Entity, new PortRest("line_cell", Property.name())); widget("TableCell", Property); }
public static void checkEntityType(EntityType<?> entity) { // Check required fields assertNotNull(entity.getName(), String.format(NOT_NULL_OBJECT_FMT, "Name", "EntityType")); // Check optional fields // NOTE description cannot be checked Set<Task> tasks = entity.getTasks(); if (tasks != null && tasks != null && !tasks.isEmpty()) { for (Task task : tasks) checkTask(task); } // Check parent type checkResourceType(entity); }
private EntityType createEntityType(Class<?> cl, Map<String, EntityType> types) { if (types.containsKey(cl.getName())) { return types.get(cl.getName()); } else { EntityType type = new EntityType(new ClassType(TypeCategory.ENTITY, cl)); typeMappings.register(type, queryTypeFactory.create(type)); if (!cl.getSuperclass().equals(Object.class)) { type.addSupertype(new Supertype(new ClassType(cl.getSuperclass()))); } types.put(cl.getName(), type); allTypes.put(cl.getName(), type); return type; } }
private void PushChanges() throws Exception { BookmarkCollection updates = Bookmark.GetBookmarksForServerUpdate(getContextSource()); BookmarkCollection deletes = Bookmark.GetBookmarksForServerDelete(this.getContextSource()); if (updates.size() == 0 && deletes.size() == 0) return; // et... EntityType et = EntityType.GetEntityType(Bookmark.class); // get the server ones... BookmarksService service = new BookmarksService(); BookmarkCollection fromServer = service.GetAll(); // walk the locally updated items… for (Bookmark local : updates) { // find it in our server set... Bookmark toUpdate = null; for (Bookmark server : fromServer) { if (local.getOrdinal() == server.getOrdinal()) { toUpdate = server; break; } } // did we have one to change? if (toUpdate != null) { // walk the fields... int serverId = 0; for (EntityField field : et.getFields()) { if (!(field.getIsKey())) toUpdate.SetValue(field, local.GetValue(field), SetReason.UserSet); else serverId = toUpdate.getBookmarkId(); } // send that up... service.PushUpdate(this.getContextSource(), toUpdate, serverId); } else { // we need to insert it... service.PushInsert(this.getContextSource(), local); } } // what about ones to delete? for (Bookmark local : deletes) { // find a matching ordinal on the server... for (Bookmark server : fromServer) { if (local.getOrdinal() == server.getOrdinal()) service.PushDelete(this.getContextSource(), server, server.getBookmarkId()); } } }
public void unmarshal(DataInputStream dis) { super.unmarshal(dis); try { minefieldID.unmarshal(dis); requestingEntityID.unmarshal(dis); minefieldSequenceNumbeer = (int) dis.readUnsignedShort(); requestID = (short) dis.readUnsignedByte(); pduSequenceNumber = (short) dis.readUnsignedByte(); numberOfPdus = (short) dis.readUnsignedByte(); numberOfMinesInThisPdu = (short) dis.readUnsignedByte(); numberOfSensorTypes = (short) dis.readUnsignedByte(); pad2 = (short) dis.readUnsignedByte(); dataFilter = dis.readInt(); mineType.unmarshal(dis); for (int idx = 0; idx < numberOfSensorTypes; idx++) { TwoByteChunk anX = new TwoByteChunk(); anX.unmarshal(dis); sensorTypes.add(anX); } pad3 = (short) dis.readUnsignedByte(); for (int idx = 0; idx < numberOfMinesInThisPdu; idx++) { Vector3Float anX = new Vector3Float(); anX.unmarshal(dis); mineLocation.add(anX); } } // end try catch (Exception e) { System.out.println(e); } } // end of unmarshal method
@Override public void complete() { AmberPersistenceUnit persistenceUnit = _sourceType.getPersistenceUnit(); Class targetClass = getTargetClass(); if (targetClass == null || void.class.equals(targetClass)) throw error( _field, L.l( "Can't determine targetEntity for {0}. @OneToMany properties must target @Entity beans.", _fieldName)); AmberType targetType = persistenceUnit.createType(targetClass); if (targetType == null) { throw error( _field, L.l( "targetClass '{0}' is not a known element collection class for {1}. The targetClass of a @ElementCollection must be a basic class.", targetClass.getName(), _fieldName)); } /* if (_orderBy != null) calculateOrderBy(_orderBy); */ addCollection(targetType); }
private void introspectDiscriminatorValue(Class type, EntityType entityType) { DiscriminatorValue discValueAnn = (DiscriminatorValue) type.getAnnotation(DiscriminatorValue.class); String discriminatorValue = null; if (discValueAnn != null) discriminatorValue = discValueAnn.value(); if (discriminatorValue == null || discriminatorValue.equals("")) { String name = entityType.getBeanClass().getSimpleName(); discriminatorValue = name; } entityType.setDiscriminatorValue(discriminatorValue); }
public void marshal(DataOutputStream dos) { super.marshal(dos); try { minefieldID.marshal(dos); requestingEntityID.marshal(dos); dos.writeByte((byte) requestID); dos.writeByte((byte) requestedPerimeterPoints.size()); dos.writeByte((byte) pad2); dos.writeByte((byte) sensorTypes.size()); dos.writeInt((int) dataFilter); requestedMineType.marshal(dos); for (int idx = 0; idx < requestedPerimeterPoints.size(); idx++) { Point aPoint = requestedPerimeterPoints.get(idx); aPoint.marshal(dos); } // end of list marshalling for (int idx = 0; idx < sensorTypes.size(); idx++) { TwoByteChunk aTwoByteChunk = sensorTypes.get(idx); aTwoByteChunk.marshal(dos); } // end of list marshalling } // end try catch (Exception e) { System.out.println(e); } } // end of marshal method
public int getMarshalledSize() { int marshalSize = 0; marshalSize = super.getMarshalledSize(); marshalSize = marshalSize + minefieldID.getMarshalledSize(); // minefieldID marshalSize = marshalSize + requestingEntityID.getMarshalledSize(); // requestingEntityID marshalSize = marshalSize + 2; // minefieldSequenceNumbeer marshalSize = marshalSize + 1; // requestID marshalSize = marshalSize + 1; // pduSequenceNumber marshalSize = marshalSize + 1; // numberOfPdus marshalSize = marshalSize + 1; // numberOfMinesInThisPdu marshalSize = marshalSize + 1; // numberOfSensorTypes marshalSize = marshalSize + 1; // pad2 marshalSize = marshalSize + 4; // dataFilter marshalSize = marshalSize + mineType.getMarshalledSize(); // mineType for (int idx = 0; idx < sensorTypes.size(); idx++) { TwoByteChunk listElement = sensorTypes.get(idx); marshalSize = marshalSize + listElement.getMarshalledSize(); } marshalSize = marshalSize + 1; // pad3 for (int idx = 0; idx < mineLocation.size(); idx++) { Vector3Float listElement = mineLocation.get(idx); marshalSize = marshalSize + listElement.getMarshalledSize(); } return marshalSize; }
public void unmarshal(DataInputStream dis) { super.unmarshal(dis); try { minefieldID.unmarshal(dis); requestingEntityID.unmarshal(dis); requestID = (short) dis.readUnsignedByte(); numberOfPerimeterPoints = (short) dis.readUnsignedByte(); pad2 = (short) dis.readUnsignedByte(); numberOfSensorTypes = (short) dis.readUnsignedByte(); dataFilter = dis.readInt(); requestedMineType.unmarshal(dis); for (int idx = 0; idx < numberOfPerimeterPoints; idx++) { Point anX = new Point(); anX.unmarshal(dis); requestedPerimeterPoints.add(anX); } for (int idx = 0; idx < numberOfSensorTypes; idx++) { TwoByteChunk anX = new TwoByteChunk(); anX.unmarshal(dis); sensorTypes.add(anX); } } // end try catch (Exception e) { System.out.println(e); } } // end of unmarshal method
/** * Unpacks a Pdu from the underlying data. * * @throws java.nio.BufferUnderflowException if buff is too small * @see java.nio.ByteBuffer * @param buff The ByteBuffer at the position to begin reading * @since ?? */ public void unmarshal(java.nio.ByteBuffer buff) { super.unmarshal(buff); minefieldID.unmarshal(buff); requestingEntityID.unmarshal(buff); minefieldSequenceNumbeer = (int) (buff.getShort() & 0xFFFF); requestID = (short) (buff.get() & 0xFF); pduSequenceNumber = (short) (buff.get() & 0xFF); numberOfPdus = (short) (buff.get() & 0xFF); numberOfMinesInThisPdu = (short) (buff.get() & 0xFF); numberOfSensorTypes = (short) (buff.get() & 0xFF); pad2 = (short) (buff.get() & 0xFF); dataFilter = buff.getInt(); mineType.unmarshal(buff); for (int idx = 0; idx < numberOfSensorTypes; idx++) { TwoByteChunk anX = new TwoByteChunk(); anX.unmarshal(buff); sensorTypes.add(anX); } pad3 = (short) (buff.get() & 0xFF); for (int idx = 0; idx < numberOfMinesInThisPdu; idx++) { Vector3Float anX = new Vector3Float(); anX.unmarshal(buff); mineLocation.add(anX); } } // end of unmarshal method
@Override public boolean equalsImpl(Object obj) { boolean ivarsEqual = true; if (!(obj instanceof MinefieldDataPdu)) return false; final MinefieldDataPdu rhs = (MinefieldDataPdu) obj; if (!(minefieldID.equals(rhs.minefieldID))) ivarsEqual = false; if (!(requestingEntityID.equals(rhs.requestingEntityID))) ivarsEqual = false; if (!(minefieldSequenceNumbeer == rhs.minefieldSequenceNumbeer)) ivarsEqual = false; if (!(requestID == rhs.requestID)) ivarsEqual = false; if (!(pduSequenceNumber == rhs.pduSequenceNumber)) ivarsEqual = false; if (!(numberOfPdus == rhs.numberOfPdus)) ivarsEqual = false; if (!(numberOfMinesInThisPdu == rhs.numberOfMinesInThisPdu)) ivarsEqual = false; if (!(numberOfSensorTypes == rhs.numberOfSensorTypes)) ivarsEqual = false; if (!(pad2 == rhs.pad2)) ivarsEqual = false; if (!(dataFilter == rhs.dataFilter)) ivarsEqual = false; if (!(mineType.equals(rhs.mineType))) ivarsEqual = false; for (int idx = 0; idx < sensorTypes.size(); idx++) { if (!(sensorTypes.get(idx).equals(rhs.sensorTypes.get(idx)))) ivarsEqual = false; } if (!(pad3 == rhs.pad3)) ivarsEqual = false; for (int idx = 0; idx < mineLocation.size(); idx++) { if (!(mineLocation.get(idx).equals(rhs.mineLocation.get(idx)))) ivarsEqual = false; } return ivarsEqual && super.equalsImpl(rhs); }
/** * Packs a Pdu into the ByteBuffer. * * @throws java.nio.BufferOverflowException if buff is too small * @throws java.nio.ReadOnlyBufferException if buff is read only * @see java.nio.ByteBuffer * @param buff The ByteBuffer at the position to begin writing * @since ?? */ public void marshal(java.nio.ByteBuffer buff) { super.marshal(buff); minefieldID.marshal(buff); requestingEntityID.marshal(buff); buff.putShort((short) minefieldSequenceNumbeer); buff.put((byte) requestID); buff.put((byte) pduSequenceNumber); buff.put((byte) numberOfPdus); buff.put((byte) mineLocation.size()); buff.put((byte) sensorTypes.size()); buff.put((byte) pad2); buff.putInt((int) dataFilter); mineType.marshal(buff); for (int idx = 0; idx < sensorTypes.size(); idx++) { TwoByteChunk aTwoByteChunk = (TwoByteChunk) sensorTypes.get(idx); aTwoByteChunk.marshal(buff); } // end of list marshalling buff.put((byte) pad3); for (int idx = 0; idx < mineLocation.size(); idx++) { Vector3Float aVector3Float = (Vector3Float) mineLocation.get(idx); aVector3Float.marshal(buff); } // end of list marshalling } // end of marshal method
public void marshal(DataOutputStream dos) { super.marshal(dos); try { minefieldID.marshal(dos); requestingEntityID.marshal(dos); dos.writeShort((short) minefieldSequenceNumbeer); dos.writeByte((byte) requestID); dos.writeByte((byte) pduSequenceNumber); dos.writeByte((byte) numberOfPdus); dos.writeByte((byte) mineLocation.size()); dos.writeByte((byte) sensorTypes.size()); dos.writeByte((byte) pad2); dos.writeInt((int) dataFilter); mineType.marshal(dos); for (int idx = 0; idx < sensorTypes.size(); idx++) { TwoByteChunk aTwoByteChunk = sensorTypes.get(idx); aTwoByteChunk.marshal(dos); } // end of list marshalling dos.writeByte((byte) pad3); for (int idx = 0; idx < mineLocation.size(); idx++) { Vector3Float aVector3Float = mineLocation.get(idx); aVector3Float.marshal(dos); } // end of list marshalling } // end try catch (Exception e) { System.out.println(e); } } // end of marshal method
@Override public boolean equalsImpl(Object obj) { boolean ivarsEqual = true; if (!(obj instanceof MinefieldQueryPdu)) return false; final MinefieldQueryPdu rhs = (MinefieldQueryPdu) obj; if (!(minefieldID.equals(rhs.minefieldID))) ivarsEqual = false; if (!(requestingEntityID.equals(rhs.requestingEntityID))) ivarsEqual = false; if (!(requestID == rhs.requestID)) ivarsEqual = false; if (!(numberOfPerimeterPoints == rhs.numberOfPerimeterPoints)) ivarsEqual = false; if (!(pad2 == rhs.pad2)) ivarsEqual = false; if (!(numberOfSensorTypes == rhs.numberOfSensorTypes)) ivarsEqual = false; if (!(dataFilter == rhs.dataFilter)) ivarsEqual = false; if (!(requestedMineType.equals(rhs.requestedMineType))) ivarsEqual = false; for (int idx = 0; idx < requestedPerimeterPoints.size(); idx++) { if (!(requestedPerimeterPoints.get(idx).equals(rhs.requestedPerimeterPoints.get(idx)))) ivarsEqual = false; } for (int idx = 0; idx < sensorTypes.size(); idx++) { if (!(sensorTypes.get(idx).equals(rhs.sensorTypes.get(idx)))) ivarsEqual = false; } return ivarsEqual && super.equalsImpl(rhs); }
// null means that we could not get the updated results, so leave the old results // empty list results means that we should save a no results marker public List<? extends ResultType> saveInCacheInsideExistingTransaction( KeyType key, List<? extends ResultType> newItems, Date now, boolean refetchedWithoutCheckingCache) { TxUtils.assertHaveTransaction(); logger.debug("Saving new results in cache"); List<EntityType> oldItems = mapper.queryExisting(key); // since we always load all items, this is as good as letting the database do it, and doesn't // require // hacking each individual oldItems sort(oldItems); if (newItems == null) return formResultTypeList(oldItems); // Delete old items if any, the noResultsMarker if none deleteCache(key); // This is perhaps superstitious, but we do have an ordering constraint that we must // remove the old items then insert the new, or it will cause a constraint violation em.flush(); // save new results if (newItems.isEmpty()) { EntityType e = mapper.newNoResultsMarker(key); if (!e.isNoResultsMarker()) throw new RuntimeException("new no results marker isn't: " + e); e.setLastUpdated(now); em.persist(e); logger.debug("cached a no results marker for key {}", key); } else { // Note that we are relying on getting database ID ordering that matches // the order of newItems, so when we load from the cache we can get things // back in the same order. for (ResultType r : newItems) { EntityType e = mapper.entityFromResult(key, r); e.setLastUpdated(now); em.persist(e); } logger.debug("cached {} items for key {}", newItems.size(), key); } return newItems; }
private void validateMetaTypes() { for (Collection<EntityType> entityTypes : Arrays.asList( context.supertypes.values(), context.entityTypes.values(), context.extensionTypes.values(), context.embeddableTypes.values(), context.projectionTypes.values())) { for (EntityType entityType : entityTypes) { for (Property property : entityType.getProperties()) { if (property.getInits() != null && property.getInits().size() > 0) { validateInits(entityType, property); } } } } }
/** * Packs a Pdu into the ByteBuffer. * * @throws java.nio.BufferOverflowException if buff is too small * @throws java.nio.ReadOnlyBufferException if buff is read only * @see java.nio.ByteBuffer * @param buff The ByteBuffer at the position to begin writing * @since ?? */ public void marshal(java.nio.ByteBuffer buff) { super.marshal(buff); orginatingEntityID.marshal(buff); receivingEntityID.marshal(buff); relationship.marshal(buff); partLocation.marshal(buff); namedLocationID.marshal(buff); partEntityType.marshal(buff); } // end of marshal method
public BookmarkCollection GetAll() throws Exception { EntityType et = EntityType.GetEntityType(Bookmark.class); // run... String url = GetServiceUrl(et); Document doc = HttpHelper.DownloadXml(url, GetDownloadSettings()); // load... return (BookmarkCollection) LoadEntities(doc, et); }