com.kabira.platform

Class ManagedObject

java.lang.Object

com.kabira.platform.ManagedObject

@Managed
public abstract class ManagedObject
extends java.lang.Object

Class to manipulate and find shared memory backed objects. To create a Java object that persists in shared memory, see the @Managed annotation.

Example:

@Managed
public class Account {
    public Account(String userName) {
        super();
        m_userName = userName;
    }

    public Account(String userName, Account referrer) {
        this(userName);
        allocateMailbox();
        addToFriendList(referrer);
    }

    public void addToFriendList(Account friendlyAccount) {
        ...
    }

    private void allocateMailbox() {
        ...
    }

    private String m_userName;
    private Account[] m_friendList;
}

Some example usage of the above type:

    //
    //  create a new account in shared memory:
    //
    Account newCustomer = new Account("Fred Rogers", referrer);
    System.out.println("Added " + newCustomer.toString());

    //
    //  delete all expired accounts from shared memory.
    //  Note extent access, and use of the delete() method
    //  to delete the shared memory instance.
    //
    for (Account acc : ManagedObject.extent(Account.class)) {
        if (acc.expireDate < today) {
            ManagedObject.delete(acc);
        }
    }
 

See Also:

Managed, Transaction

Constructor Summary

Constructors

Constructor and Description
ManagedObject()

Method Summary

Methods

Modifier and Type	Method and Description
static int	cardinality(java.lang.Class<?> operand) Returns the number of instances of the given class.
static void	delete(java.lang.Object operand) Deletes a Managed object.
static boolean	equals(java.lang.Object o1, java.lang.Object o2) Returns true if both references are proxies to the same shared memory object.
static <T> java.lang.Iterable<T>	extent(java.lang.Class<T> klass) Returns all shared memory instances of a Managed type.
static <T> java.lang.Iterable<T>	extent(java.lang.Class<T> klass, LockMode objectLock) Returns all shared memory instances of a Managed type, with an explicit transaction lock taken on each instance as it is iterated.
static int	hashCode(java.lang.Object o) Returns a hash code based on the underlying shared memory object.
static boolean	isEmpty(java.lang.Object operand) Determines if the backing shared memory object has been deleted.
static boolean	isManaged(java.lang.Object o) Determines if the given object is an instance of a Managed class.
static boolean	isManagedClass(java.lang.Class<?> klass) Determines if the given class is Managed.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ManagedObject

public ManagedObject()

Method Detail

extent

public static <T> java.lang.Iterable<T> extent(java.lang.Class<T> klass)
                                    throws ManagedClassError

Returns all shared memory instances of a Managed type.

The klass parameter must be a Managed class, and is used to determine the extent to return. A Managed class is either annotated @Managed, or extends a class that is so annotated.

Consider the following example. It returns all instances of MyType (including instances of its subtypes) with no locks held on the objects:

    //
    // Iterate instances of MyType.class, returning all objects in the extent
    //
    for (MyType instance : ManagedObject.extent(MyType.class)) {
        assert ( Transaction.hasReadLock(instance) == false );
        assert ( Transaction.hasWriteLock(instance) == false );
        ...
    }

Parameters:

klass - extent class - instances of this type, and any subtypes that extend from this type, will be returned in the extent.

Returns:

Iterable that will traverse all instances located in shared memory.

Throws:

ManagedClassError - Thrown if klass is not Managed (or exactly ManagedObject).

See Also:

Managed, ManagedClassError

extent

public static <T> java.lang.Iterable<T> extent(java.lang.Class<T> klass,
                               LockMode objectLock)
                                    throws ManagedClassError

Returns all shared memory instances of a Managed type, with an explicit transaction lock taken on each instance as it is iterated.

The klass parameter must be a Managed class, and is used to determine the extent to return.

The objectLock parameter is used to specify the transaction lock to take on objects returned during extent iteration. The objects are locked as they are returned from the java.util.Iterator, not when this method returns.

Consider the following example. It returns all instances of MyType (including instances of its subtypes) with a READLOCK held on each instance:

    //
    //  Iterate the ManagedObjectSet taking read locks on the objects
    //
    for (MyType mt : ManagedObject.extent( MyType.class, LockMode.READLOCK)) {
        assert ( Transaction.hasReadLock(mt) == true );
        ...
    }

Parameters:

klass - extent class - instances of this type, and any subtypes that extend from this type, will be returned in the extent.

objectLock - object lock - all object instances returned during extent iteration will have this transaction lock.

Returns:

Iterable containing references to all instances located in shared memory.

Throws:

ManagedClassError - Thrown if klass is not marked Managed, or is exactly ManagedObject.

See Also:

Managed

hashCode

public static int hashCode(java.lang.Object o)

Returns a hash code based on the underlying shared memory object.

equals

public static boolean equals(java.lang.Object o1,
             java.lang.Object o2)
                      throws ManagedClassError

Returns true if both references are proxies to the same shared memory object.

Throws:

ManagedClassError - if o1 or o2 is not Managed.

isManaged

public static boolean isManaged(java.lang.Object o)

Determines if the given object is an instance of a Managed class. Returns true only if the object, or a superclass, is marked @Managed.

isManagedClass

public static boolean isManagedClass(java.lang.Class<?> klass)

Determines if the given class is Managed. Returns true only if the class, or a superclass, is marked @Managed.

delete

public static void delete(java.lang.Object operand)
                   throws ManagedClassError

Deletes a Managed object.

Throws:

ManagedClassError - if operand is not Managed.

cardinality

public static int cardinality(java.lang.Class<?> operand)
                       throws ManagedClassError

Returns the number of instances of the given class.
This count does not require transaction locks on the extent or any of the individual objects in the extent.
This means the number returned by cardinality() may change even as observed within a single transaction.

Throws:

ManagedClassError - if klass is not Managed.

isEmpty

public static boolean isEmpty(java.lang.Object operand)
                       throws ManagedClassError

Determines if the backing shared memory object has been deleted.

Returns:

true if the operand has been deleted, false otherwise.

Throws:

ManagedClassError - if the operand object is not of a Managed class.