java.lang.Object
- org.robwork.sdurw_models.CompositeDevicePtr

```
public class CompositeDevicePtr
extends java.lang.Object
```
Ptr stores a pointer and optionally takes ownership of the value.

Constructor Summary

Constructors
Constructor	Description
`CompositeDevicePtr()`	Default constructor yielding a NULL-pointer.
`CompositeDevicePtr(long cPtr, boolean cMemoryOwn)`
`CompositeDevicePtr(CompositeDevice ptr)`	Do not take ownership of ptr. ptr can be null. The constructor is implicit on purpose.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`CompositeDevice`	`__ref__()`	Dereferencing operator.
`DeviceCPtr`	`asDeviceCPtr()`
`DevicePtr`	`asDevicePtr()`
`JointDeviceCPtr`	`asJointDeviceCPtr()`
`JointDevicePtr`	`asJointDevicePtr()`
`JacobianCalculatorPtr`	`baseJCend(State state)`	DeviceJacobian for the end frame. By default this method forwards to baseDJframe().
`JacobianCalculatorPtr`	`baseJCframe(FrameCPtr frame, State state)`	DeviceJacobian for a particular frame. By default this method forwards to baseDJframes().
`JacobianCalculatorPtr`	`baseJCframes(FrameVector frames, State state)`
`Jacobian`	`baseJend(State state)`
`Jacobian`	`baseJends(State state)`	like Device::baseJend() but with a Jacobian calculated for all end-effectors (see getEnds()).
`Jacobian`	`baseJframe(FrameCPtr frame, State state)`	Calculates the jacobian matrix of a frame f described in the robot base frame ^{base}_{frame}\mathbf{J}_{\mathbf{q}}(\mathbf{q})
`Jacobian`	`baseJframes(FrameVector frames, State state)`	The Jacobian for a sequence of frames. A Jacobian is computed for each of the frames and the Jacobians are stacked on top of eachother.
`Transform3D`	`baseTend(State state)`	Calculates the homogeneous transform from base to the end frame \robabx{base}{end}{\mathbf{T}}
`Transform3D`	`baseTframe(FrameCPtr f, State state)`	Calculates the homogeneous transform from base to a frame f \robabx{b}{f}{\mathbf{T}}
`CompositeDeviceCPtr`	`cptr()`
`void`	`delete()`
`CompositeDevice`	`deref()`	The pointer stored in the object.
`boolean`	`equals(CompositeDevice p)`
`Q`	`getAccelerationLimits()`
`Frame`	`getBase()`
`PairQ`	`getBounds()`
`static long`	`getCPtr(CompositeDevicePtr obj)`
`CompositeDevice`	`getDeref()`	Member access operator.
`long`	`getDOF()`
`Frame`	`getEnd()`
`FrameVector`	`getEnds()`	The end-effectors of the composite device. The end-effectors of the composite device are the end-effectors of the devices from which the composite device was constructed. This sequence of end-effectors may or may not include the default end-effector returned by getEnd().
`VectorJoint_p`	`getJoints()`	Get all joints of this device
`java.lang.String`	`getName()`	Returns the name of the device
`PropertyMap`	`getPropertyMap()`
`Q`	`getQ(State state)`
`StateStructurePtr`	`getStateStructure()`	Get the state structure.
`Q`	`getVelocityLimits()`
`boolean`	`isNull()`	checks if the pointer is null
`boolean`	`isRegistered()`	Check if object has registered its state.
`boolean`	`isShared()`	check if this Ptr has shared ownership or none ownership
`void`	`registerIn(State state)`	initialize this stateless data to a specific state
`void`	`registerIn(StateStructurePtr state)`	register this stateless object in a statestructure.
`void`	`setAccelerationLimits(Q acclimits)`
`void`	`setBounds(PairQ bounds)`
`void`	`setName(java.lang.String name)`	Sets the name of the Device
`void`	`setQ(Q q, State state)`	The method is implemented via forwarding to the Device::setQ() methods of the subdevices.
`void`	`setVelocityLimits(Q vellimits)`
`java.lang.String`	`toString()`
`void`	`unregister()`	unregisters all state data of this stateless object
`Transform3D`	`worldTbase(State state)`	Calculates the homogeneous transform from world to base \robabx{w}{b}{\mathbf{T}}

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - CompositeDevicePtr
```
public CompositeDevicePtr(long cPtr,
                          boolean cMemoryOwn)
```
  - CompositeDevicePtr
```
public CompositeDevicePtr()
```
    Default constructor yielding a NULL-pointer.
  - CompositeDevicePtr
```
public CompositeDevicePtr(CompositeDevice ptr)
```
    Do not take ownership of ptr.
    
    ptr can be null.
    
    The constructor is implicit on purpose.
- Method Detail
  - getCPtr
```
public static long getCPtr(CompositeDevicePtr obj)
```
  - delete
```
public void delete()
```
  - deref
```
public CompositeDevice deref()
```
    The pointer stored in the object.
  - __ref__
```
public CompositeDevice __ref__()
```
    Dereferencing operator.
  - getDeref
```
public CompositeDevice getDeref()
```
    Member access operator.
  - equals
```
public boolean equals(CompositeDevice p)
```
  - isShared
```
public boolean isShared()
```
    check if this Ptr has shared ownership or none
    ownership
    
    Returns:
    
    true if Ptr has shared ownership, false if it has no ownership.
  - isNull
```
public boolean isNull()
```
    checks if the pointer is null
    
    Returns:
    
    Returns true if the pointer is null
  - cptr
```
public CompositeDeviceCPtr cptr()
```
  - asDevicePtr
```
public DevicePtr asDevicePtr()
```
  - asDeviceCPtr
```
public DeviceCPtr asDeviceCPtr()
```
  - asJointDevicePtr
```
public JointDevicePtr asJointDevicePtr()
```
  - asJointDeviceCPtr
```
public JointDeviceCPtr asJointDeviceCPtr()
```
  - setQ
```
public void setQ(Q q,
                 State state)
```
    The method is implemented via forwarding to the Device::setQ()
    methods of the subdevices.
  - baseJends
```
public Jacobian baseJends(State state)
```
    like Device::baseJend() but with a Jacobian calculated for all
    end-effectors (see getEnds()).
  - getEnds
```
public FrameVector getEnds()
```
    The end-effectors of the composite device.
    
    The end-effectors of the composite device are the end-effectors of
    the devices from which the composite device was constructed.
    
    This sequence of end-effectors may or may not include the default
    end-effector returned by getEnd().
  - getJoints
```
public VectorJoint_p getJoints()
```
    Get all joints of this device
    
    Returns:
    
    all joints
  - getQ
```
public Q getQ(State state)
```
  - getDOF
```
public long getDOF()
```
  - getBounds
```
public PairQ getBounds()
```
  - setBounds
```
public void setBounds(PairQ bounds)
```
  - getVelocityLimits
```
public Q getVelocityLimits()
```
  - setVelocityLimits
```
public void setVelocityLimits(Q vellimits)
```
  - getAccelerationLimits
```
public Q getAccelerationLimits()
```
  - setAccelerationLimits
```
public void setAccelerationLimits(Q acclimits)
```
  - baseJend
```
public Jacobian baseJend(State state)
```
  - baseJCframes
```
public JacobianCalculatorPtr baseJCframes(FrameVector frames,
                                          State state)
```
  - getBase
```
public Frame getBase()
```
  - getEnd
```
public Frame getEnd()
```
  - getName
```
public java.lang.String getName()
```
    Returns the name of the device
    
    Returns:
    
    name of the device
  - setName
```
public void setName(java.lang.String name)
```
    Sets the name of the Device
    
    Parameters:
    
    name - [in] the new name of the frame
  - baseTframe
```
public Transform3D baseTframe(FrameCPtr f,
                              State state)
```
    Calculates the homogeneous transform from base to a frame f
    \robabx{b}{f}{\mathbf{T}}
    
    Returns:
    
    the homogeneous transform \robabx{b}{f}{\mathbf{T}}
  - baseTend
```
public Transform3D baseTend(State state)
```
    Calculates the homogeneous transform from base to the end frame
    \robabx{base}{end}{\mathbf{T}}
    
    Returns:
    
    the homogeneous transform \robabx{base}{end}{\mathbf{T}}
  - worldTbase
```
public Transform3D worldTbase(State state)
```
    Calculates the homogeneous transform from world to base \robabx{w}{b}{\mathbf{T}}
    
    Returns:
    
    the homogeneous transform \robabx{w}{b}{\mathbf{T}}
  - baseJframe
```
public Jacobian baseJframe(FrameCPtr frame,
                           State state)
```
    Calculates the jacobian matrix of a frame f described in the
    robot base frame ^{base}_{frame}\mathbf{J}_{\mathbf{q}}(\mathbf{q})
    
    Parameters:
    
    frame - [in] Frame for which to calculate the Jacobian
    
    state - [in] State for which to calculate the Jacobian
    
    Returns:
    
    the 6*ndof jacobian matrix: {^{base}_{frame}}\mathbf{J}_{\mathbf{q}}(\mathbf{q})
    
    This method calculates the jacobian relating joint velocities ( \mathbf{\dot{q}} ) to the frame f velocity seen from base-frame
    ( \nu^{base}_{frame} )
    
    \nu^{base}_{frame} = {^{base}_{frame}}\mathbf{J}_\mathbf{q}(\mathbf{q})\mathbf{\dot{q}}
    
    The jacobian matrix {^{base}_n}\mathbf{J}_{\mathbf{q}}(\mathbf{q})
    is defined as:
    
    {^{base}_n}\mathbf{J}_{\mathbf{q}}(\mathbf{q}) = \frac{\partial ^{base}\mathbf{x}_n}{\partial \mathbf{q}}
    
    By default the method forwards to baseJframes().
  - baseJframes
```
public Jacobian baseJframes(FrameVector frames,
                            State state)
```
    The Jacobian for a sequence of frames.
    
    A Jacobian is computed for each of the frames and the Jacobians are
    stacked on top of eachother.
    
    Parameters:
    
    frames - [in] the frames to calculate the frames from
    
    state - [in] the state to calculate in
    
    Returns:
    
    the jacobian
  - baseJCend
```
public JacobianCalculatorPtr baseJCend(State state)
```
    DeviceJacobian for the end frame.
    
    By default this method forwards to baseDJframe().
  - baseJCframe
```
public JacobianCalculatorPtr baseJCframe(FrameCPtr frame,
                                         State state)
```
    DeviceJacobian for a particular frame.
    
    By default this method forwards to baseDJframes().
  - getPropertyMap
```
public PropertyMap getPropertyMap()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - registerIn
```
public void registerIn(State state)
```
    initialize this stateless data to a specific state
    
    Parameters:
    
    state - [in] the state in which to register the data.
    
    Note: the data will be registered in the state structure of the state
    and any copies or other instances of the state will therefore also
    contain the added states.
  - registerIn
```
public void registerIn(StateStructurePtr state)
```
    register this stateless object in a statestructure.
  - unregister
```
public void unregister()
```
    unregisters all state data of this stateless object
  - getStateStructure
```
public StateStructurePtr getStateStructure()
```
    Get the state structure.
    
    Returns:
    
    the state structure.
  - isRegistered
```
public boolean isRegistered()
```
    Check if object has registered its state.
    
    Returns:
    
    true if registered, false otherwise.

Class CompositeDevicePtr

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CompositeDevicePtr

CompositeDevicePtr

CompositeDevicePtr

Method Detail

getCPtr

delete

deref

__ref__

getDeref

equals

isShared

isNull

cptr

asDevicePtr

asDeviceCPtr

asJointDevicePtr

asJointDeviceCPtr

setQ

baseJends

getEnds

getJoints

getQ

getDOF

getBounds

setBounds

getVelocityLimits

setVelocityLimits

getAccelerationLimits

setAccelerationLimits

baseJend

baseJCframes

getBase

getEnd

getName

setName

baseTframe

baseTend

worldTbase

baseJframe

baseJframes

baseJCend

baseJCframe

getPropertyMap

toString

registerIn

registerIn

unregister

getStateStructure

isRegistered

ref