@Override @Hidden public FixtureType getType() { return FixtureType.DOMAIN_OBJECTS; } }
/** * Used to recreate a recreatable object with a memento obtained from {@link #__isis_recreate(String)}. */ @Hidden public void __isis_recreate(String memento);
@Override @Hidden public FixtureType getType() { return FixtureType.DOMAIN_OBJECTS; } }
/** * This field is not persisted, nor displayed to the user. * * @uml.property name="container" */ @Hidden protected DomainObjectContainer getContainer() { return this.container; }
/** * @deprecated */ @Deprecated @Hidden @Override public void publish(EventMetadata metadata, EventPayload payload) { Object serializedEvent = eventSerializer.serialize(metadata, payload); System.err.println(serializedEvent); }
/** * Delete this object from the persistent object store. * * @deprecated - instead use {@link #remove(Object)}. */ @Deprecated @Hidden protected void disposeInstance() { remove(this); } // }}
@Hidden @MemberOrder(sequence = "11") public List<BusRulesEntityChild> getInvisibleCollection() { return invisibleCollection; }
/** * Whether this object is persistent. * * @deprecated - instead use {@link #isPersistent(Object)}. */ @Deprecated @Hidden protected boolean isPersistent() { return isPersistent(this); }
@Hidden @DomainService public class HiddenRepository { public String someAction() { return null; } }
@Hidden @MemberOrder(sequence = "3") public int getInvisibleProperty() { return invisibleProperty; }
/** * The object (usually an {@link WithInterval}, but not necessarily) that precedes this one, if any (not * necessarily contiguously).. * * <p> * Implementations where successive intervals are contiguous should instead implement * {@link WithIntervalContiguous}. */ @Hidden(where=Where.ALL_TABLES) @Disabled @Optional public T getPrevious();
/** * Saves the object, but only if not already {@link #isPersistent() * persistent}. * * @see #isPersistent() * @see #persist(Object) */ @Hidden protected void persistIfNotAlready(final Object domainObject) { getContainer().persistIfNotAlready(domainObject); }
/** * Resolve this object if the referenced object is still unknown. */ @Hidden protected void resolve(final Object referencedObject) { getContainer().resolve(this, referencedObject); }
/** * Notifies the container that this object has changed, so that it can be * persisted. */ @Hidden protected void objectChanged() { getContainer().objectChanged(this); }
@Hidden @ActionSemantics(Of.SAFE) @MemberOrder(sequence = "1") public ActionsEntity invisibleAction() { return this; }
/** * The object (usually an {@link WithInterval}, but not necessarily) that succeeds this one, if any (not * necessarily contiguously). * * <p> * Implementations where successive intervals are contiguous should instead implement * {@link WithIntervalContiguous}. */ @Hidden(where=Where.ALL_TABLES) @Disabled @Optional public T getNext();
/** * Resolve this object, populating references to other objects. */ @Hidden protected void resolve() { getContainer().resolve(this); }
@Hidden protected <T> T newAggregatedInstance(final Object parent, final Class<T> ofType) { return getContainer().newAggregatedInstance(parent, ofType); }
/** * Save provided object to the persistent object store. * * <p> * If the object {@link #isPersistent(Object) is persistent} already, then * will throw an exception. * * @see #persistIfNotAlready(Object) */ @Hidden protected void persist(final Object transientDomainObject) { getContainer().persist(transientDomainObject); }
@MemberOrder(sequence="30") @Hidden(where=Where.ALL_TABLES) @Named("Value") public String getValueAsString() { return getValueRaw(); } public boolean hideValueAsString() {