Python: module TCE.base.mach

TCE.base.mach

index
/opt/tce/lib/python2.5/site-packages/TCE/base/mach.so

Classes



Boost.Python.instance(__builtin__.object)

Connection
Machine

NullMachine
UniversalMachine

MachinePart

Component

AddressSpace

NullAddressSpace

Bus

NullBus

ImmediateSlot
InstructionTemplate

NullInstructionTemplate

Socket
Unit

BaseRegisterFile

RegisterFile

ImmediateUnit

NullImmediateUnit

NullRegisterFile
UnboundedRegisterFile

FunctionUnit

ControlUnit
NullFunctionUnit
UniversalFunctionUnit

SubComponent

ExecutionPipeline
Guard

NullGuard
PortGuard
RegisterGuard
UnconditionalGuard

HWOperation

SmartHWOperation

Port

BaseFUPort

FUPort

UniversalFUPort

SpecialRegisterPort

NullPort
RFPort

Segment

MachineTestReportTextGenerator
MachineTestReporter
MachineTester
PipelineElement
TemplateSlot

class AddressSpace(Component)


Method resolution order:

AddressSpace

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, int width, unsigned int minAddress, unsigned int maxAddress, TTAMachine::Machine {lvalue} owner) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Machine {lvalue} owner) -> void*

end(...)
C++ signature:     end(TTAMachine::AddressSpace {lvalue}) -> unsigned int C++ signature:     end(AddressSpace_wrapper {lvalue}) -> unsigned int

loadState(...)
C++ signature:     loadState(TTAMachine::AddressSpace {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(AddressSpace_wrapper {lvalue}, ObjectState const* state) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::AddressSpace {lvalue}) -> ObjectState* C++ signature:     saveState(AddressSpace_wrapper {lvalue}) -> ObjectState*

setAddressBounds(...)
C++ signature:     setAddressBounds(TTAMachine::AddressSpace {lvalue}, unsigned int start, unsigned int end) -> void* C++ signature:     setAddressBounds(AddressSpace_wrapper {lvalue}, unsigned int start, unsigned int end) -> void*

setMachine(...)
C++ signature:     setMachine(TTAMachine::AddressSpace {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(AddressSpace_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

setName(...)
C++ signature:     setName(TTAMachine::AddressSpace {lvalue}, std::string name) -> void* C++ signature:     setName(AddressSpace_wrapper {lvalue}, std::string name) -> void*

setWidth(...)
C++ signature:     setWidth(TTAMachine::AddressSpace {lvalue}, int width) -> void* C++ signature:     setWidth(AddressSpace_wrapper {lvalue}, int width) -> void*

start(...)
C++ signature:     start(TTAMachine::AddressSpace {lvalue}) -> unsigned int C++ signature:     start(AddressSpace_wrapper {lvalue}) -> unsigned int

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::AddressSpace {lvalue}) -> void* C++ signature:     unsetMachine(AddressSpace_wrapper {lvalue}) -> void*

width(...)
C++ signature:     width(TTAMachine::AddressSpace {lvalue}) -> int C++ signature:     width(AddressSpace_wrapper {lvalue}) -> int

Data descriptors defined here:

OSKEY_MAX_ADDRESS

OSKEY_MIN_ADDRESS

OSKEY_WIDTH

OSNAME_ADDRESS_SPACE

Data and other attributes defined here:

__instance_size__ = 36

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class BaseFUPort(Port)


Method resolution order:

BaseFUPort

Port

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, int width, TTAMachine::FunctionUnit {lvalue} parent) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Unit {lvalue} parent) -> void*

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAMachine::BaseFUPort {lvalue}) -> bool C++ signature:     isOpcodeSetting(BaseFUPort_wrapper {lvalue}) -> void*

isTriggering(...)
C++ signature:     isTriggering(TTAMachine::BaseFUPort {lvalue}) -> bool C++ signature:     isTriggering(BaseFUPort_wrapper {lvalue}) -> void*

loadState(...)
C++ signature:     loadState(TTAMachine::BaseFUPort {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(BaseFUPort_wrapper {lvalue}, ObjectState const* state) -> void*

parentUnit(...)
C++ signature: parentUnit(TTAMachine::BaseFUPort {lvalue}) -> TTAMachine::FunctionUnit*

saveState(...)
C++ signature:     saveState(TTAMachine::BaseFUPort {lvalue}) -> ObjectState* C++ signature:     saveState(BaseFUPort_wrapper {lvalue}) -> ObjectState*

setWidth(...)
C++ signature: setWidth(TTAMachine::BaseFUPort {lvalue}, int width) -> void*

width(...)
C++ signature:     width(TTAMachine::BaseFUPort {lvalue}) -> int C++ signature:     width(BaseFUPort_wrapper {lvalue}) -> int

Data descriptors defined here:

OSKEY_WIDTH

Data and other attributes defined here:

__instance_size__ = 36

Methods inherited from Port:

attachSocket(...)
C++ signature:     attachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     attachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

detachAllSockets(...)
C++ signature:     detachAllSockets(TTAMachine::Port {lvalue}) -> void* C++ signature:     detachAllSockets(Port_wrapper {lvalue}) -> void*

detachSocket(...)
C++ signature:     detachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     detachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

inputSocket(...)
C++ signature:     inputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     inputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::Port {lvalue}, TTAMachine::Socket socket) -> bool C++ signature:     isConnectedTo(Port_wrapper {lvalue}, TTAMachine::Socket socket) -> bool

isInput(...)
C++ signature:     isInput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isInput(Port_wrapper {lvalue}) -> bool

isOutput(...)
C++ signature:     isOutput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isOutput(Port_wrapper {lvalue}) -> bool

name(...)
C++ signature:     name(TTAMachine::Port {lvalue}) -> std::string C++ signature:     name(Port_wrapper {lvalue}) -> std::string

outputSocket(...)
C++ signature:     outputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     outputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

setName(...)
C++ signature:     setName(TTAMachine::Port {lvalue}, std::string name) -> void* C++ signature:     setName(Port_wrapper {lvalue}, std::string name) -> void*

socketCount(...)
C++ signature:     socketCount(TTAMachine::Port {lvalue}) -> int C++ signature:     socketCount(Port_wrapper {lvalue}) -> int

unconnectedSocket(...)
C++ signature:     unconnectedSocket(TTAMachine::Port {lvalue}, int index) -> TTAMachine::Socket* C++ signature:     unconnectedSocket(Port_wrapper {lvalue}, int index) -> TTAMachine::Socket*

Data descriptors inherited from Port:

OSKEY_FIRST_SOCKET

OSKEY_NAME

OSKEY_SECOND_SOCKET

OSNAME_PORT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class BaseRegisterFile(Unit)


Method resolution order:

BaseRegisterFile

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, int size, int width) -> void* C++ signature:     __init__(_object*, ObjectState const* state) -> void*

loadState(...)
C++ signature:     loadState(TTAMachine::BaseRegisterFile {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(BaseRegisterFile_wrapper {lvalue}, ObjectState const* state) -> void*

port(...)
C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, int index) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, int index) -> TTAMachine::RFPort*

removePort(...)
C++ signature: removePort(BaseRegisterFile_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::BaseRegisterFile {lvalue}) -> ObjectState* C++ signature:     saveState(BaseRegisterFile_wrapper {lvalue}) -> ObjectState*

setNumberOfRegisters(...)
C++ signature:     setNumberOfRegisters(TTAMachine::BaseRegisterFile {lvalue}, int registers) -> void* C++ signature:     setNumberOfRegisters(BaseRegisterFile_wrapper {lvalue}, int registers) -> void*

setWidth(...)
C++ signature:     setWidth(TTAMachine::BaseRegisterFile {lvalue}, int width) -> void* C++ signature:     setWidth(BaseRegisterFile_wrapper {lvalue}, int width) -> void*

Data descriptors defined here:

OSKEY_SIZE

OSKEY_WIDTH

OSNAME_BASE_REGISTER_FILE

Data and other attributes defined here:

__instance_size__ = 44

Methods inherited from Unit:

hasPort(...)
C++ signature:     hasPort(TTAMachine::Unit {lvalue}, std::string name) -> bool C++ signature:     hasPort(Unit_wrapper {lvalue}, std::string name) -> bool

portCount(...)
C++ signature:     portCount(TTAMachine::Unit {lvalue}) -> int C++ signature:     portCount(Unit_wrapper {lvalue}) -> int

setMachine(...)
C++ signature:     setMachine(TTAMachine::Unit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(Unit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::Unit {lvalue}) -> void* C++ signature:     unsetMachine(Unit_wrapper {lvalue}) -> void*

Data descriptors inherited from Unit:

OSNAME_UNIT

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

setName(...)
C++ signature:     setName(TTAMachine::Component {lvalue}, std::string name) -> void* C++ signature:     setName(Component_wrapper {lvalue}, std::string name) -> void*

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Bus(Component)


Method resolution order:

Bus

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, int width, int immWidth, TTAMachine::Machine::Extension extensionMode) -> void* C++ signature:     __init__(_object*, ObjectState const* state) -> void*

addGuard(...)
C++ signature:     addGuard(TTAMachine::Bus {lvalue}, TTAMachine::Guard {lvalue} guard) -> void* C++ signature:     addGuard(Bus_wrapper {lvalue}, TTAMachine::Guard {lvalue} guard) -> void*

addSegment(...)
C++ signature:     addSegment(TTAMachine::Bus {lvalue}, TTAMachine::Segment {lvalue} segment) -> void* C++ signature:     addSegment(Bus_wrapper {lvalue}, TTAMachine::Segment {lvalue} segment) -> void*

canRead(...)
C++ signature:     canRead(TTAMachine::Bus {lvalue}, TTAMachine::Bus bus) -> bool C++ signature:     canRead(Bus_wrapper {lvalue}, TTAMachine::Bus bus) -> bool

canReadWrite(...)
C++ signature:     canReadWrite(TTAMachine::Bus {lvalue}, TTAMachine::Bus bus) -> bool C++ signature:     canReadWrite(Bus_wrapper {lvalue}, TTAMachine::Bus bus) -> bool

canWrite(...)
C++ signature:     canWrite(TTAMachine::Bus {lvalue}, TTAMachine::Bus bus) -> bool C++ signature:     canWrite(Bus_wrapper {lvalue}, TTAMachine::Bus bus) -> bool

clearDestinationBridge(...)
C++ signature:     clearDestinationBridge(TTAMachine::Bus {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     clearDestinationBridge(Bus_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

clearSourceBridge(...)
C++ signature:     clearSourceBridge(TTAMachine::Bus {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     clearSourceBridge(Bus_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

copy(...)
C++ signature:     copy(TTAMachine::Bus {lvalue}) -> TTAMachine::Bus* C++ signature:     copy(Bus_wrapper {lvalue}) -> TTAMachine::Bus*

guard(...)
C++ signature:     guard(TTAMachine::Bus {lvalue}, int index) -> TTAMachine::Guard* C++ signature:     guard(Bus_wrapper {lvalue}, int index) -> TTAMachine::Guard*

guardCount(...)
C++ signature:     guardCount(TTAMachine::Bus {lvalue}) -> int C++ signature:     guardCount(Bus_wrapper {lvalue}) -> int

hasNextBus(...)
C++ signature:     hasNextBus(TTAMachine::Bus {lvalue}) -> bool C++ signature:     hasNextBus(Bus_wrapper {lvalue}) -> bool

hasPreviousBus(...)
C++ signature:     hasPreviousBus(TTAMachine::Bus {lvalue}) -> bool C++ signature:     hasPreviousBus(Bus_wrapper {lvalue}) -> bool

hasSegment(...)
C++ signature:     hasSegment(TTAMachine::Bus {lvalue}, std::string name) -> bool C++ signature:     hasSegment(Bus_wrapper {lvalue}, std::string name) -> bool

immediateWidth(...)
C++ signature:     immediateWidth(TTAMachine::Bus {lvalue}) -> int C++ signature:     immediateWidth(Bus_wrapper {lvalue}) -> int

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::Bus {lvalue}, TTAMachine::Bus bus) -> bool C++ signature:     isArchitectureEqual(Bus_wrapper {lvalue}, TTAMachine::Bus bus) -> bool

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::Bus {lvalue}, TTAMachine::Socket socket) -> bool C++ signature:     isConnectedTo(Bus_wrapper {lvalue}, TTAMachine::Socket socket) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::Bus {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(Bus_wrapper {lvalue}, ObjectState const* state) -> void*

nextBus(...)
C++ signature:     nextBus(TTAMachine::Bus {lvalue}) -> TTAMachine::Bus* C++ signature:     nextBus(Bus_wrapper {lvalue}) -> TTAMachine::Bus*

position(...)
C++ signature:     position(TTAMachine::Bus {lvalue}) -> int C++ signature:     position(Bus_wrapper {lvalue}) -> int

previousBus(...)
C++ signature:     previousBus(TTAMachine::Bus {lvalue}) -> TTAMachine::Bus* C++ signature:     previousBus(Bus_wrapper {lvalue}) -> TTAMachine::Bus*

removeGuard(...)
C++ signature:     removeGuard(TTAMachine::Bus {lvalue}, TTAMachine::Guard {lvalue} guard) -> void* C++ signature:     removeGuard(Bus_wrapper {lvalue}, TTAMachine::Guard {lvalue} guard) -> void*

removeSegment(...)
C++ signature:     removeSegment(TTAMachine::Bus {lvalue}, TTAMachine::Segment {lvalue} segment) -> void* C++ signature:     removeSegment(Bus_wrapper {lvalue}, TTAMachine::Segment {lvalue} segment) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::Bus {lvalue}) -> ObjectState* C++ signature:     saveState(Bus_wrapper {lvalue}) -> ObjectState*

segment(...)
C++ signature:     segment(TTAMachine::Bus {lvalue}, int index) -> TTAMachine::Segment* C++ signature:     segment(Bus_wrapper {lvalue}, int index) -> TTAMachine::Segment* C++ signature:     segment(TTAMachine::Bus {lvalue}, std::string name) -> TTAMachine::Segment* C++ signature:     segment(Bus_wrapper {lvalue}, std::string name) -> TTAMachine::Segment*

segmentCount(...)
C++ signature:     segmentCount(TTAMachine::Bus {lvalue}) -> int C++ signature:     segmentCount(Bus_wrapper {lvalue}) -> int

setDestinationBridge(...)
C++ signature:     setDestinationBridge(TTAMachine::Bus {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     setDestinationBridge(Bus_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

setImmediateWidth(...)
C++ signature:     setImmediateWidth(TTAMachine::Bus {lvalue}, int width) -> void* C++ signature:     setImmediateWidth(Bus_wrapper {lvalue}, int width) -> void*

setMachine(...)
C++ signature:     setMachine(TTAMachine::Bus {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(Bus_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

setName(...)
C++ signature:     setName(TTAMachine::Bus {lvalue}, std::string name) -> void* C++ signature:     setName(Bus_wrapper {lvalue}, std::string name) -> void*

setSignExtends(...)
C++ signature:     setSignExtends(TTAMachine::Bus {lvalue}) -> void* C++ signature:     setSignExtends(Bus_wrapper {lvalue}) -> void*

setSourceBridge(...)
C++ signature:     setSourceBridge(TTAMachine::Bus {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     setSourceBridge(Bus_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

setWidth(...)
C++ signature:     setWidth(TTAMachine::Bus {lvalue}, int width) -> void* C++ signature:     setWidth(Bus_wrapper {lvalue}, int width) -> void*

setZeroExtends(...)
C++ signature:     setZeroExtends(TTAMachine::Bus {lvalue}) -> void* C++ signature:     setZeroExtends(Bus_wrapper {lvalue}) -> void*

signExtends(...)
C++ signature:     signExtends(TTAMachine::Bus {lvalue}) -> bool C++ signature:     signExtends(Bus_wrapper {lvalue}) -> bool

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::Bus {lvalue}) -> void* C++ signature:     unsetMachine(Bus_wrapper {lvalue}) -> void*

width(...)
C++ signature:     width(TTAMachine::Bus {lvalue}) -> int C++ signature:     width(Bus_wrapper {lvalue}) -> int

zeroExtends(...)
C++ signature:     zeroExtends(TTAMachine::Bus {lvalue}) -> bool C++ signature:     zeroExtends(Bus_wrapper {lvalue}) -> bool

Data descriptors defined here:

OSKEY_EXTENSION

OSKEY_IMMWIDTH

OSKEY_WIDTH

OSNAME_BUS

OSVALUE_SIGN

OSVALUE_ZERO

Data and other attributes defined here:

__instance_size__ = 84

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Component(MachinePart)


Method resolution order:

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name) -> void* C++ signature:     __init__(_object*, ObjectState const* state) -> void*

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::Component {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(Component_wrapper {lvalue}, ObjectState const* state) -> void*

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

saveState(...)
C++ signature:     saveState(TTAMachine::Component {lvalue}) -> ObjectState* C++ signature:     saveState(Component_wrapper {lvalue}) -> ObjectState*

setMachine(...)
C++ signature:     setMachine(TTAMachine::Component {lvalue}, TTAMachine::Machine {lvalue} machine) -> void* C++ signature:     setMachine(Component_wrapper {lvalue}, TTAMachine::Machine {lvalue}) -> void*

setName(...)
C++ signature:     setName(TTAMachine::Component {lvalue}, std::string name) -> void* C++ signature:     setName(Component_wrapper {lvalue}, std::string name) -> void*

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::Component {lvalue}) -> void* C++ signature:     unsetMachine(Component_wrapper {lvalue}) -> void*

Data descriptors defined here:

OSKEY_NAME

OSNAME_COMPONENT

Data and other attributes defined here:

__instance_size__ = 24

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Connection(Boost.Python.instance)


Method resolution order:

Connection

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, TTAMachine::Socket {lvalue} socket, TTAMachine::Segment {lvalue} bus) -> void*

saveState(...)
C++ signature: saveState(TTAMachine::Connection {lvalue}) -> ObjectState*

Data descriptors defined here:

OSKEY_BUS

OSKEY_SEGMENT

OSKEY_SOCKET

OSNAME_CONNECTION

Data and other attributes defined here:

__instance_size__ = 16

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class ControlUnit(FunctionUnit)


Method resolution order:

ControlUnit

FunctionUnit

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, int delaySlots, int globalGuardLatency) -> void* C++ signature:     __init__(_object*, ObjectState const* state) -> void*

copy(...)
C++ signature:     copy(TTAMachine::ControlUnit {lvalue}) -> TTAMachine::ControlUnit* C++ signature:     copy(ControlUnit_wrapper {lvalue}) -> TTAMachine::ControlUnit*

hasReturnAddressPort(...)
C++ signature: hasReturnAddressPort(TTAMachine::ControlUnit {lvalue}) -> bool

hasSpecialRegisterPort(...)
C++ signature: hasSpecialRegisterPort(TTAMachine::ControlUnit {lvalue}, std::string name) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::ControlUnit {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(ControlUnit_wrapper {lvalue}, ObjectState const* state) -> void*

removePort(...)
C++ signature: removePort(ControlUnit_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

returnAddressPort(...)
C++ signature: returnAddressPort(TTAMachine::ControlUnit {lvalue}) -> TTAMachine::SpecialRegisterPort*

saveState(...)
C++ signature:     saveState(TTAMachine::ControlUnit {lvalue}) -> ObjectState* C++ signature:     saveState(ControlUnit_wrapper {lvalue}) -> ObjectState*

setDelaySlots(...)
C++ signature: setDelaySlots(TTAMachine::ControlUnit {lvalue}, int delaySlots) -> void*

setGlobalGuardLatency(...)
C++ signature: setGlobalGuardLatency(TTAMachine::ControlUnit {lvalue}, int latency) -> void*

setMachine(...)
C++ signature:     setMachine(TTAMachine::ControlUnit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(ControlUnit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

setReturnAddressPort(...)
C++ signature: setReturnAddressPort(TTAMachine::ControlUnit {lvalue}, TTAMachine::SpecialRegisterPort port) -> void*

specialRegisterPort(...)
C++ signature:     specialRegisterPort(TTAMachine::ControlUnit {lvalue}, int index) -> TTAMachine::SpecialRegisterPort* C++ signature:     specialRegisterPort(TTAMachine::ControlUnit {lvalue}, std::string name) -> TTAMachine::SpecialRegisterPort*

specialRegisterPortCount(...)
C++ signature: specialRegisterPortCount(TTAMachine::ControlUnit {lvalue}) -> int

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::ControlUnit {lvalue}) -> void* C++ signature:     unsetMachine(ControlUnit_wrapper {lvalue}) -> void*

unsetMachineDerived(...)
C++ signature: unsetMachineDerived(ControlUnit_wrapper {lvalue}) -> void*

unsetReturnAddressPort(...)
C++ signature: unsetReturnAddressPort(TTAMachine::ControlUnit {lvalue}) -> void*

Data descriptors defined here:

OSKEY_DELAY_SLOTS

OSKEY_GUARD_LATENCY

OSKEY_RA_PORT

OSNAME_CONTROL_UNIT

Data and other attributes defined here:

__instance_size__ = 76

Methods inherited from FunctionUnit:

addOperation(...)
C++ signature:     addOperation(TTAMachine::FunctionUnit {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void* C++ signature:     addOperation(FunctionUnit_wrapper {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void*

addPipelineElement(...)
C++ signature:     addPipelineElement(TTAMachine::FunctionUnit {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void* C++ signature:     addPipelineElement(FunctionUnit_wrapper {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void*

addressSpace(...)
C++ signature:     addressSpace(TTAMachine::FunctionUnit {lvalue}) -> TTAMachine::AddressSpace* C++ signature:     addressSpace(FunctionUnit_wrapper {lvalue}) -> TTAMachine::AddressSpace*

cleanup(...)
C++ signature:     cleanup(TTAMachine::FunctionUnit {lvalue}, std::string resource) -> void* C++ signature:     cleanup(FunctionUnit_wrapper {lvalue}, std::string resource) -> void*

deleteOperation(...)
C++ signature:     deleteOperation(TTAMachine::FunctionUnit {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void* C++ signature:     deleteOperation(FunctionUnit_wrapper {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void*

deletePipelineElement(...)
C++ signature:     deletePipelineElement(TTAMachine::FunctionUnit {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void* C++ signature:     deletePipelineElement(FunctionUnit_wrapper {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void*

hasAddressSpace(...)
C++ signature:     hasAddressSpace(TTAMachine::FunctionUnit {lvalue}) -> bool C++ signature:     hasAddressSpace(FunctionUnit_wrapper {lvalue}) -> bool

hasOperation(...)
C++ signature:     hasOperation(TTAMachine::FunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasOperation(FunctionUnit_wrapper {lvalue}, std::string name) -> bool

hasOperationPort(...)
C++ signature:     hasOperationPort(TTAMachine::FunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasOperationPort(FunctionUnit_wrapper {lvalue}, std::string name) -> bool

hasPipelineElement(...)
C++ signature:     hasPipelineElement(TTAMachine::FunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasPipelineElement(FunctionUnit_wrapper {lvalue}, std::string name) -> bool

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::FunctionUnit {lvalue}, TTAMachine::FunctionUnit const* fu, bool checkPortWidths=True) -> bool C++ signature:     isArchitectureEqual(FunctionUnit_wrapper {lvalue}, TTAMachine::FunctionUnit const* fu, bool checkPortWidths=True) -> bool

maxLatency(...)
C++ signature:     maxLatency(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     maxLatency(FunctionUnit_wrapper {lvalue}) -> int

operation(...)
C++ signature:     operation(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::HWOperation* C++ signature:     operation(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::HWOperation* C++ signature:     operation(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::HWOperation* C++ signature:     operation(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::HWOperation*

operationCount(...)
C++ signature:     operationCount(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     operationCount(FunctionUnit_wrapper {lvalue}) -> int

operationPort(...)
C++ signature:     operationPort(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::FUPort* C++ signature:     operationPort(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::FUPort* C++ signature:     operationPort(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::FUPort* C++ signature:     operationPort(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::FUPort*

operationPortCount(...)
C++ signature:     operationPortCount(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     operationPortCount(FunctionUnit_wrapper {lvalue}) -> int

pipelineElement(...)
C++ signature:     pipelineElement(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::PipelineElement*

pipelineElementCount(...)
C++ signature:     pipelineElementCount(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     pipelineElementCount(FunctionUnit_wrapper {lvalue}) -> int

port(...)
C++ signature:     port(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::BaseFUPort* C++ signature:     port(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::BaseFUPort* C++ signature:     port(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::BaseFUPort* C++ signature:     port(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::BaseFUPort*

setAddressSpace(...)
C++ signature:     setAddressSpace(TTAMachine::FunctionUnit {lvalue}, TTAMachine::AddressSpace* as) -> void* C++ signature:     setAddressSpace(FunctionUnit_wrapper {lvalue}, TTAMachine::AddressSpace* as) -> void*

setName(...)
C++ signature:     setName(TTAMachine::FunctionUnit {lvalue}, std::string name) -> void* C++ signature:     setName(FunctionUnit_wrapper {lvalue}, std::string name) -> void*

Data descriptors inherited from FunctionUnit:

OSKEY_AS

OSNAME_FU

Methods inherited from Unit:

hasPort(...)
C++ signature:     hasPort(TTAMachine::Unit {lvalue}, std::string name) -> bool C++ signature:     hasPort(Unit_wrapper {lvalue}, std::string name) -> bool

portCount(...)
C++ signature:     portCount(TTAMachine::Unit {lvalue}) -> int C++ signature:     portCount(Unit_wrapper {lvalue}) -> int

Data descriptors inherited from Unit:

OSNAME_UNIT

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class ExecutionPipeline(SubComponent)


Method resolution order:

ExecutionPipeline

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, TTAMachine::HWOperation {lvalue} parentOperation) -> void*

addPortRead(...)
C++ signature: addPortRead(TTAMachine::ExecutionPipeline {lvalue}, int operand, int start, int duration) -> void*

addPortWrite(...)
C++ signature: addPortWrite(TTAMachine::ExecutionPipeline {lvalue}, int operand, int start, int duration) -> void*

addResourceUse(...)
C++ signature: addResourceUse(TTAMachine::ExecutionPipeline {lvalue}, std::string name, int start, int duration) -> void*

isArchitectureEqual(...)
C++ signature: isArchitectureEqual(TTAMachine::ExecutionPipeline {lvalue}, TTAMachine::ExecutionPipeline const* pipeline) -> bool

isPortRead(...)
C++ signature: isPortRead(TTAMachine::ExecutionPipeline {lvalue}, TTAMachine::FUPort port, int cycle) -> bool

isPortUsed(...)
C++ signature: isPortUsed(TTAMachine::ExecutionPipeline {lvalue}, TTAMachine::FUPort port, int cycle) -> bool

isPortWritten(...)
C++ signature: isPortWritten(TTAMachine::ExecutionPipeline {lvalue}, TTAMachine::FUPort port, int cycle) -> bool

isResourceUsed(...)
C++ signature: isResourceUsed(TTAMachine::ExecutionPipeline {lvalue}, std::string name, int cycle) -> bool

latency(...)
C++ signature:     latency(TTAMachine::ExecutionPipeline {lvalue}) -> int C++ signature:     latency(TTAMachine::ExecutionPipeline {lvalue}, int output) -> int

loadState(...)
C++ signature:     loadState(TTAMachine::ExecutionPipeline {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(ExecutionPipeline_wrapper {lvalue}, ObjectState const* state) -> void*

parentOperation(...)
C++ signature: parentOperation(TTAMachine::ExecutionPipeline {lvalue}) -> TTAMachine::HWOperation const*

readOperands(...)
C++ signature:     readOperands(TTAMachine::ExecutionPipeline {lvalue}, int cycle) -> std::set<int, std::less<int>, std::allocator<int> > C++ signature:     readOperands(TTAMachine::ExecutionPipeline {lvalue}) -> std::set<int, std::less<int>, std::allocator<int> >

removeAllResourceUses(...)
C++ signature: removeAllResourceUses(TTAMachine::ExecutionPipeline {lvalue}) -> void*

removeOperandUse(...)
C++ signature: removeOperandUse(TTAMachine::ExecutionPipeline {lvalue}, int operand, int cycle) -> void*

removeResourceUse(...)
C++ signature:     removeResourceUse(TTAMachine::ExecutionPipeline {lvalue}, std::string name) -> void* C++ signature:     removeResourceUse(TTAMachine::ExecutionPipeline {lvalue}, std::string name, int cycle) -> void*

resourceUsages(...)
C++ signature: resourceUsages(TTAMachine::ExecutionPipeline {lvalue}, int cycle) -> std::set<TTAMachine::PipelineElement*, std::less<TTAMachine::PipelineElement*>, std::allocator<TTAMachine::PipelineElement*> >

saveState(...)
C++ signature:     saveState(TTAMachine::ExecutionPipeline {lvalue}) -> ObjectState* C++ signature:     saveState(ExecutionPipeline_wrapper {lvalue}) -> ObjectState*

slack(...)
C++ signature: slack(TTAMachine::ExecutionPipeline {lvalue}, int input) -> int

writtenOperands(...)
C++ signature:     writtenOperands(TTAMachine::ExecutionPipeline {lvalue}, int cycle) -> std::set<int, std::less<int>, std::allocator<int> > C++ signature:     writtenOperands(TTAMachine::ExecutionPipeline {lvalue}) -> std::set<int, std::less<int>, std::allocator<int> >

Data descriptors defined here:

OSKEY_CYCLES

OSKEY_OPERAND

OSKEY_RESOURCE_NAME

OSKEY_START_CYCLE

OSNAME_OPERAND_READ

OSNAME_OPERAND_WRITE

OSNAME_PIPELINE

OSNAME_RESOURCE_USAGE

Data and other attributes defined here:

__instance_size__ = 56

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class FUPort(BaseFUPort)


Method resolution order:

FUPort

BaseFUPort

Port

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, int width, TTAMachine::FunctionUnit {lvalue} parent, bool triggers, bool setsOpcode) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Unit {lvalue} parent) -> void* C++ signature:     __init__(_object*, std::string name, int width, TTAMachine::FunctionUnit {lvalue} parent, bool triggers, bool setsOpcode, bool dummy) -> void*

bindingString(...)
C++ signature: bindingString(TTAMachine::FUPort {lvalue}) -> std::string

isArchitectureEqual(...)
C++ signature: isArchitectureEqual(TTAMachine::FUPort {lvalue}, TTAMachine::FUPort* port) -> bool

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAMachine::FUPort {lvalue}) -> bool C++ signature:     isOpcodeSetting(FUPort_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAMachine::FUPort {lvalue}) -> bool C++ signature:     isTriggering(FUPort_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::FUPort {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(FUPort_wrapper {lvalue}, ObjectState const* state) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::FUPort {lvalue}) -> ObjectState* C++ signature:     saveState(FUPort_wrapper {lvalue}) -> ObjectState*

setOpcodeSetting(...)
C++ signature: setOpcodeSetting(TTAMachine::FUPort {lvalue}, bool setsOpcode) -> void*

setTriggering(...)
C++ signature: setTriggering(TTAMachine::FUPort {lvalue}, bool triggers) -> void*

updateBindingString(...)
C++ signature: updateBindingString(TTAMachine::FUPort {lvalue}) -> void*

Data descriptors defined here:

OSKEY_OPCODE_SETTING

OSKEY_TRIGGERING

OSNAME_FUPORT

Data and other attributes defined here:

__instance_size__ = 44

Methods inherited from BaseFUPort:

parentUnit(...)
C++ signature: parentUnit(TTAMachine::BaseFUPort {lvalue}) -> TTAMachine::FunctionUnit*

setWidth(...)
C++ signature: setWidth(TTAMachine::BaseFUPort {lvalue}, int width) -> void*

width(...)
C++ signature:     width(TTAMachine::BaseFUPort {lvalue}) -> int C++ signature:     width(BaseFUPort_wrapper {lvalue}) -> int

Data descriptors inherited from BaseFUPort:

OSKEY_WIDTH

Methods inherited from Port:

attachSocket(...)
C++ signature:     attachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     attachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

detachAllSockets(...)
C++ signature:     detachAllSockets(TTAMachine::Port {lvalue}) -> void* C++ signature:     detachAllSockets(Port_wrapper {lvalue}) -> void*

detachSocket(...)
C++ signature:     detachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     detachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

inputSocket(...)
C++ signature:     inputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     inputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::Port {lvalue}, TTAMachine::Socket socket) -> bool C++ signature:     isConnectedTo(Port_wrapper {lvalue}, TTAMachine::Socket socket) -> bool

isInput(...)
C++ signature:     isInput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isInput(Port_wrapper {lvalue}) -> bool

isOutput(...)
C++ signature:     isOutput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isOutput(Port_wrapper {lvalue}) -> bool

name(...)
C++ signature:     name(TTAMachine::Port {lvalue}) -> std::string C++ signature:     name(Port_wrapper {lvalue}) -> std::string

outputSocket(...)
C++ signature:     outputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     outputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

setName(...)
C++ signature:     setName(TTAMachine::Port {lvalue}, std::string name) -> void* C++ signature:     setName(Port_wrapper {lvalue}, std::string name) -> void*

socketCount(...)
C++ signature:     socketCount(TTAMachine::Port {lvalue}) -> int C++ signature:     socketCount(Port_wrapper {lvalue}) -> int

unconnectedSocket(...)
C++ signature:     unconnectedSocket(TTAMachine::Port {lvalue}, int index) -> TTAMachine::Socket* C++ signature:     unconnectedSocket(Port_wrapper {lvalue}, int index) -> TTAMachine::Socket*

Data descriptors inherited from Port:

OSKEY_FIRST_SOCKET

OSKEY_NAME

OSKEY_SECOND_SOCKET

OSNAME_PORT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class FunctionUnit(Unit)


Method resolution order:

FunctionUnit

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name) -> void* C++ signature:     __init__(_object*, ObjectState const* state) -> void*

addOperation(...)
C++ signature:     addOperation(TTAMachine::FunctionUnit {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void* C++ signature:     addOperation(FunctionUnit_wrapper {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void*

addPipelineElement(...)
C++ signature:     addPipelineElement(TTAMachine::FunctionUnit {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void* C++ signature:     addPipelineElement(FunctionUnit_wrapper {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void*

addressSpace(...)
C++ signature:     addressSpace(TTAMachine::FunctionUnit {lvalue}) -> TTAMachine::AddressSpace* C++ signature:     addressSpace(FunctionUnit_wrapper {lvalue}) -> TTAMachine::AddressSpace*

cleanup(...)
C++ signature:     cleanup(TTAMachine::FunctionUnit {lvalue}, std::string resource) -> void* C++ signature:     cleanup(FunctionUnit_wrapper {lvalue}, std::string resource) -> void*

copy(...)
C++ signature:     copy(TTAMachine::FunctionUnit {lvalue}) -> TTAMachine::FunctionUnit* C++ signature:     copy(FunctionUnit_wrapper {lvalue}) -> TTAMachine::FunctionUnit*

deleteOperation(...)
C++ signature:     deleteOperation(TTAMachine::FunctionUnit {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void* C++ signature:     deleteOperation(FunctionUnit_wrapper {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void*

deletePipelineElement(...)
C++ signature:     deletePipelineElement(TTAMachine::FunctionUnit {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void* C++ signature:     deletePipelineElement(FunctionUnit_wrapper {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void*

hasAddressSpace(...)
C++ signature:     hasAddressSpace(TTAMachine::FunctionUnit {lvalue}) -> bool C++ signature:     hasAddressSpace(FunctionUnit_wrapper {lvalue}) -> bool

hasOperation(...)
C++ signature:     hasOperation(TTAMachine::FunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasOperation(FunctionUnit_wrapper {lvalue}, std::string name) -> bool

hasOperationPort(...)
C++ signature:     hasOperationPort(TTAMachine::FunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasOperationPort(FunctionUnit_wrapper {lvalue}, std::string name) -> bool

hasPipelineElement(...)
C++ signature:     hasPipelineElement(TTAMachine::FunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasPipelineElement(FunctionUnit_wrapper {lvalue}, std::string name) -> bool

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::FunctionUnit {lvalue}, TTAMachine::FunctionUnit const* fu, bool checkPortWidths=True) -> bool C++ signature:     isArchitectureEqual(FunctionUnit_wrapper {lvalue}, TTAMachine::FunctionUnit const* fu, bool checkPortWidths=True) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::FunctionUnit {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(FunctionUnit_wrapper {lvalue}, ObjectState const* state) -> void*

maxLatency(...)
C++ signature:     maxLatency(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     maxLatency(FunctionUnit_wrapper {lvalue}) -> int

operation(...)
C++ signature:     operation(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::HWOperation* C++ signature:     operation(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::HWOperation* C++ signature:     operation(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::HWOperation* C++ signature:     operation(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::HWOperation*

operationCount(...)
C++ signature:     operationCount(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     operationCount(FunctionUnit_wrapper {lvalue}) -> int

operationPort(...)
C++ signature:     operationPort(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::FUPort* C++ signature:     operationPort(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::FUPort* C++ signature:     operationPort(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::FUPort* C++ signature:     operationPort(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::FUPort*

operationPortCount(...)
C++ signature:     operationPortCount(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     operationPortCount(FunctionUnit_wrapper {lvalue}) -> int

pipelineElement(...)
C++ signature:     pipelineElement(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::PipelineElement*

pipelineElementCount(...)
C++ signature:     pipelineElementCount(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     pipelineElementCount(FunctionUnit_wrapper {lvalue}) -> int

port(...)
C++ signature:     port(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::BaseFUPort* C++ signature:     port(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::BaseFUPort* C++ signature:     port(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::BaseFUPort* C++ signature:     port(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::BaseFUPort*

removePort(...)
C++ signature: removePort(FunctionUnit_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::FunctionUnit {lvalue}) -> ObjectState* C++ signature:     saveState(FunctionUnit_wrapper {lvalue}) -> ObjectState*

setAddressSpace(...)
C++ signature:     setAddressSpace(TTAMachine::FunctionUnit {lvalue}, TTAMachine::AddressSpace* as) -> void* C++ signature:     setAddressSpace(FunctionUnit_wrapper {lvalue}, TTAMachine::AddressSpace* as) -> void*

setName(...)
C++ signature:     setName(TTAMachine::FunctionUnit {lvalue}, std::string name) -> void* C++ signature:     setName(FunctionUnit_wrapper {lvalue}, std::string name) -> void*

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::FunctionUnit {lvalue}) -> void* C++ signature:     unsetMachine(FunctionUnit_wrapper {lvalue}) -> void*

unsetMachineDerived(...)
C++ signature: unsetMachineDerived(FunctionUnit_wrapper {lvalue}) -> void*

Data descriptors defined here:

OSKEY_AS

OSNAME_FU

Data and other attributes defined here:

__instance_size__ = 64

Methods inherited from Unit:

hasPort(...)
C++ signature:     hasPort(TTAMachine::Unit {lvalue}, std::string name) -> bool C++ signature:     hasPort(Unit_wrapper {lvalue}, std::string name) -> bool

portCount(...)
C++ signature:     portCount(TTAMachine::Unit {lvalue}) -> int C++ signature:     portCount(Unit_wrapper {lvalue}) -> int

setMachine(...)
C++ signature:     setMachine(TTAMachine::Unit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(Unit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

Data descriptors inherited from Unit:

OSNAME_UNIT

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Guard(SubComponent)


Method resolution order:

Guard

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, bool inverted, TTAMachine::Bus {lvalue} parentBus) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Bus {lvalue} parentBus) -> void*

isDisjoint(...)
C++ signature:     isDisjoint(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isDisjoint(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

isEqual(...)
C++ signature:     isEqual(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isEqual(Guard_wrapper {lvalue}, TTAMachine::Guard) -> void*

isLessRestrictive(...)
C++ signature:     isLessRestrictive(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isLessRestrictive(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

isMoreRestrictive(...)
C++ signature:     isMoreRestrictive(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isMoreRestrictive(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::Guard {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(Guard_wrapper {lvalue}, ObjectState const* state) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::Guard {lvalue}) -> ObjectState* C++ signature:     saveState(Guard_wrapper {lvalue}) -> ObjectState*

Data descriptors defined here:

OSKEY_INVERTED

OSNAME_GUARD

Data and other attributes defined here:

__instance_size__ = 24

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class HWOperation(SubComponent)


Method resolution order:

HWOperation

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, TTAMachine::FunctionUnit {lvalue} parent) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::FunctionUnit {lvalue} parent) -> void*

bindPort(...)
C++ signature:     bindPort(TTAMachine::HWOperation {lvalue}, int operand, TTAMachine::FUPort port) -> void* C++ signature:     bindPort(HWOperation_wrapper {lvalue}, int operand, TTAMachine::FUPort port) -> void*

io(...)
C++ signature: io(TTAMachine::HWOperation {lvalue}, TTAMachine::FUPort port) -> int

isBound(...)
C++ signature: isBound(TTAMachine::HWOperation {lvalue}, TTAMachine::FUPort port) -> bool

latency(...)
C++ signature:     latency(TTAMachine::HWOperation {lvalue}) -> int C++ signature:     latency(TTAMachine::HWOperation {lvalue}, int output) -> int

loadState(...)
C++ signature:     loadState(TTAMachine::HWOperation {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(HWOperation_wrapper {lvalue}, ObjectState const* state) -> void*

name(...)
C++ signature: name(TTAMachine::HWOperation {lvalue}) -> std::string

parentUnit(...)
C++ signature: parentUnit(TTAMachine::HWOperation {lvalue}) -> TTAMachine::FunctionUnit*

pipeline(...)
C++ signature: pipeline(TTAMachine::HWOperation {lvalue}) -> TTAMachine::ExecutionPipeline*

port(...)
C++ signature:     port(TTAMachine::HWOperation {lvalue}, int operand) -> TTAMachine::FUPort* C++ signature:     port(HWOperation_wrapper {lvalue}, int operand) -> TTAMachine::FUPort*

saveState(...)
C++ signature:     saveState(TTAMachine::HWOperation {lvalue}) -> ObjectState* C++ signature:     saveState(HWOperation_wrapper {lvalue}) -> ObjectState*

setName(...)
C++ signature:     setName(TTAMachine::HWOperation {lvalue}, std::string name) -> void* C++ signature:     setName(HWOperation_wrapper {lvalue}, std::string name) -> void*

slack(...)
C++ signature: slack(TTAMachine::HWOperation {lvalue}, int input) -> int

unbindPort(...)
C++ signature:     unbindPort(TTAMachine::HWOperation {lvalue}, TTAMachine::FUPort port) -> void* C++ signature:     unbindPort(HWOperation_wrapper {lvalue}, TTAMachine::FUPort port) -> void*

Data descriptors defined here:

OSKEY_NAME

OSKEY_OPERAND

OSKEY_PORT

OSNAME_OPERAND_BINDING

OSNAME_OPERATION

Data and other attributes defined here:

__instance_size__ = 52

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class ImmediateSlot(Component)


Method resolution order:

ImmediateSlot

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, TTAMachine::Machine {lvalue} parent) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Machine {lvalue} parent) -> void*

loadState(...)
C++ signature:     loadState(TTAMachine::ImmediateSlot {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(ImmediateSlot_wrapper {lvalue}, ObjectState const* state) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::ImmediateSlot {lvalue}) -> ObjectState* C++ signature:     saveState(ImmediateSlot_wrapper {lvalue}) -> ObjectState*

setMachine(...)
C++ signature:     setMachine(TTAMachine::ImmediateSlot {lvalue}, TTAMachine::Machine {lvalue} machine) -> void* C++ signature:     setMachine(ImmediateSlot_wrapper {lvalue}, TTAMachine::Machine {lvalue} machine) -> void*

setName(...)
C++ signature:     setName(TTAMachine::ImmediateSlot {lvalue}, std::string name) -> void* C++ signature:     setName(ImmediateSlot_wrapper {lvalue}, std::string name) -> void*

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::ImmediateSlot {lvalue}) -> void* C++ signature:     unsetMachine(ImmediateSlot_wrapper {lvalue}) -> void*

width(...)
C++ signature: width(TTAMachine::ImmediateSlot {lvalue}) -> int

Data descriptors defined here:

OSNAME_IMMEDIATE_SLOT

Data and other attributes defined here:

__instance_size__ = 24

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class ImmediateUnit(RegisterFile)


Method resolution order:

ImmediateUnit

RegisterFile

BaseRegisterFile

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, unsigned int size, unsigned int width, unsigned int maxReads, unsigned int guardLatency, TTAMachine::Machine::Extension extension) -> void* C++ signature:     __init__(_object*, ObjectState const* state) -> void*

extensionMode(...)
C++ signature:     extensionMode(TTAMachine::ImmediateUnit {lvalue}) -> TTAMachine::Machine::Extension C++ signature:     extensionMode(ImmediateUnit_wrapper {lvalue}) -> TTAMachine::Machine::Extension

latency(...)
C++ signature:     latency(TTAMachine::ImmediateUnit {lvalue}) -> int C++ signature:     latency(ImmediateUnit_wrapper {lvalue}) -> int

loadState(...)
C++ signature:     loadState(TTAMachine::ImmediateUnit {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(ImmediateUnit_wrapper {lvalue}, ObjectState const* state) -> void*

removePort(...)
C++ signature: removePort(ImmediateUnit_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::ImmediateUnit {lvalue}) -> ObjectState* C++ signature:     saveState(ImmediateUnit_wrapper {lvalue}) -> ObjectState*

setExtensionMode(...)
C++ signature:     setExtensionMode(TTAMachine::ImmediateUnit {lvalue}, TTAMachine::Machine::Extension mode) -> void* C++ signature:     setExtensionMode(ImmediateUnit_wrapper {lvalue}, TTAMachine::Machine::Extension mode) -> void*

setMaxWrites(...)
C++ signature:     setMaxWrites(TTAMachine::ImmediateUnit {lvalue}, int maxWrites) -> void* C++ signature:     setMaxWrites(ImmediateUnit_wrapper {lvalue}, int maxWrites) -> void*

setName(...)
C++ signature:     setName(TTAMachine::ImmediateUnit {lvalue}, std::string name) -> void* C++ signature:     setName(ImmediateUnit_wrapper {lvalue}, std::string name) -> void*

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::ImmediateUnit {lvalue}) -> void* C++ signature:     unsetMachine(ImmediateUnit_wrapper {lvalue}) -> void*

Data descriptors defined here:

OSKEY_EXTENSION

OSKEY_LATENCY

OSNAME_IMMEDIATE_UNIT

OSVALUE_SIGN

OSVALUE_ZERO

Data and other attributes defined here:

__instance_size__ = 68

Methods inherited from RegisterFile:

copy(...)
C++ signature:     copy(TTAMachine::RegisterFile {lvalue}) -> TTAMachine::RegisterFile* C++ signature:     copy(RegisterFile_wrapper {lvalue}) -> TTAMachine::RegisterFile*

guardLatency(...)
C++ signature:     guardLatency(TTAMachine::RegisterFile {lvalue}) -> int C++ signature:     guardLatency(RegisterFile_wrapper {lvalue}) -> int

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::RegisterFile {lvalue}, TTAMachine::RegisterFile rf) -> bool C++ signature:     isArchitectureEqual(RegisterFile_wrapper {lvalue}, TTAMachine::RegisterFile rf) -> bool

isNormal(...)
C++ signature:     isNormal(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isNormal(RegisterFile_wrapper {lvalue}) -> bool

isReserved(...)
C++ signature:     isReserved(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isReserved(RegisterFile_wrapper {lvalue}) -> bool

isUsedAsGuard(...)
C++ signature:     isUsedAsGuard(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isUsedAsGuard(RegisterFile_wrapper {lvalue}) -> bool

isVolatile(...)
C++ signature:     isVolatile(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isVolatile(RegisterFile_wrapper {lvalue}) -> bool

maxReads(...)
C++ signature:     maxReads(TTAMachine::RegisterFile {lvalue}) -> int C++ signature:     maxReads(RegisterFile_wrapper {lvalue}) -> int

maxWrites(...)
C++ signature:     maxWrites(TTAMachine::RegisterFile {lvalue}) -> int C++ signature:     maxWrites(RegisterFile_wrapper {lvalue}) -> int

setGuardLatency(...)
C++ signature:     setGuardLatency(TTAMachine::RegisterFile {lvalue}, int latency) -> void* C++ signature:     setGuardLatency(RegisterFile_wrapper {lvalue}, int latency) -> void*

setMaxReads(...)
C++ signature:     setMaxReads(TTAMachine::RegisterFile {lvalue}, int maxReads) -> void* C++ signature:     setMaxReads(RegisterFile_wrapper {lvalue}, int maxReads) -> void*

setNumberOfRegisters(...)
C++ signature:     setNumberOfRegisters(TTAMachine::RegisterFile {lvalue}, int registers) -> void* C++ signature:     setNumberOfRegisters(RegisterFile_wrapper {lvalue}, int registers) -> void*

setType(...)
C++ signature:     setType(TTAMachine::RegisterFile {lvalue}, TTAMachine::RegisterFile::Type type) -> void* C++ signature:     setType(RegisterFile_wrapper {lvalue}, TTAMachine::RegisterFile::Type type) -> void*

type(...)
C++ signature:     type(TTAMachine::RegisterFile {lvalue}) -> TTAMachine::RegisterFile::Type C++ signature:     type(RegisterFile_wrapper {lvalue}) -> TTAMachine::RegisterFile::Type

updateMaxReadsAndWrites(...)
C++ signature: updateMaxReadsAndWrites(TTAMachine::RegisterFile {lvalue}) -> bool

Data descriptors inherited from RegisterFile:

OSKEY_GUARD_LATENCY

OSKEY_MAX_READS

OSKEY_MAX_WRITES

OSKEY_TYPE

OSNAME_REGISTER_FILE

OSVALUE_NORMAL

OSVALUE_RESERVED

OSVALUE_VOLATILE

Data and other attributes inherited from RegisterFile:

NORMAL = TCE.base.mach.Type.NORMAL

RESERVED = TCE.base.mach.Type.RESERVED

Type = <class 'TCE.base.TCE.base.mach.Type'>

VOLATILE = TCE.base.mach.Type.VOLATILE

Methods inherited from BaseRegisterFile:

port(...)
C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, int index) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, int index) -> TTAMachine::RFPort*

setWidth(...)
C++ signature:     setWidth(TTAMachine::BaseRegisterFile {lvalue}, int width) -> void* C++ signature:     setWidth(BaseRegisterFile_wrapper {lvalue}, int width) -> void*

Data descriptors inherited from BaseRegisterFile:

OSKEY_SIZE

OSKEY_WIDTH

OSNAME_BASE_REGISTER_FILE

Methods inherited from Unit:

hasPort(...)
C++ signature:     hasPort(TTAMachine::Unit {lvalue}, std::string name) -> bool C++ signature:     hasPort(Unit_wrapper {lvalue}, std::string name) -> bool

portCount(...)
C++ signature:     portCount(TTAMachine::Unit {lvalue}) -> int C++ signature:     portCount(Unit_wrapper {lvalue}) -> int

setMachine(...)
C++ signature:     setMachine(TTAMachine::Unit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(Unit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

Data descriptors inherited from Unit:

OSNAME_UNIT

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class InstructionTemplate(Component)


Method resolution order:

InstructionTemplate

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, TTAMachine::Machine {lvalue} owner) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Machine {lvalue} owner) -> void*

addSlot(...)
C++ signature:     addSlot(TTAMachine::InstructionTemplate {lvalue}, std::string slotName, int width, TTAMachine::ImmediateUnit {lvalue} dstUnit) -> void* C++ signature:     addSlot(InstructionTemplate_wrapper {lvalue}, std::string slotName, int width, TTAMachine::ImmediateUnit {lvalue} dstUnit) -> void*

destinationOfSlot(...)
C++ signature:     destinationOfSlot(TTAMachine::InstructionTemplate {lvalue}, std::string slotName) -> TTAMachine::ImmediateUnit* C++ signature:     destinationOfSlot(InstructionTemplate_wrapper {lvalue}, std::string slotName) -> TTAMachine::ImmediateUnit*

destinationUsesSlot(...)
C++ signature:     destinationUsesSlot(TTAMachine::InstructionTemplate {lvalue}, std::string slotName, TTAMachine::ImmediateUnit dstUnit) -> bool C++ signature:     destinationUsesSlot(InstructionTemplate_wrapper {lvalue}, std::string slotName, TTAMachine::ImmediateUnit dstUnit) -> bool

isEmpty(...)
C++ signature:     isEmpty(TTAMachine::InstructionTemplate {lvalue}) -> bool C++ signature:     isEmpty(InstructionTemplate_wrapper {lvalue}) -> bool

isOneOfDestinations(...)
C++ signature:     isOneOfDestinations(TTAMachine::InstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> bool C++ signature:     isOneOfDestinations(InstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::InstructionTemplate {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(InstructionTemplate_wrapper {lvalue}, ObjectState const* state) -> void*

numberOfDestinations(...)
C++ signature:     numberOfDestinations(TTAMachine::InstructionTemplate {lvalue}) -> int C++ signature:     numberOfDestinations(InstructionTemplate_wrapper {lvalue}) -> int

numberOfSlots(...)
C++ signature:     numberOfSlots(TTAMachine::InstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> int C++ signature:     numberOfSlots(InstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> int

removeSlot(...)
C++ signature:     removeSlot(TTAMachine::InstructionTemplate {lvalue}, std::string slotName) -> void* C++ signature:     removeSlot(InstructionTemplate_wrapper {lvalue}, std::string slotName) -> void*

removeSlots(...)
C++ signature:     removeSlots(TTAMachine::InstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> void* C++ signature:     removeSlots(InstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::InstructionTemplate {lvalue}) -> ObjectState* C++ signature:     saveState(InstructionTemplate_wrapper {lvalue}) -> ObjectState*

setMachine(...)
C++ signature:     setMachine(TTAMachine::InstructionTemplate {lvalue}, TTAMachine::Machine {lvalue} machine) -> void* C++ signature:     setMachine(InstructionTemplate_wrapper {lvalue}, TTAMachine::Machine {lvalue} machine) -> void*

setName(...)
C++ signature:     setName(TTAMachine::InstructionTemplate {lvalue}, std::string name) -> void* C++ signature:     setName(InstructionTemplate_wrapper {lvalue}, std::string name) -> void*

slot(...)
C++ signature:     slot(TTAMachine::InstructionTemplate {lvalue}, int index) -> TTAMachine::TemplateSlot* C++ signature:     slot(InstructionTemplate_wrapper {lvalue}, int index) -> TTAMachine::TemplateSlot*

slotCount(...)
C++ signature:     slotCount(TTAMachine::InstructionTemplate {lvalue}) -> int C++ signature:     slotCount(InstructionTemplate_wrapper {lvalue}) -> int

slotOfDestination(...)
C++ signature:     slotOfDestination(TTAMachine::InstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit, int index) -> std::string C++ signature:     slotOfDestination(InstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit, int index) -> std::string

supportedWidth(...)
C++ signature:     supportedWidth(TTAMachine::InstructionTemplate {lvalue}) -> int C++ signature:     supportedWidth(InstructionTemplate_wrapper {lvalue}) -> int C++ signature:     supportedWidth(TTAMachine::InstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> int C++ signature:     supportedWidth(InstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> int C++ signature:     supportedWidth(TTAMachine::InstructionTemplate {lvalue}, std::string slotName) -> int C++ signature:     supportedWidth(InstructionTemplate_wrapper {lvalue}, std::string slotName) -> int

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::InstructionTemplate {lvalue}) -> void* C++ signature:     unsetMachine(InstructionTemplate_wrapper {lvalue}) -> void*

usesSlot(...)
C++ signature:     usesSlot(TTAMachine::InstructionTemplate {lvalue}, std::string slotName) -> bool C++ signature:     usesSlot(InstructionTemplate_wrapper {lvalue}, std::string slotName) -> bool

Data descriptors defined here:

OSNAME_INSTRUCTION_TEMPLATE

Data and other attributes defined here:

__instance_size__ = 36

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Machine(Boost.Python.instance)


Method resolution order:

Machine

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*, TTAMachine::Machine old) -> void*

addAddressSpace(...)
C++ signature:     addAddressSpace(TTAMachine::Machine {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void* C++ signature:     addAddressSpace(Machine_wrapper {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void*

addBridge(...)
C++ signature:     addBridge(TTAMachine::Machine {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     addBridge(Machine_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

addBus(...)
C++ signature:     addBus(TTAMachine::Machine {lvalue}, TTAMachine::Bus {lvalue} bus) -> void* C++ signature:     addBus(Machine_wrapper {lvalue}, TTAMachine::Bus {lvalue} bus) -> void*

addFunctionUnit(...)
C++ signature:     addFunctionUnit(TTAMachine::Machine {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void* C++ signature:     addFunctionUnit(Machine_wrapper {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void*

addImmediateSlot(...)
C++ signature:     addImmediateSlot(TTAMachine::Machine {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void* C++ signature:     addImmediateSlot(Machine_wrapper {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void*

addImmediateUnit(...)
C++ signature:     addImmediateUnit(TTAMachine::Machine {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void* C++ signature:     addImmediateUnit(Machine_wrapper {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void*

addInstructionTemplate(...)
C++ signature:     addInstructionTemplate(TTAMachine::Machine {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void* C++ signature:     addInstructionTemplate(Machine_wrapper {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void*

addRegisterFile(...)
C++ signature:     addRegisterFile(TTAMachine::Machine {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void* C++ signature:     addRegisterFile(Machine_wrapper {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void*

addSocket(...)
C++ signature:     addSocket(TTAMachine::Machine {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     addSocket(Machine_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

addUnit(...)
C++ signature: addUnit(TTAMachine::Machine {lvalue}, TTAMachine::Unit {lvalue} unit) -> void*

addressSpaceNavigator(...)
C++ signature:     addressSpaceNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::AddressSpace> C++ signature:     addressSpaceNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::AddressSpace>

bridgeNavigator(...)
C++ signature:     bridgeNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bridge> C++ signature:     bridgeNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bridge>

busNavigator(...)
C++ signature:     busNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bus> C++ signature:     busNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bus>

controlUnit(...)
C++ signature:     controlUnit(TTAMachine::Machine {lvalue}) -> TTAMachine::ControlUnit* C++ signature:     controlUnit(Machine_wrapper {lvalue}) -> TTAMachine::ControlUnit*

deleteAddressSpace(...)
C++ signature:     deleteAddressSpace(TTAMachine::Machine {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void* C++ signature:     deleteAddressSpace(Machine_wrapper {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void*

deleteBridge(...)
C++ signature:     deleteBridge(TTAMachine::Machine {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     deleteBridge(Machine_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

deleteImmediateSlot(...)
C++ signature:     deleteImmediateSlot(TTAMachine::Machine {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void* C++ signature:     deleteImmediateSlot(Machine_wrapper {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void*

deleteInstructionTemplate(...)
C++ signature:     deleteInstructionTemplate(TTAMachine::Machine {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void* C++ signature:     deleteInstructionTemplate(Machine_wrapper {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void*

functionUnitNavigator(...)
C++ signature:     functionUnitNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::FunctionUnit> C++ signature:     functionUnitNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::FunctionUnit>

immediateSlotNavigator(...)
C++ signature:     immediateSlotNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateSlot> C++ signature:     immediateSlotNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateSlot>

immediateUnitNavigator(...)
C++ signature:     immediateUnitNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateUnit> C++ signature:     immediateUnitNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateUnit>

instructionTemplateNavigator(...)
C++ signature:     instructionTemplateNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::InstructionTemplate> C++ signature:     instructionTemplateNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::InstructionTemplate>

loadState(...)
C++ signature:     loadState(TTAMachine::Machine {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(Machine_wrapper {lvalue}, ObjectState const* state) -> void*

machineTester(...)
C++ signature: machineTester(TTAMachine::Machine {lvalue}) -> MachineTester

registerFileNavigator(...)
C++ signature:     registerFileNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::RegisterFile> C++ signature:     registerFileNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::RegisterFile>

removeBus(...)
C++ signature:     removeBus(TTAMachine::Machine {lvalue}, TTAMachine::Bus {lvalue} bus) -> void* C++ signature:     removeBus(Machine_wrapper {lvalue}, TTAMachine::Bus {lvalue} bus) -> void*

removeFunctionUnit(...)
C++ signature:     removeFunctionUnit(TTAMachine::Machine {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void* C++ signature:     removeFunctionUnit(Machine_wrapper {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void*

removeImmediateUnit(...)
C++ signature:     removeImmediateUnit(TTAMachine::Machine {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void* C++ signature:     removeImmediateUnit(Machine_wrapper {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void*

removeRegisterFile(...)
C++ signature:     removeRegisterFile(TTAMachine::Machine {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void* C++ signature:     removeRegisterFile(Machine_wrapper {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void*

removeSocket(...)
C++ signature:     removeSocket(TTAMachine::Machine {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     removeSocket(Machine_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

removeUnit(...)
C++ signature:     removeUnit(TTAMachine::Machine {lvalue}, TTAMachine::Unit {lvalue} unit) -> void* C++ signature:     removeUnit(Machine_wrapper {lvalue}, TTAMachine::Unit {lvalue} unit) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::Machine {lvalue}) -> ObjectState* C++ signature:     saveState(Machine_wrapper {lvalue}) -> ObjectState*

setBusPosition(...)
C++ signature: setBusPosition(TTAMachine::Machine {lvalue}, TTAMachine::Bus bus, int newPosition) -> void*

setGlobalControl(...)
C++ signature:     setGlobalControl(TTAMachine::Machine {lvalue}, TTAMachine::ControlUnit {lvalue} unit) -> void* C++ signature:     setGlobalControl(Machine_wrapper {lvalue}, TTAMachine::ControlUnit {lvalue} unit) -> void*

socketNavigator(...)
C++ signature:     socketNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Socket> C++ signature:     socketNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Socket>

unsetGlobalControl(...)
C++ signature:     unsetGlobalControl(TTAMachine::Machine {lvalue}) -> void* C++ signature:     unsetGlobalControl(Machine_wrapper {lvalue}) -> void*

Static methods defined here:

loadFromADF(...)
C++ signature: loadFromADF(std::string adfFileName) -> TTAMachine::Machine*

Data descriptors defined here:

OSNAME_MACHINE

Data and other attributes defined here:

Extension = <class 'TCE.base.TCE.base.mach.Extension'>

SIGN = TCE.base.mach.Extension.SIGN

ZERO = TCE.base.mach.Extension.ZERO

__instance_size__ = 144

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class MachinePart(Boost.Python.instance)


Method resolution order:

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

loadState(...)
C++ signature:     loadState(TTAMachine::MachinePart {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(MachinePart_wrapper {lvalue}, ObjectState const*) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::MachinePart {lvalue}) -> ObjectState* C++ signature:     saveState(MachinePart_wrapper {lvalue}) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class MachineTestReportTextGenerator(Boost.Python.instance)


Method resolution order:

MachineTestReportTextGenerator

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*) -> void*

Data and other attributes defined here:

TXT_BRIDGE_BRANCHED_BUS = 23

TXT_BRIDGE_EXISTS = 22

TXT_BRIDGE_ILLEGAL_REG = 20

TXT_BRIDGE_LOOP = 21

TXT_SOCKET_DIR_UNKNOWN = 24

TXT_SOCKET_FORBIDDEN_DIR = 27

TXT_SOCKET_NO_CONN = 25

TXT_SOCKET_PORT_CONN_EXISTS = 16

TXT_SOCKET_PORT_CONN_ILLEGAL_REG = 15

TXT_SOCKET_PORT_CONN_MAX_CONN = 19

TXT_SOCKET_PORT_CONN_RF_PORT_CONN_EXISTS = 17

TXT_SOCKET_PORT_CONN_WRONG_SOCKET_DIR = 18

TXT_SOCKET_SAME_DIR_CONN = 26

TXT_SOCKET_SEGMENT_CONN_BOTH_DIRS_ARE_ILLEGAL = 14

TXT_SOCKET_SEGMENT_CONN_EXISTS = 12

TXT_SOCKET_SEGMENT_CONN_ILLEGAL_REG = 13

__instance_size__ = 36

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class MachineTestReporter(Boost.Python.instance)


Method resolution order:

MachineTestReporter

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

Static methods defined here:

bridgingError(...)
C++ signature: bridgingError(TTAMachine::Bus sourceBus, TTAMachine::Bus destinationBus, MachineTester tester) -> std::string

socketDirectionSettingError(...)
C++ signature: socketDirectionSettingError(TTAMachine::Socket socket, TTAMachine::Socket::Direction arg1, MachineTester tester) -> std::string

socketPortConnectionError(...)
C++ signature: socketPortConnectionError(TTAMachine::Socket socket, TTAMachine::Port port, MachineTester tester) -> std::string

socketSegmentConnectionError(...)
C++ signature: socketSegmentConnectionError(TTAMachine::Socket socket, TTAMachine::Segment segment, MachineTester tester) -> std::string

Data and other attributes defined here:

__instance_size__ = 12

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class MachineTester(Boost.Python.instance)


Method resolution order:

MachineTester

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, TTAMachine::Machine machine) -> void*

branchedBus(...)
C++ signature: branchedBus(MachineTester {lvalue}) -> TTAMachine::Bus*

canBridge(...)
C++ signature:     canBridge(MachineTester {lvalue}, TTAMachine::Bus source, TTAMachine::Bus destination) -> bool C++ signature:     canBridge(MachineTester_wrapper {lvalue}, TTAMachine::Bus source, TTAMachine::Bus destination) -> bool

canConnect(...)
C++ signature:     canConnect(MachineTester {lvalue}, TTAMachine::Socket socket, TTAMachine::Segment segment) -> bool C++ signature:     canConnect(MachineTester_wrapper {lvalue}, TTAMachine::Socket socket, TTAMachine::Segment segment) -> bool C++ signature:     canConnect(MachineTester {lvalue}, TTAMachine::Socket socket, TTAMachine::Port port) -> bool C++ signature:     canConnect(MachineTester_wrapper {lvalue}, TTAMachine::Socket socket, TTAMachine::Port port) -> bool

canSetDirection(...)
C++ signature:     canSetDirection(MachineTester {lvalue}, TTAMachine::Socket socket, TTAMachine::Socket::Direction direction) -> bool C++ signature:     canSetDirection(MachineTester_wrapper {lvalue}, TTAMachine::Socket socket, TTAMachine::Socket::Direction direction) -> bool

connectionExists(...)
C++ signature: connectionExists(MachineTester {lvalue}) -> bool

forbiddenSocketDirection(...)
C++ signature: forbiddenSocketDirection(MachineTester {lvalue}, TTAMachine::Socket::Direction direction) -> TTAMachine::Port*

illegalRegistration(...)
C++ signature: illegalRegistration(MachineTester {lvalue}) -> bool

loop(...)
C++ signature: loop(MachineTester {lvalue}) -> bool

maxConnections(...)
C++ signature: maxConnections(MachineTester {lvalue}) -> bool

noConnections(...)
C++ signature: noConnections(MachineTester {lvalue}) -> bool

registerFilePortAlreadyConnected(...)
C++ signature: registerFilePortAlreadyConnected(MachineTester {lvalue}) -> bool

sameDirSocketConnection(...)
C++ signature: sameDirSocketConnection(MachineTester {lvalue}, TTAMachine::Socket::Direction direction) -> TTAMachine::Port*

unknownSocketDirection(...)
C++ signature: unknownSocketDirection(MachineTester {lvalue}) -> bool

wrongSocketDirection(...)
C++ signature: wrongSocketDirection(MachineTester {lvalue}) -> bool

Static methods defined here:

isValidComponentName(...)
C++ signature: isValidComponentName(std::string name) -> bool

Data and other attributes defined here:

__instance_size__ = 44

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullAddressSpace(AddressSpace)


Method resolution order:

NullAddressSpace

AddressSpace

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

end(...)
C++ signature:     end(TTAMachine::NullAddressSpace {lvalue}) -> unsigned int C++ signature:     end(NullAddressSpace_wrapper {lvalue}) -> unsigned int

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::NullAddressSpace {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(NullAddressSpace_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::NullAddressSpace {lvalue}) -> bool C++ signature:     isRegistered(NullAddressSpace_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::NullAddressSpace {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(NullAddressSpace_wrapper {lvalue}, ObjectState const* state) -> void*

machine(...)
C++ signature:     machine(TTAMachine::NullAddressSpace {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(NullAddressSpace_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::NullAddressSpace {lvalue}) -> std::string C++ signature:     name(NullAddressSpace_wrapper {lvalue}) -> std::string

saveState(...)
C++ signature:     saveState(TTAMachine::NullAddressSpace {lvalue}) -> ObjectState* C++ signature:     saveState(NullAddressSpace_wrapper {lvalue}) -> ObjectState*

setAddressBounds(...)
C++ signature:     setAddressBounds(TTAMachine::NullAddressSpace {lvalue}, unsigned int start, unsigned int end) -> void* C++ signature:     setAddressBounds(NullAddressSpace_wrapper {lvalue}, unsigned int start, unsigned int end) -> void*

setMachine(...)
C++ signature:     setMachine(TTAMachine::NullAddressSpace {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(NullAddressSpace_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

setName(...)
C++ signature:     setName(TTAMachine::NullAddressSpace {lvalue}, std::string name) -> void* C++ signature:     setName(NullAddressSpace_wrapper {lvalue}, std::string name) -> void*

setWidth(...)
C++ signature:     setWidth(TTAMachine::NullAddressSpace {lvalue}, int width) -> void* C++ signature:     setWidth(NullAddressSpace_wrapper {lvalue}, int width) -> void*

start(...)
C++ signature:     start(TTAMachine::NullAddressSpace {lvalue}) -> unsigned int C++ signature:     start(NullAddressSpace_wrapper {lvalue}) -> unsigned int

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::NullAddressSpace {lvalue}) -> void* C++ signature:     unsetMachine(NullAddressSpace_wrapper {lvalue}) -> void*

width(...)
C++ signature:     width(TTAMachine::NullAddressSpace {lvalue}) -> int C++ signature:     width(NullAddressSpace_wrapper {lvalue}) -> int

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAMachine::NullAddressSpace

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Data descriptors inherited from AddressSpace:

OSKEY_MAX_ADDRESS

OSKEY_MIN_ADDRESS

OSKEY_WIDTH

OSNAME_ADDRESS_SPACE

Data and other attributes inherited from AddressSpace:

__instance_size__ = 36

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullBus(Bus)


Method resolution order:

NullBus

Bus

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

addGuard(...)
C++ signature:     addGuard(TTAMachine::NullBus {lvalue}, TTAMachine::Guard {lvalue} guard) -> void* C++ signature:     addGuard(NullBus_wrapper {lvalue}, TTAMachine::Guard {lvalue} guard) -> void*

addSegment(...)
C++ signature:     addSegment(TTAMachine::NullBus {lvalue}, TTAMachine::Segment {lvalue} segment) -> void* C++ signature:     addSegment(NullBus_wrapper {lvalue}, TTAMachine::Segment {lvalue} segment) -> void*

canRead(...)
C++ signature:     canRead(TTAMachine::NullBus {lvalue}, TTAMachine::Bus bus) -> bool C++ signature:     canRead(NullBus_wrapper {lvalue}, TTAMachine::Bus bus) -> bool

canReadWrite(...)
C++ signature:     canReadWrite(TTAMachine::NullBus {lvalue}, TTAMachine::Bus bus) -> bool C++ signature:     canReadWrite(NullBus_wrapper {lvalue}, TTAMachine::Bus bus) -> bool

canWrite(...)
C++ signature:     canWrite(TTAMachine::NullBus {lvalue}, TTAMachine::Bus bus) -> bool C++ signature:     canWrite(NullBus_wrapper {lvalue}, TTAMachine::Bus bus) -> bool

clearDestinationBridge(...)
C++ signature:     clearDestinationBridge(TTAMachine::NullBus {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     clearDestinationBridge(NullBus_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

clearSourceBridge(...)
C++ signature:     clearSourceBridge(TTAMachine::NullBus {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     clearSourceBridge(NullBus_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::NullBus {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(NullBus_wrapper {lvalue}, TTAMachine::Component component) -> void*

guard(...)
C++ signature:     guard(TTAMachine::NullBus {lvalue}, int index) -> TTAMachine::Guard* C++ signature:     guard(NullBus_wrapper {lvalue}, int index) -> TTAMachine::Guard*

guardCount(...)
C++ signature:     guardCount(TTAMachine::NullBus {lvalue}) -> int C++ signature:     guardCount(NullBus_wrapper {lvalue}) -> int

hasNextBus(...)
C++ signature:     hasNextBus(TTAMachine::NullBus {lvalue}) -> bool C++ signature:     hasNextBus(NullBus_wrapper {lvalue}) -> bool

hasPreviousBus(...)
C++ signature:     hasPreviousBus(TTAMachine::NullBus {lvalue}) -> bool C++ signature:     hasPreviousBus(NullBus_wrapper {lvalue}) -> bool

hasSegment(...)
C++ signature:     hasSegment(TTAMachine::NullBus {lvalue}, std::string name) -> bool C++ signature:     hasSegment(NullBus_wrapper {lvalue}, std::string name) -> bool

immediateWidth(...)
C++ signature:     immediateWidth(TTAMachine::NullBus {lvalue}) -> int C++ signature:     immediateWidth(NullBus_wrapper {lvalue}) -> int

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::NullBus {lvalue}, TTAMachine::Socket socket) -> bool C++ signature:     isConnectedTo(NullBus_wrapper {lvalue}, TTAMachine::Socket socket) -> bool

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::NullBus {lvalue}) -> bool C++ signature:     isRegistered(NullBus_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::NullBus {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(NullBus_wrapper {lvalue}, ObjectState const* state) -> void*

machine(...)
C++ signature:     machine(TTAMachine::NullBus {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(NullBus_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::NullBus {lvalue}) -> std::string C++ signature:     name(NullBus_wrapper {lvalue}) -> std::string

nextBus(...)
C++ signature:     nextBus(TTAMachine::NullBus {lvalue}) -> TTAMachine::Bus* C++ signature:     nextBus(NullBus_wrapper {lvalue}) -> TTAMachine::Bus*

position(...)
C++ signature:     position(TTAMachine::NullBus {lvalue}) -> int C++ signature:     position(NullBus_wrapper {lvalue}) -> int

previousBus(...)
C++ signature:     previousBus(TTAMachine::NullBus {lvalue}) -> TTAMachine::Bus* C++ signature:     previousBus(NullBus_wrapper {lvalue}) -> TTAMachine::Bus*

removeGuard(...)
C++ signature:     removeGuard(TTAMachine::NullBus {lvalue}, TTAMachine::Guard {lvalue} guard) -> void* C++ signature:     removeGuard(NullBus_wrapper {lvalue}, TTAMachine::Guard {lvalue} guard) -> void*

removeSegment(...)
C++ signature:     removeSegment(TTAMachine::NullBus {lvalue}, TTAMachine::Segment {lvalue} segment) -> void* C++ signature:     removeSegment(NullBus_wrapper {lvalue}, TTAMachine::Segment {lvalue} segment) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::NullBus {lvalue}) -> ObjectState* C++ signature:     saveState(NullBus_wrapper {lvalue}) -> ObjectState*

segment(...)
C++ signature:     segment(TTAMachine::NullBus {lvalue}, int index) -> TTAMachine::Segment* C++ signature:     segment(NullBus_wrapper {lvalue}, int index) -> TTAMachine::Segment* C++ signature:     segment(TTAMachine::NullBus {lvalue}, std::string name) -> TTAMachine::Segment* C++ signature:     segment(NullBus_wrapper {lvalue}, std::string name) -> TTAMachine::Segment*

segmentCount(...)
C++ signature:     segmentCount(TTAMachine::NullBus {lvalue}) -> int C++ signature:     segmentCount(NullBus_wrapper {lvalue}) -> int

setDestinationBridge(...)
C++ signature:     setDestinationBridge(TTAMachine::NullBus {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     setDestinationBridge(NullBus_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

setImmediateWidth(...)
C++ signature:     setImmediateWidth(TTAMachine::NullBus {lvalue}, int width) -> void* C++ signature:     setImmediateWidth(NullBus_wrapper {lvalue}, int width) -> void*

setMachine(...)
C++ signature:     setMachine(TTAMachine::NullBus {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(NullBus_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

setName(...)
C++ signature:     setName(TTAMachine::NullBus {lvalue}, std::string name) -> void* C++ signature:     setName(NullBus_wrapper {lvalue}, std::string name) -> void*

setSignExtends(...)
C++ signature:     setSignExtends(TTAMachine::NullBus {lvalue}) -> void* C++ signature:     setSignExtends(NullBus_wrapper {lvalue}) -> void*

setSourceBridge(...)
C++ signature:     setSourceBridge(TTAMachine::NullBus {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     setSourceBridge(NullBus_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

setWidth(...)
C++ signature:     setWidth(TTAMachine::NullBus {lvalue}, int width) -> void* C++ signature:     setWidth(NullBus_wrapper {lvalue}, int width) -> void*

setZeroExtends(...)
C++ signature:     setZeroExtends(TTAMachine::NullBus {lvalue}) -> void* C++ signature:     setZeroExtends(NullBus_wrapper {lvalue}) -> void*

signExtends(...)
C++ signature:     signExtends(TTAMachine::NullBus {lvalue}) -> bool C++ signature:     signExtends(NullBus_wrapper {lvalue}) -> bool

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::NullBus {lvalue}) -> void* C++ signature:     unsetMachine(NullBus_wrapper {lvalue}) -> void*

width(...)
C++ signature:     width(TTAMachine::NullBus {lvalue}) -> int C++ signature:     width(NullBus_wrapper {lvalue}) -> int

zeroExtends(...)
C++ signature:     zeroExtends(TTAMachine::NullBus {lvalue}) -> bool C++ signature:     zeroExtends(NullBus_wrapper {lvalue}) -> bool

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAMachine::NullBus

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Methods inherited from Bus:

copy(...)
C++ signature:     copy(TTAMachine::Bus {lvalue}) -> TTAMachine::Bus* C++ signature:     copy(Bus_wrapper {lvalue}) -> TTAMachine::Bus*

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::Bus {lvalue}, TTAMachine::Bus bus) -> bool C++ signature:     isArchitectureEqual(Bus_wrapper {lvalue}, TTAMachine::Bus bus) -> bool

Data descriptors inherited from Bus:

OSKEY_EXTENSION

OSKEY_IMMWIDTH

OSKEY_WIDTH

OSNAME_BUS

OSVALUE_SIGN

OSVALUE_ZERO

Data and other attributes inherited from Bus:

__instance_size__ = 84

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullFunctionUnit(FunctionUnit)


Method resolution order:

NullFunctionUnit

FunctionUnit

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

addOperation(...)
C++ signature:     addOperation(TTAMachine::NullFunctionUnit {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void* C++ signature:     addOperation(NullFunctionUnit_wrapper {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void*

addPipelineElement(...)
C++ signature:     addPipelineElement(TTAMachine::NullFunctionUnit {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void* C++ signature:     addPipelineElement(NullFunctionUnit_wrapper {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void*

addressSpace(...)
C++ signature:     addressSpace(TTAMachine::NullFunctionUnit {lvalue}) -> TTAMachine::AddressSpace* C++ signature:     addressSpace(NullFunctionUnit_wrapper {lvalue}) -> TTAMachine::AddressSpace*

cleanup(...)
C++ signature:     cleanup(TTAMachine::NullFunctionUnit {lvalue}, std::string resource) -> void* C++ signature:     cleanup(NullFunctionUnit_wrapper {lvalue}, std::string resource) -> void*

deleteOperation(...)
C++ signature:     deleteOperation(TTAMachine::NullFunctionUnit {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void* C++ signature:     deleteOperation(NullFunctionUnit_wrapper {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void*

deletePipelineElement(...)
C++ signature:     deletePipelineElement(TTAMachine::NullFunctionUnit {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void* C++ signature:     deletePipelineElement(NullFunctionUnit_wrapper {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void*

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::NullFunctionUnit {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(NullFunctionUnit_wrapper {lvalue}, TTAMachine::Component component) -> void*

hasAddressSpace(...)
C++ signature:     hasAddressSpace(TTAMachine::NullFunctionUnit {lvalue}) -> bool C++ signature:     hasAddressSpace(NullFunctionUnit_wrapper {lvalue}) -> bool

hasOperation(...)
C++ signature:     hasOperation(TTAMachine::NullFunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasOperation(NullFunctionUnit_wrapper {lvalue}, std::string name) -> bool

hasOperationPort(...)
C++ signature:     hasOperationPort(TTAMachine::NullFunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasOperationPort(NullFunctionUnit_wrapper {lvalue}, std::string name) -> bool

hasPipelineElement(...)
C++ signature:     hasPipelineElement(TTAMachine::NullFunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasPipelineElement(NullFunctionUnit_wrapper {lvalue}, std::string name) -> bool

hasPort(...)
C++ signature:     hasPort(TTAMachine::NullFunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasPort(NullFunctionUnit_wrapper {lvalue}, std::string name) -> bool

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::NullFunctionUnit {lvalue}) -> bool C++ signature:     isRegistered(NullFunctionUnit_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::NullFunctionUnit {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(NullFunctionUnit_wrapper {lvalue}, ObjectState const* state) -> void*

machine(...)
C++ signature:     machine(TTAMachine::NullFunctionUnit {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(NullFunctionUnit_wrapper {lvalue}) -> TTAMachine::Machine*

maxLatency(...)
C++ signature:     maxLatency(TTAMachine::NullFunctionUnit {lvalue}) -> int C++ signature:     maxLatency(NullFunctionUnit_wrapper {lvalue}) -> int

name(...)
C++ signature:     name(TTAMachine::NullFunctionUnit {lvalue}) -> std::string C++ signature:     name(NullFunctionUnit_wrapper {lvalue}) -> std::string

operation(...)
C++ signature:     operation(TTAMachine::NullFunctionUnit {lvalue}, std::string name) -> TTAMachine::HWOperation* C++ signature:     operation(NullFunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::HWOperation* C++ signature:     operation(TTAMachine::NullFunctionUnit {lvalue}, int index) -> TTAMachine::HWOperation* C++ signature:     operation(NullFunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::HWOperation*

operationCount(...)
C++ signature:     operationCount(TTAMachine::NullFunctionUnit {lvalue}) -> int C++ signature:     operationCount(NullFunctionUnit_wrapper {lvalue}) -> int

operationPort(...)
C++ signature:     operationPort(TTAMachine::NullFunctionUnit {lvalue}, std::string name) -> TTAMachine::FUPort* C++ signature:     operationPort(NullFunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::FUPort* C++ signature:     operationPort(TTAMachine::NullFunctionUnit {lvalue}, int index) -> TTAMachine::FUPort* C++ signature:     operationPort(NullFunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::FUPort*

operationPortCount(...)
C++ signature:     operationPortCount(TTAMachine::NullFunctionUnit {lvalue}) -> int C++ signature:     operationPortCount(NullFunctionUnit_wrapper {lvalue}) -> int

pipelineElement(...)
C++ signature:     pipelineElement(TTAMachine::NullFunctionUnit {lvalue}, int index) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(NullFunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(TTAMachine::NullFunctionUnit {lvalue}, std::string name) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(NullFunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::PipelineElement*

pipelineElementCount(...)
C++ signature:     pipelineElementCount(TTAMachine::NullFunctionUnit {lvalue}) -> int C++ signature:     pipelineElementCount(NullFunctionUnit_wrapper {lvalue}) -> int

port(...)
C++ signature:     port(TTAMachine::NullFunctionUnit {lvalue}, std::string name) -> TTAMachine::BaseFUPort* C++ signature:     port(NullFunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::BaseFUPort* C++ signature:     port(TTAMachine::NullFunctionUnit {lvalue}, int index) -> TTAMachine::BaseFUPort* C++ signature:     port(NullFunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::BaseFUPort*

portCount(...)
C++ signature:     portCount(TTAMachine::NullFunctionUnit {lvalue}) -> int C++ signature:     portCount(NullFunctionUnit_wrapper {lvalue}) -> int

removePort(...)
C++ signature: removePort(NullFunctionUnit_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::NullFunctionUnit {lvalue}) -> ObjectState* C++ signature:     saveState(NullFunctionUnit_wrapper {lvalue}) -> ObjectState*

setAddressSpace(...)
C++ signature:     setAddressSpace(TTAMachine::NullFunctionUnit {lvalue}, TTAMachine::AddressSpace* as) -> void* C++ signature:     setAddressSpace(NullFunctionUnit_wrapper {lvalue}, TTAMachine::AddressSpace* as) -> void*

setMachine(...)
C++ signature:     setMachine(TTAMachine::NullFunctionUnit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(NullFunctionUnit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

setName(...)
C++ signature:     setName(TTAMachine::NullFunctionUnit {lvalue}, std::string name) -> void* C++ signature:     setName(NullFunctionUnit_wrapper {lvalue}, std::string name) -> void*

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::NullFunctionUnit {lvalue}) -> void* C++ signature:     unsetMachine(NullFunctionUnit_wrapper {lvalue}) -> void*

unsetMachineDerived(...)
C++ signature: unsetMachineDerived(NullFunctionUnit_wrapper {lvalue}) -> void*

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAMachine::NullFunctionUnit

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Methods inherited from FunctionUnit:

copy(...)
C++ signature:     copy(TTAMachine::FunctionUnit {lvalue}) -> TTAMachine::FunctionUnit* C++ signature:     copy(FunctionUnit_wrapper {lvalue}) -> TTAMachine::FunctionUnit*

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::FunctionUnit {lvalue}, TTAMachine::FunctionUnit const* fu, bool checkPortWidths=True) -> bool C++ signature:     isArchitectureEqual(FunctionUnit_wrapper {lvalue}, TTAMachine::FunctionUnit const* fu, bool checkPortWidths=True) -> bool

Data descriptors inherited from FunctionUnit:

OSKEY_AS

OSNAME_FU

Data and other attributes inherited from FunctionUnit:

__instance_size__ = 64

Data descriptors inherited from Unit:

OSNAME_UNIT

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullGuard(Guard)


Method resolution order:

NullGuard

Guard

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

isDisjoint(...)
C++ signature:     isDisjoint(TTAMachine::NullGuard {lvalue}, TTAMachine::Guard arg0) -> bool C++ signature:     isDisjoint(NullGuard_wrapper {lvalue}, TTAMachine::Guard arg0) -> bool

isEqual(...)
C++ signature:     isEqual(TTAMachine::NullGuard {lvalue}, TTAMachine::Guard arg0) -> bool C++ signature:     isEqual(NullGuard_wrapper {lvalue}, TTAMachine::Guard arg0) -> bool

isInverted(...)
C++ signature:     isInverted(TTAMachine::NullGuard {lvalue}) -> bool C++ signature:     isInverted(NullGuard_wrapper {lvalue}) -> bool

isLessRestrictive(...)
C++ signature:     isLessRestrictive(TTAMachine::NullGuard {lvalue}, TTAMachine::Guard arg0) -> bool C++ signature:     isLessRestrictive(NullGuard_wrapper {lvalue}, TTAMachine::Guard arg0) -> bool

isMoreRestrictive(...)
C++ signature:     isMoreRestrictive(TTAMachine::NullGuard {lvalue}, TTAMachine::Guard arg0) -> bool C++ signature:     isMoreRestrictive(NullGuard_wrapper {lvalue}, TTAMachine::Guard arg0) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::NullGuard {lvalue}, ObjectState const* arg0) -> void* C++ signature:     loadState(NullGuard_wrapper {lvalue}, ObjectState const* arg0) -> void*

parentBus(...)
C++ signature:     parentBus(TTAMachine::NullGuard {lvalue}) -> TTAMachine::Bus* C++ signature:     parentBus(NullGuard_wrapper {lvalue}) -> TTAMachine::Bus*

saveState(...)
C++ signature:     saveState(TTAMachine::NullGuard {lvalue}) -> ObjectState* C++ signature:     saveState(NullGuard_wrapper {lvalue}) -> ObjectState*

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAMachine::NullGuard

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Data descriptors inherited from Guard:

OSKEY_INVERTED

OSNAME_GUARD

Data and other attributes inherited from Guard:

__instance_size__ = 24

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullImmediateUnit(ImmediateUnit)


Method resolution order:

NullImmediateUnit

ImmediateUnit

RegisterFile

BaseRegisterFile

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::NullImmediateUnit {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(NullImmediateUnit_wrapper {lvalue}, TTAMachine::Component component) -> void*

extensionMode(...)
C++ signature:     extensionMode(TTAMachine::NullImmediateUnit {lvalue}) -> TTAMachine::Machine::Extension C++ signature:     extensionMode(NullImmediateUnit_wrapper {lvalue}) -> TTAMachine::Machine::Extension

guardLatency(...)
C++ signature:     guardLatency(TTAMachine::NullImmediateUnit {lvalue}) -> int C++ signature:     guardLatency(NullImmediateUnit_wrapper {lvalue}) -> int

hasPort(...)
C++ signature:     hasPort(TTAMachine::NullImmediateUnit {lvalue}, std::string name) -> bool C++ signature:     hasPort(NullImmediateUnit_wrapper {lvalue}, std::string name) -> bool

isNormal(...)
C++ signature:     isNormal(TTAMachine::NullImmediateUnit {lvalue}) -> bool C++ signature:     isNormal(NullImmediateUnit_wrapper {lvalue}) -> bool

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::NullImmediateUnit {lvalue}) -> bool C++ signature:     isRegistered(NullImmediateUnit_wrapper {lvalue}) -> bool

isReserved(...)
C++ signature:     isReserved(TTAMachine::NullImmediateUnit {lvalue}) -> bool C++ signature:     isReserved(NullImmediateUnit_wrapper {lvalue}) -> bool

isVolatile(...)
C++ signature:     isVolatile(TTAMachine::NullImmediateUnit {lvalue}) -> bool C++ signature:     isVolatile(NullImmediateUnit_wrapper {lvalue}) -> bool

latency(...)
C++ signature:     latency(TTAMachine::NullImmediateUnit {lvalue}) -> int C++ signature:     latency(NullImmediateUnit_wrapper {lvalue}) -> int

loadState(...)
C++ signature:     loadState(TTAMachine::NullImmediateUnit {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(NullImmediateUnit_wrapper {lvalue}, ObjectState const* state) -> void*

machine(...)
C++ signature:     machine(TTAMachine::NullImmediateUnit {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(NullImmediateUnit_wrapper {lvalue}) -> TTAMachine::Machine*

maxReads(...)
C++ signature:     maxReads(TTAMachine::NullImmediateUnit {lvalue}) -> int C++ signature:     maxReads(NullImmediateUnit_wrapper {lvalue}) -> int

maxWrites(...)
C++ signature:     maxWrites(TTAMachine::NullImmediateUnit {lvalue}) -> int C++ signature:     maxWrites(NullImmediateUnit_wrapper {lvalue}) -> int

name(...)
C++ signature:     name(TTAMachine::NullImmediateUnit {lvalue}) -> std::string C++ signature:     name(NullImmediateUnit_wrapper {lvalue}) -> std::string

numberOfRegisters(...)
C++ signature:     numberOfRegisters(TTAMachine::NullImmediateUnit {lvalue}) -> int C++ signature:     numberOfRegisters(NullImmediateUnit_wrapper {lvalue}) -> int

portCount(...)
C++ signature:     portCount(TTAMachine::NullImmediateUnit {lvalue}) -> int C++ signature:     portCount(NullImmediateUnit_wrapper {lvalue}) -> int

removePort(...)
C++ signature: removePort(NullImmediateUnit_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::NullImmediateUnit {lvalue}) -> ObjectState* C++ signature:     saveState(NullImmediateUnit_wrapper {lvalue}) -> ObjectState*

setExtensionMode(...)
C++ signature:     setExtensionMode(TTAMachine::NullImmediateUnit {lvalue}, TTAMachine::Machine::Extension mode) -> void* C++ signature:     setExtensionMode(NullImmediateUnit_wrapper {lvalue}, TTAMachine::Machine::Extension mode) -> void*

setGuardLatency(...)
C++ signature:     setGuardLatency(TTAMachine::NullImmediateUnit {lvalue}, int latency) -> void* C++ signature:     setGuardLatency(NullImmediateUnit_wrapper {lvalue}, int latency) -> void*

setLatency(...)
C++ signature:     setLatency(TTAMachine::NullImmediateUnit {lvalue}, int latency) -> void* C++ signature:     setLatency(NullImmediateUnit_wrapper {lvalue}, int latency) -> void*

setMachine(...)
C++ signature:     setMachine(TTAMachine::NullImmediateUnit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(NullImmediateUnit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

setMaxReads(...)
C++ signature:     setMaxReads(TTAMachine::NullImmediateUnit {lvalue}, int reads) -> void* C++ signature:     setMaxReads(NullImmediateUnit_wrapper {lvalue}, int reads) -> void*

setMaxWrites(...)
C++ signature:     setMaxWrites(TTAMachine::NullImmediateUnit {lvalue}, int maxWrites) -> void* C++ signature:     setMaxWrites(NullImmediateUnit_wrapper {lvalue}, int maxWrites) -> void*

setName(...)
C++ signature:     setName(TTAMachine::NullImmediateUnit {lvalue}, std::string name) -> void* C++ signature:     setName(NullImmediateUnit_wrapper {lvalue}, std::string name) -> void*

setNumberOfRegisters(...)
C++ signature:     setNumberOfRegisters(TTAMachine::NullImmediateUnit {lvalue}, int registers) -> void* C++ signature:     setNumberOfRegisters(NullImmediateUnit_wrapper {lvalue}, int registers) -> void*

setType(...)
C++ signature:     setType(TTAMachine::NullImmediateUnit {lvalue}, TTAMachine::RegisterFile::Type type) -> void* C++ signature:     setType(NullImmediateUnit_wrapper {lvalue}, TTAMachine::RegisterFile::Type type) -> void*

setWidth(...)
C++ signature:     setWidth(TTAMachine::NullImmediateUnit {lvalue}, int width) -> void* C++ signature:     setWidth(NullImmediateUnit_wrapper {lvalue}, int width) -> void*

type(...)
C++ signature:     type(TTAMachine::NullImmediateUnit {lvalue}) -> TTAMachine::RegisterFile::Type C++ signature:     type(NullImmediateUnit_wrapper {lvalue}) -> TTAMachine::RegisterFile::Type

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::NullImmediateUnit {lvalue}) -> void* C++ signature:     unsetMachine(NullImmediateUnit_wrapper {lvalue}) -> void*

width(...)
C++ signature:     width(TTAMachine::NullImmediateUnit {lvalue}) -> int C++ signature:     width(NullImmediateUnit_wrapper {lvalue}) -> int

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAMachine::NullImmediateUnit

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Data descriptors inherited from ImmediateUnit:

OSKEY_EXTENSION

OSKEY_LATENCY

OSNAME_IMMEDIATE_UNIT

OSVALUE_SIGN

OSVALUE_ZERO

Data and other attributes inherited from ImmediateUnit:

__instance_size__ = 68

Methods inherited from RegisterFile:

copy(...)
C++ signature:     copy(TTAMachine::RegisterFile {lvalue}) -> TTAMachine::RegisterFile* C++ signature:     copy(RegisterFile_wrapper {lvalue}) -> TTAMachine::RegisterFile*

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::RegisterFile {lvalue}, TTAMachine::RegisterFile rf) -> bool C++ signature:     isArchitectureEqual(RegisterFile_wrapper {lvalue}, TTAMachine::RegisterFile rf) -> bool

isUsedAsGuard(...)
C++ signature:     isUsedAsGuard(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isUsedAsGuard(RegisterFile_wrapper {lvalue}) -> bool

updateMaxReadsAndWrites(...)
C++ signature: updateMaxReadsAndWrites(TTAMachine::RegisterFile {lvalue}) -> bool

Data descriptors inherited from RegisterFile:

OSKEY_GUARD_LATENCY

OSKEY_MAX_READS

OSKEY_MAX_WRITES

OSKEY_TYPE

OSNAME_REGISTER_FILE

OSVALUE_NORMAL

OSVALUE_RESERVED

OSVALUE_VOLATILE

Data and other attributes inherited from RegisterFile:

NORMAL = TCE.base.mach.Type.NORMAL

RESERVED = TCE.base.mach.Type.RESERVED

Type = <class 'TCE.base.TCE.base.mach.Type'>

VOLATILE = TCE.base.mach.Type.VOLATILE

Methods inherited from BaseRegisterFile:

port(...)
C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, int index) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, int index) -> TTAMachine::RFPort*

Data descriptors inherited from BaseRegisterFile:

OSKEY_SIZE

OSKEY_WIDTH

OSNAME_BASE_REGISTER_FILE

Data descriptors inherited from Unit:

OSNAME_UNIT

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullInstructionTemplate(InstructionTemplate)


Method resolution order:

NullInstructionTemplate

InstructionTemplate

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

addSlot(...)
C++ signature:     addSlot(TTAMachine::NullInstructionTemplate {lvalue}, std::string slotName, int width, TTAMachine::ImmediateUnit {lvalue} dstUnit) -> void* C++ signature:     addSlot(NullInstructionTemplate_wrapper {lvalue}, std::string slotName, int width, TTAMachine::ImmediateUnit {lvalue} dstUnit) -> void*

destinationOfSlot(...)
C++ signature:     destinationOfSlot(TTAMachine::NullInstructionTemplate {lvalue}, std::string slotName) -> TTAMachine::ImmediateUnit* C++ signature:     destinationOfSlot(NullInstructionTemplate_wrapper {lvalue}, std::string slotName) -> TTAMachine::ImmediateUnit*

destinationUsesSlot(...)
C++ signature:     destinationUsesSlot(TTAMachine::NullInstructionTemplate {lvalue}, std::string slotName, TTAMachine::ImmediateUnit dstUnit) -> bool C++ signature:     destinationUsesSlot(NullInstructionTemplate_wrapper {lvalue}, std::string slotName, TTAMachine::ImmediateUnit dstUnit) -> bool

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::NullInstructionTemplate {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(NullInstructionTemplate_wrapper {lvalue}, TTAMachine::Component component) -> void*

isEmpty(...)
C++ signature:     isEmpty(TTAMachine::NullInstructionTemplate {lvalue}) -> bool C++ signature:     isEmpty(NullInstructionTemplate_wrapper {lvalue}) -> bool

isOneOfDestinations(...)
C++ signature:     isOneOfDestinations(TTAMachine::NullInstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> bool C++ signature:     isOneOfDestinations(NullInstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> bool

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::NullInstructionTemplate {lvalue}) -> bool C++ signature:     isRegistered(NullInstructionTemplate_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::NullInstructionTemplate {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(NullInstructionTemplate_wrapper {lvalue}, ObjectState const* state) -> void*

machine(...)
C++ signature:     machine(TTAMachine::NullInstructionTemplate {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(NullInstructionTemplate_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::NullInstructionTemplate {lvalue}) -> std::string C++ signature:     name(NullInstructionTemplate_wrapper {lvalue}) -> std::string

numberOfDestinations(...)
C++ signature:     numberOfDestinations(TTAMachine::NullInstructionTemplate {lvalue}) -> int C++ signature:     numberOfDestinations(NullInstructionTemplate_wrapper {lvalue}) -> int

numberOfSlots(...)
C++ signature:     numberOfSlots(TTAMachine::NullInstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> int C++ signature:     numberOfSlots(NullInstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> int

removeSlot(...)
C++ signature:     removeSlot(TTAMachine::NullInstructionTemplate {lvalue}, std::string slotName) -> void* C++ signature:     removeSlot(NullInstructionTemplate_wrapper {lvalue}, std::string slotName) -> void*

removeSlots(...)
C++ signature:     removeSlots(TTAMachine::NullInstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> void* C++ signature:     removeSlots(NullInstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::NullInstructionTemplate {lvalue}) -> ObjectState* C++ signature:     saveState(NullInstructionTemplate_wrapper {lvalue}) -> ObjectState*

setMachine(...)
C++ signature:     setMachine(TTAMachine::NullInstructionTemplate {lvalue}, TTAMachine::Machine {lvalue} machine) -> void* C++ signature:     setMachine(NullInstructionTemplate_wrapper {lvalue}, TTAMachine::Machine {lvalue} machine) -> void*

setName(...)
C++ signature:     setName(TTAMachine::NullInstructionTemplate {lvalue}, std::string name) -> void* C++ signature:     setName(NullInstructionTemplate_wrapper {lvalue}, std::string name) -> void*

slot(...)
C++ signature:     slot(TTAMachine::NullInstructionTemplate {lvalue}, int index) -> TTAMachine::TemplateSlot* C++ signature:     slot(NullInstructionTemplate_wrapper {lvalue}, int index) -> TTAMachine::TemplateSlot*

slotCount(...)
C++ signature:     slotCount(TTAMachine::NullInstructionTemplate {lvalue}) -> int C++ signature:     slotCount(NullInstructionTemplate_wrapper {lvalue}) -> int

slotOfDestination(...)
C++ signature:     slotOfDestination(TTAMachine::NullInstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit, int index) -> std::string C++ signature:     slotOfDestination(NullInstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit, int index) -> std::string

supportedWidth(...)
C++ signature:     supportedWidth(TTAMachine::NullInstructionTemplate {lvalue}) -> int C++ signature:     supportedWidth(NullInstructionTemplate_wrapper {lvalue}) -> int C++ signature:     supportedWidth(TTAMachine::NullInstructionTemplate {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> int C++ signature:     supportedWidth(NullInstructionTemplate_wrapper {lvalue}, TTAMachine::ImmediateUnit dstUnit) -> int C++ signature:     supportedWidth(TTAMachine::NullInstructionTemplate {lvalue}, std::string slotName) -> int C++ signature:     supportedWidth(NullInstructionTemplate_wrapper {lvalue}, std::string slotName) -> int

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::NullInstructionTemplate {lvalue}) -> void* C++ signature:     unsetMachine(NullInstructionTemplate_wrapper {lvalue}) -> void*

usesSlot(...)
C++ signature:     usesSlot(TTAMachine::NullInstructionTemplate {lvalue}, std::string slotName) -> bool C++ signature:     usesSlot(NullInstructionTemplate_wrapper {lvalue}, std::string slotName) -> bool

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAMachine::NullInstructionTemplate

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Data descriptors inherited from InstructionTemplate:

OSNAME_INSTRUCTION_TEMPLATE

Data and other attributes inherited from InstructionTemplate:

__instance_size__ = 36

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullMachine(Machine)


Method resolution order:

NullMachine

Machine

Boost.Python.instance

__builtin__.object

Methods defined here:

addAddressSpace(...)
C++ signature:     addAddressSpace(TTAMachine::NullMachine {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void* C++ signature:     addAddressSpace(NullMachine_wrapper {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void*

addBridge(...)
C++ signature:     addBridge(TTAMachine::NullMachine {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     addBridge(NullMachine_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

addBus(...)
C++ signature:     addBus(TTAMachine::NullMachine {lvalue}, TTAMachine::Bus {lvalue} bus) -> void* C++ signature:     addBus(NullMachine_wrapper {lvalue}, TTAMachine::Bus {lvalue} bus) -> void*

addFunctionUnit(...)
C++ signature:     addFunctionUnit(TTAMachine::NullMachine {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void* C++ signature:     addFunctionUnit(NullMachine_wrapper {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void*

addImmediateUnit(...)
C++ signature:     addImmediateUnit(TTAMachine::NullMachine {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void* C++ signature:     addImmediateUnit(NullMachine_wrapper {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void*

addInstructionTemplate(...)
C++ signature:     addInstructionTemplate(TTAMachine::NullMachine {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void* C++ signature:     addInstructionTemplate(NullMachine_wrapper {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void*

addRegisterFile(...)
C++ signature:     addRegisterFile(TTAMachine::NullMachine {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void* C++ signature:     addRegisterFile(NullMachine_wrapper {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void*

addSocket(...)
C++ signature:     addSocket(TTAMachine::NullMachine {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     addSocket(NullMachine_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

addUnit(...)
C++ signature: addUnit(TTAMachine::NullMachine {lvalue}, TTAMachine::Unit {lvalue} unit) -> void*

addressSpaceNavigator(...)
C++ signature:     addressSpaceNavigator(TTAMachine::NullMachine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::AddressSpace> C++ signature:     addressSpaceNavigator(NullMachine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::AddressSpace>

bridgeNavigator(...)
C++ signature:     bridgeNavigator(TTAMachine::NullMachine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bridge> C++ signature:     bridgeNavigator(NullMachine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bridge>

busNavigator(...)
C++ signature:     busNavigator(TTAMachine::NullMachine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bus> C++ signature:     busNavigator(NullMachine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bus>

controlUnit(...)
C++ signature:     controlUnit(TTAMachine::NullMachine {lvalue}) -> TTAMachine::ControlUnit* C++ signature:     controlUnit(NullMachine_wrapper {lvalue}) -> TTAMachine::ControlUnit*

deleteAddressSpace(...)
C++ signature:     deleteAddressSpace(TTAMachine::NullMachine {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void* C++ signature:     deleteAddressSpace(NullMachine_wrapper {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void*

deleteBridge(...)
C++ signature:     deleteBridge(TTAMachine::NullMachine {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     deleteBridge(NullMachine_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

deleteInstructionTemplate(...)
C++ signature:     deleteInstructionTemplate(TTAMachine::NullMachine {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void* C++ signature:     deleteInstructionTemplate(NullMachine_wrapper {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void*

functionUnitNavigator(...)
C++ signature:     functionUnitNavigator(TTAMachine::NullMachine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::FunctionUnit> C++ signature:     functionUnitNavigator(NullMachine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::FunctionUnit>

immediateUnitNavigator(...)
C++ signature:     immediateUnitNavigator(TTAMachine::NullMachine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateUnit> C++ signature:     immediateUnitNavigator(NullMachine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateUnit>

instructionTemplateNavigator(...)
C++ signature:     instructionTemplateNavigator(TTAMachine::NullMachine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::InstructionTemplate> C++ signature:     instructionTemplateNavigator(NullMachine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::InstructionTemplate>

loadState(...)
C++ signature:     loadState(TTAMachine::NullMachine {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(NullMachine_wrapper {lvalue}, ObjectState const* state) -> void*

registerFileNavigator(...)
C++ signature:     registerFileNavigator(TTAMachine::NullMachine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::RegisterFile> C++ signature:     registerFileNavigator(NullMachine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::RegisterFile>

removeBus(...)
C++ signature:     removeBus(TTAMachine::NullMachine {lvalue}, TTAMachine::Bus {lvalue} bus) -> void* C++ signature:     removeBus(NullMachine_wrapper {lvalue}, TTAMachine::Bus {lvalue} bus) -> void*

removeFunctionUnit(...)
C++ signature:     removeFunctionUnit(TTAMachine::NullMachine {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void* C++ signature:     removeFunctionUnit(NullMachine_wrapper {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void*

removeImmediateUnit(...)
C++ signature:     removeImmediateUnit(TTAMachine::NullMachine {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void* C++ signature:     removeImmediateUnit(NullMachine_wrapper {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void*

removeRegisterFile(...)
C++ signature:     removeRegisterFile(TTAMachine::NullMachine {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void* C++ signature:     removeRegisterFile(NullMachine_wrapper {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void*

removeSocket(...)
C++ signature:     removeSocket(TTAMachine::NullMachine {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     removeSocket(NullMachine_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

removeUnit(...)
C++ signature:     removeUnit(TTAMachine::NullMachine {lvalue}, TTAMachine::Unit {lvalue} unit) -> void* C++ signature:     removeUnit(NullMachine_wrapper {lvalue}, TTAMachine::Unit {lvalue} unit) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::NullMachine {lvalue}) -> ObjectState* C++ signature:     saveState(NullMachine_wrapper {lvalue}) -> ObjectState*

setGlobalControl(...)
C++ signature:     setGlobalControl(TTAMachine::NullMachine {lvalue}, TTAMachine::ControlUnit {lvalue} unit) -> void* C++ signature:     setGlobalControl(NullMachine_wrapper {lvalue}, TTAMachine::ControlUnit {lvalue} unit) -> void*

socketNavigator(...)
C++ signature:     socketNavigator(TTAMachine::NullMachine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Socket> C++ signature:     socketNavigator(NullMachine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Socket>

unsetGlobalControl(...)
C++ signature:     unsetGlobalControl(TTAMachine::NullMachine {lvalue}) -> void* C++ signature:     unsetGlobalControl(NullMachine_wrapper {lvalue}) -> void*

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAMachine::NullMachine

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Methods inherited from Machine:

addImmediateSlot(...)
C++ signature:     addImmediateSlot(TTAMachine::Machine {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void* C++ signature:     addImmediateSlot(Machine_wrapper {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void*

deleteImmediateSlot(...)
C++ signature:     deleteImmediateSlot(TTAMachine::Machine {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void* C++ signature:     deleteImmediateSlot(Machine_wrapper {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void*

immediateSlotNavigator(...)
C++ signature:     immediateSlotNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateSlot> C++ signature:     immediateSlotNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateSlot>

machineTester(...)
C++ signature: machineTester(TTAMachine::Machine {lvalue}) -> MachineTester

setBusPosition(...)
C++ signature: setBusPosition(TTAMachine::Machine {lvalue}, TTAMachine::Bus bus, int newPosition) -> void*

Static methods inherited from Machine:

loadFromADF(...)
C++ signature: loadFromADF(std::string adfFileName) -> TTAMachine::Machine*

Data descriptors inherited from Machine:

OSNAME_MACHINE

Data and other attributes inherited from Machine:

Extension = <class 'TCE.base.TCE.base.mach.Extension'>

SIGN = TCE.base.mach.Extension.SIGN

ZERO = TCE.base.mach.Extension.ZERO

__instance_size__ = 144

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullPort(Port)


Method resolution order:

NullPort

Port

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

attachSocket(...)
C++ signature:     attachSocket(TTAMachine::NullPort {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     attachSocket(NullPort_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

detachAllSockets(...)
C++ signature:     detachAllSockets(TTAMachine::NullPort {lvalue}) -> void* C++ signature:     detachAllSockets(NullPort_wrapper {lvalue}) -> void*

detachSocket(...)
C++ signature:     detachSocket(TTAMachine::NullPort {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     detachSocket(NullPort_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

inputSocket(...)
C++ signature:     inputSocket(TTAMachine::NullPort {lvalue}) -> TTAMachine::Socket* C++ signature:     inputSocket(NullPort_wrapper {lvalue}) -> TTAMachine::Socket*

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::NullPort {lvalue}, TTAMachine::Socket socket) -> bool C++ signature:     isConnectedTo(NullPort_wrapper {lvalue}, TTAMachine::Socket socket) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::NullPort {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(NullPort_wrapper {lvalue}, ObjectState const* state) -> void*

name(...)
C++ signature:     name(TTAMachine::NullPort {lvalue}) -> std::string C++ signature:     name(NullPort_wrapper {lvalue}) -> std::string

outputSocket(...)
C++ signature:     outputSocket(TTAMachine::NullPort {lvalue}) -> TTAMachine::Socket* C++ signature:     outputSocket(NullPort_wrapper {lvalue}) -> TTAMachine::Socket*

saveState(...)
C++ signature:     saveState(TTAMachine::NullPort {lvalue}) -> ObjectState* C++ signature:     saveState(NullPort_wrapper {lvalue}) -> ObjectState*

setName(...)
C++ signature:     setName(TTAMachine::NullPort {lvalue}, std::string name) -> void* C++ signature:     setName(NullPort_wrapper {lvalue}, std::string name) -> void*

socketCount(...)
C++ signature:     socketCount(TTAMachine::NullPort {lvalue}) -> int C++ signature:     socketCount(NullPort_wrapper {lvalue}) -> int

unconnectedSocket(...)
C++ signature:     unconnectedSocket(TTAMachine::NullPort {lvalue}, int index) -> TTAMachine::Socket* C++ signature:     unconnectedSocket(NullPort_wrapper {lvalue}, int index) -> TTAMachine::Socket*

width(...)
C++ signature:     width(TTAMachine::NullPort {lvalue}) -> int C++ signature:     width(NullPort_wrapper {lvalue}) -> int

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAMachine::NullPort

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Methods inherited from Port:

isInput(...)
C++ signature:     isInput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isInput(Port_wrapper {lvalue}) -> bool

isOutput(...)
C++ signature:     isOutput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isOutput(Port_wrapper {lvalue}) -> bool

Data descriptors inherited from Port:

OSKEY_FIRST_SOCKET

OSKEY_NAME

OSKEY_SECOND_SOCKET

OSNAME_PORT

Data and other attributes inherited from Port:

__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class NullRegisterFile(RegisterFile)


Method resolution order:

NullRegisterFile

RegisterFile

BaseRegisterFile

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::NullRegisterFile {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(NullRegisterFile_wrapper {lvalue}, TTAMachine::Component component) -> void*

guardLatency(...)
C++ signature:     guardLatency(TTAMachine::NullRegisterFile {lvalue}) -> int C++ signature:     guardLatency(NullRegisterFile_wrapper {lvalue}) -> int

hasPort(...)
C++ signature:     hasPort(TTAMachine::NullRegisterFile {lvalue}, std::string name) -> bool C++ signature:     hasPort(NullRegisterFile_wrapper {lvalue}, std::string name) -> bool

isNormal(...)
C++ signature:     isNormal(TTAMachine::NullRegisterFile {lvalue}) -> bool C++ signature:     isNormal(NullRegisterFile_wrapper {lvalue}) -> bool

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::NullRegisterFile {lvalue}) -> bool C++ signature:     isRegistered(NullRegisterFile_wrapper {lvalue}) -> bool

isReserved(...)
C++ signature:     isReserved(TTAMachine::NullRegisterFile {lvalue}) -> bool C++ signature:     isReserved(NullRegisterFile_wrapper {lvalue}) -> bool

isVolatile(...)
C++ signature:     isVolatile(TTAMachine::NullRegisterFile {lvalue}) -> bool C++ signature:     isVolatile(NullRegisterFile_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::NullRegisterFile {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(NullRegisterFile_wrapper {lvalue}, ObjectState const* state) -> void*

machine(...)
C++ signature:     machine(TTAMachine::NullRegisterFile {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(NullRegisterFile_wrapper {lvalue}) -> TTAMachine::Machine*

maxReads(...)
C++ signature:     maxReads(TTAMachine::NullRegisterFile {lvalue}) -> int C++ signature:     maxReads(NullRegisterFile_wrapper {lvalue}) -> int

maxWrites(...)
C++ signature:     maxWrites(TTAMachine::NullRegisterFile {lvalue}) -> int C++ signature:     maxWrites(NullRegisterFile_wrapper {lvalue}) -> int

name(...)
C++ signature:     name(TTAMachine::NullRegisterFile {lvalue}) -> std::string C++ signature:     name(NullRegisterFile_wrapper {lvalue}) -> std::string

numberOfRegisters(...)
C++ signature:     numberOfRegisters(TTAMachine::NullRegisterFile {lvalue}) -> int C++ signature:     numberOfRegisters(NullRegisterFile_wrapper {lvalue}) -> int

portCount(...)
C++ signature:     portCount(TTAMachine::NullRegisterFile {lvalue}) -> int C++ signature:     portCount(NullRegisterFile_wrapper {lvalue}) -> int

removePort(...)
C++ signature: removePort(NullRegisterFile_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::NullRegisterFile {lvalue}) -> ObjectState* C++ signature:     saveState(NullRegisterFile_wrapper {lvalue}) -> ObjectState*

setGuardLatency(...)
C++ signature:     setGuardLatency(TTAMachine::NullRegisterFile {lvalue}, int latency) -> void* C++ signature:     setGuardLatency(NullRegisterFile_wrapper {lvalue}, int latency) -> void*

setMachine(...)
C++ signature:     setMachine(TTAMachine::NullRegisterFile {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(NullRegisterFile_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

setMaxReads(...)
C++ signature:     setMaxReads(TTAMachine::NullRegisterFile {lvalue}, int reads) -> void* C++ signature:     setMaxReads(NullRegisterFile_wrapper {lvalue}, int reads) -> void*

setMaxWrites(...)
C++ signature:     setMaxWrites(TTAMachine::NullRegisterFile {lvalue}, int maxWrites) -> void* C++ signature:     setMaxWrites(NullRegisterFile_wrapper {lvalue}, int maxWrites) -> void*

setName(...)
C++ signature:     setName(TTAMachine::NullRegisterFile {lvalue}, std::string name) -> void* C++ signature:     setName(NullRegisterFile_wrapper {lvalue}, std::string name) -> void*

setNumberOfRegisters(...)
C++ signature:     setNumberOfRegisters(TTAMachine::NullRegisterFile {lvalue}, int registers) -> void* C++ signature:     setNumberOfRegisters(NullRegisterFile_wrapper {lvalue}, int registers) -> void*

setType(...)
C++ signature:     setType(TTAMachine::NullRegisterFile {lvalue}, TTAMachine::RegisterFile::Type type) -> void* C++ signature:     setType(NullRegisterFile_wrapper {lvalue}, TTAMachine::RegisterFile::Type type) -> void*

setWidth(...)
C++ signature:     setWidth(TTAMachine::NullRegisterFile {lvalue}, int width) -> void* C++ signature:     setWidth(NullRegisterFile_wrapper {lvalue}, int width) -> void*

type(...)
C++ signature:     type(TTAMachine::NullRegisterFile {lvalue}) -> TTAMachine::RegisterFile::Type C++ signature:     type(NullRegisterFile_wrapper {lvalue}) -> TTAMachine::RegisterFile::Type

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::NullRegisterFile {lvalue}) -> void* C++ signature:     unsetMachine(NullRegisterFile_wrapper {lvalue}) -> void*

width(...)
C++ signature:     width(TTAMachine::NullRegisterFile {lvalue}) -> int C++ signature:     width(NullRegisterFile_wrapper {lvalue}) -> int

Static methods defined here:

instance(...)
C++ signature: instance(void) -> TTAMachine::NullRegisterFile

Data and other attributes defined here:

__init__ = <built-in function __init__>
Raises an exception This class cannot be instantiated from Python

Methods inherited from RegisterFile:

copy(...)
C++ signature:     copy(TTAMachine::RegisterFile {lvalue}) -> TTAMachine::RegisterFile* C++ signature:     copy(RegisterFile_wrapper {lvalue}) -> TTAMachine::RegisterFile*

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::RegisterFile {lvalue}, TTAMachine::RegisterFile rf) -> bool C++ signature:     isArchitectureEqual(RegisterFile_wrapper {lvalue}, TTAMachine::RegisterFile rf) -> bool

isUsedAsGuard(...)
C++ signature:     isUsedAsGuard(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isUsedAsGuard(RegisterFile_wrapper {lvalue}) -> bool

updateMaxReadsAndWrites(...)
C++ signature: updateMaxReadsAndWrites(TTAMachine::RegisterFile {lvalue}) -> bool

Data descriptors inherited from RegisterFile:

OSKEY_GUARD_LATENCY

OSKEY_MAX_READS

OSKEY_MAX_WRITES

OSKEY_TYPE

OSNAME_REGISTER_FILE

OSVALUE_NORMAL

OSVALUE_RESERVED

OSVALUE_VOLATILE

Data and other attributes inherited from RegisterFile:

NORMAL = TCE.base.mach.Type.NORMAL

RESERVED = TCE.base.mach.Type.RESERVED

Type = <class 'TCE.base.TCE.base.mach.Type'>

VOLATILE = TCE.base.mach.Type.VOLATILE

__instance_size__ = 60

Methods inherited from BaseRegisterFile:

port(...)
C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, int index) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, int index) -> TTAMachine::RFPort*

Data descriptors inherited from BaseRegisterFile:

OSKEY_SIZE

OSKEY_WIDTH

OSNAME_BASE_REGISTER_FILE

Data descriptors inherited from Unit:

OSNAME_UNIT

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class PipelineElement(Boost.Python.instance)


Method resolution order:

PipelineElement

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, std::string name, TTAMachine::FunctionUnit {lvalue} parentUnit) -> void*

setName(...)
C++ signature: setName(TTAMachine::PipelineElement {lvalue}, std::string name) -> void*

Data and other attributes defined here:

__instance_size__ = 20

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Port(SubComponent)


Method resolution order:

Port

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, TTAMachine::Unit {lvalue} parentUnit) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Unit {lvalue} parentUnit) -> void*

attachSocket(...)
C++ signature:     attachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     attachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

detachAllSockets(...)
C++ signature:     detachAllSockets(TTAMachine::Port {lvalue}) -> void* C++ signature:     detachAllSockets(Port_wrapper {lvalue}) -> void*

detachSocket(...)
C++ signature:     detachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     detachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

inputSocket(...)
C++ signature:     inputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     inputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::Port {lvalue}, TTAMachine::Socket socket) -> bool C++ signature:     isConnectedTo(Port_wrapper {lvalue}, TTAMachine::Socket socket) -> bool

isInput(...)
C++ signature:     isInput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isInput(Port_wrapper {lvalue}) -> bool

isOutput(...)
C++ signature:     isOutput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isOutput(Port_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::Port {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(Port_wrapper {lvalue}, ObjectState const* state) -> void*

name(...)
C++ signature:     name(TTAMachine::Port {lvalue}) -> std::string C++ signature:     name(Port_wrapper {lvalue}) -> std::string

outputSocket(...)
C++ signature:     outputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     outputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

saveState(...)
C++ signature:     saveState(TTAMachine::Port {lvalue}) -> ObjectState* C++ signature:     saveState(Port_wrapper {lvalue}) -> ObjectState*

setName(...)
C++ signature:     setName(TTAMachine::Port {lvalue}, std::string name) -> void* C++ signature:     setName(Port_wrapper {lvalue}, std::string name) -> void*

socketCount(...)
C++ signature:     socketCount(TTAMachine::Port {lvalue}) -> int C++ signature:     socketCount(Port_wrapper {lvalue}) -> int

unconnectedSocket(...)
C++ signature:     unconnectedSocket(TTAMachine::Port {lvalue}, int index) -> TTAMachine::Socket* C++ signature:     unconnectedSocket(Port_wrapper {lvalue}, int index) -> TTAMachine::Socket*

width(...)
C++ signature:     width(TTAMachine::Port {lvalue}) -> int C++ signature:     width(Port_wrapper {lvalue}) -> void*

Data descriptors defined here:

OSKEY_FIRST_SOCKET

OSKEY_NAME

OSKEY_SECOND_SOCKET

OSNAME_PORT

Data and other attributes defined here:

__instance_size__ = 32

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class PortGuard(Guard)


Method resolution order:

PortGuard

Guard

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, bool inverted, TTAMachine::FUPort {lvalue} port, TTAMachine::Bus {lvalue} parentBus) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Bus {lvalue} parentBus) -> void*

isEqual(...)
C++ signature:     isEqual(TTAMachine::PortGuard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isEqual(PortGuard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::PortGuard {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(PortGuard_wrapper {lvalue}, ObjectState const* state) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::PortGuard {lvalue}) -> ObjectState* C++ signature:     saveState(PortGuard_wrapper {lvalue}) -> ObjectState*

Data descriptors defined here:

OSKEY_FU

OSKEY_PORT

OSNAME_PORT_GUARD

Data and other attributes defined here:

__instance_size__ = 28

Methods inherited from Guard:

isDisjoint(...)
C++ signature:     isDisjoint(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isDisjoint(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

isLessRestrictive(...)
C++ signature:     isLessRestrictive(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isLessRestrictive(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

isMoreRestrictive(...)
C++ signature:     isMoreRestrictive(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isMoreRestrictive(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

Data descriptors inherited from Guard:

OSKEY_INVERTED

OSNAME_GUARD

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class RFPort(Port)


Method resolution order:

RFPort

Port

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, TTAMachine::BaseRegisterFile {lvalue} parent) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Unit {lvalue} parent) -> void*

loadState(...)
C++ signature:     loadState(TTAMachine::RFPort {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(RFPort_wrapper {lvalue}, ObjectState const* state) -> void*

parentUnit(...)
C++ signature: parentUnit(TTAMachine::RFPort {lvalue}) -> TTAMachine::BaseRegisterFile*

saveState(...)
C++ signature:     saveState(TTAMachine::RFPort {lvalue}) -> ObjectState* C++ signature:     saveState(RFPort_wrapper {lvalue}) -> ObjectState*

width(...)
C++ signature:     width(TTAMachine::RFPort {lvalue}) -> int C++ signature:     width(RFPort_wrapper {lvalue}) -> int

Data descriptors defined here:

OSNAME_RFPORT

Data and other attributes defined here:

__instance_size__ = 32

Methods inherited from Port:

attachSocket(...)
C++ signature:     attachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     attachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

detachAllSockets(...)
C++ signature:     detachAllSockets(TTAMachine::Port {lvalue}) -> void* C++ signature:     detachAllSockets(Port_wrapper {lvalue}) -> void*

detachSocket(...)
C++ signature:     detachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     detachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

inputSocket(...)
C++ signature:     inputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     inputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::Port {lvalue}, TTAMachine::Socket socket) -> bool C++ signature:     isConnectedTo(Port_wrapper {lvalue}, TTAMachine::Socket socket) -> bool

isInput(...)
C++ signature:     isInput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isInput(Port_wrapper {lvalue}) -> bool

isOutput(...)
C++ signature:     isOutput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isOutput(Port_wrapper {lvalue}) -> bool

name(...)
C++ signature:     name(TTAMachine::Port {lvalue}) -> std::string C++ signature:     name(Port_wrapper {lvalue}) -> std::string

outputSocket(...)
C++ signature:     outputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     outputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

setName(...)
C++ signature:     setName(TTAMachine::Port {lvalue}, std::string name) -> void* C++ signature:     setName(Port_wrapper {lvalue}, std::string name) -> void*

socketCount(...)
C++ signature:     socketCount(TTAMachine::Port {lvalue}) -> int C++ signature:     socketCount(Port_wrapper {lvalue}) -> int

unconnectedSocket(...)
C++ signature:     unconnectedSocket(TTAMachine::Port {lvalue}, int index) -> TTAMachine::Socket* C++ signature:     unconnectedSocket(Port_wrapper {lvalue}, int index) -> TTAMachine::Socket*

Data descriptors inherited from Port:

OSKEY_FIRST_SOCKET

OSKEY_NAME

OSKEY_SECOND_SOCKET

OSNAME_PORT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class RegisterFile(BaseRegisterFile)


Method resolution order:

RegisterFile

BaseRegisterFile

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, unsigned int size, unsigned int width, unsigned int maxReads, unsigned int maxwrites, unsigned int guardLatency, TTAMachine::RegisterFile::Type type) -> void* C++ signature:     __init__(_object*, ObjectState const* state) -> void*

copy(...)
C++ signature:     copy(TTAMachine::RegisterFile {lvalue}) -> TTAMachine::RegisterFile* C++ signature:     copy(RegisterFile_wrapper {lvalue}) -> TTAMachine::RegisterFile*

guardLatency(...)
C++ signature:     guardLatency(TTAMachine::RegisterFile {lvalue}) -> int C++ signature:     guardLatency(RegisterFile_wrapper {lvalue}) -> int

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::RegisterFile {lvalue}, TTAMachine::RegisterFile rf) -> bool C++ signature:     isArchitectureEqual(RegisterFile_wrapper {lvalue}, TTAMachine::RegisterFile rf) -> bool

isNormal(...)
C++ signature:     isNormal(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isNormal(RegisterFile_wrapper {lvalue}) -> bool

isReserved(...)
C++ signature:     isReserved(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isReserved(RegisterFile_wrapper {lvalue}) -> bool

isUsedAsGuard(...)
C++ signature:     isUsedAsGuard(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isUsedAsGuard(RegisterFile_wrapper {lvalue}) -> bool

isVolatile(...)
C++ signature:     isVolatile(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isVolatile(RegisterFile_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::RegisterFile {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(RegisterFile_wrapper {lvalue}, ObjectState const* state) -> void*

maxReads(...)
C++ signature:     maxReads(TTAMachine::RegisterFile {lvalue}) -> int C++ signature:     maxReads(RegisterFile_wrapper {lvalue}) -> int

maxWrites(...)
C++ signature:     maxWrites(TTAMachine::RegisterFile {lvalue}) -> int C++ signature:     maxWrites(RegisterFile_wrapper {lvalue}) -> int

removePort(...)
C++ signature: removePort(RegisterFile_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::RegisterFile {lvalue}) -> ObjectState* C++ signature:     saveState(RegisterFile_wrapper {lvalue}) -> ObjectState*

setGuardLatency(...)
C++ signature:     setGuardLatency(TTAMachine::RegisterFile {lvalue}, int latency) -> void* C++ signature:     setGuardLatency(RegisterFile_wrapper {lvalue}, int latency) -> void*

setMaxReads(...)
C++ signature:     setMaxReads(TTAMachine::RegisterFile {lvalue}, int maxReads) -> void* C++ signature:     setMaxReads(RegisterFile_wrapper {lvalue}, int maxReads) -> void*

setMaxWrites(...)
C++ signature:     setMaxWrites(TTAMachine::RegisterFile {lvalue}, int maxWrites) -> void* C++ signature:     setMaxWrites(RegisterFile_wrapper {lvalue}, int maxWrites) -> void*

setName(...)
C++ signature:     setName(TTAMachine::RegisterFile {lvalue}, std::string name) -> void* C++ signature:     setName(RegisterFile_wrapper {lvalue}, std::string name) -> void*

setNumberOfRegisters(...)
C++ signature:     setNumberOfRegisters(TTAMachine::RegisterFile {lvalue}, int registers) -> void* C++ signature:     setNumberOfRegisters(RegisterFile_wrapper {lvalue}, int registers) -> void*

setType(...)
C++ signature:     setType(TTAMachine::RegisterFile {lvalue}, TTAMachine::RegisterFile::Type type) -> void* C++ signature:     setType(RegisterFile_wrapper {lvalue}, TTAMachine::RegisterFile::Type type) -> void*

type(...)
C++ signature:     type(TTAMachine::RegisterFile {lvalue}) -> TTAMachine::RegisterFile::Type C++ signature:     type(RegisterFile_wrapper {lvalue}) -> TTAMachine::RegisterFile::Type

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::RegisterFile {lvalue}) -> void* C++ signature:     unsetMachine(RegisterFile_wrapper {lvalue}) -> void*

updateMaxReadsAndWrites(...)
C++ signature: updateMaxReadsAndWrites(TTAMachine::RegisterFile {lvalue}) -> bool

Data descriptors defined here:

OSKEY_GUARD_LATENCY

OSKEY_MAX_READS

OSKEY_MAX_WRITES

OSKEY_TYPE

OSNAME_REGISTER_FILE

OSVALUE_NORMAL

OSVALUE_RESERVED

OSVALUE_VOLATILE

Data and other attributes defined here:

NORMAL = TCE.base.mach.Type.NORMAL

RESERVED = TCE.base.mach.Type.RESERVED

Type = <class 'TCE.base.TCE.base.mach.Type'>

VOLATILE = TCE.base.mach.Type.VOLATILE

__instance_size__ = 60

Methods inherited from BaseRegisterFile:

port(...)
C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, int index) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, int index) -> TTAMachine::RFPort*

setWidth(...)
C++ signature:     setWidth(TTAMachine::BaseRegisterFile {lvalue}, int width) -> void* C++ signature:     setWidth(BaseRegisterFile_wrapper {lvalue}, int width) -> void*

Data descriptors inherited from BaseRegisterFile:

OSKEY_SIZE

OSKEY_WIDTH

OSNAME_BASE_REGISTER_FILE

Methods inherited from Unit:

hasPort(...)
C++ signature:     hasPort(TTAMachine::Unit {lvalue}, std::string name) -> bool C++ signature:     hasPort(Unit_wrapper {lvalue}, std::string name) -> bool

portCount(...)
C++ signature:     portCount(TTAMachine::Unit {lvalue}) -> int C++ signature:     portCount(Unit_wrapper {lvalue}) -> int

setMachine(...)
C++ signature:     setMachine(TTAMachine::Unit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(Unit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

Data descriptors inherited from Unit:

OSNAME_UNIT

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class RegisterGuard(Guard)


Method resolution order:

RegisterGuard

Guard

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, bool inverted, TTAMachine::RegisterFile {lvalue} regFile, int registerIndex, TTAMachine::Bus {lvalue} parentBus) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Bus {lvalue} parentBus) -> void*

isEqual(...)
C++ signature:     isEqual(TTAMachine::RegisterGuard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isEqual(RegisterGuard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::RegisterGuard {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(RegisterGuard_wrapper {lvalue}, ObjectState const* state) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::RegisterGuard {lvalue}) -> ObjectState* C++ signature:     saveState(RegisterGuard_wrapper {lvalue}) -> ObjectState*

Data descriptors defined here:

OSKEY_INDEX

OSKEY_REGFILE

OSNAME_REGISTER_GUARD

Data and other attributes defined here:

__instance_size__ = 32

Methods inherited from Guard:

isDisjoint(...)
C++ signature:     isDisjoint(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isDisjoint(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

isLessRestrictive(...)
C++ signature:     isLessRestrictive(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isLessRestrictive(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

isMoreRestrictive(...)
C++ signature:     isMoreRestrictive(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isMoreRestrictive(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

Data descriptors inherited from Guard:

OSKEY_INVERTED

OSNAME_GUARD

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Segment(SubComponent)


Method resolution order:

Segment

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, TTAMachine::Bus {lvalue} parent) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Bus {lvalue} parent) -> void*

attachSocket(...)
C++ signature: attachSocket(TTAMachine::Segment {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

connection(...)
C++ signature:     connection(TTAMachine::Segment {lvalue}, TTAMachine::Socket socket) -> TTAMachine::Connection C++ signature:     connection(TTAMachine::Segment {lvalue}, int index) -> TTAMachine::Socket*

detachAllSockets(...)
C++ signature: detachAllSockets(TTAMachine::Segment {lvalue}) -> void*

detachSocket(...)
C++ signature: detachSocket(TTAMachine::Segment {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

hasDestinationSegment(...)
C++ signature: hasDestinationSegment(TTAMachine::Segment {lvalue}) -> bool

hasSourceSegment(...)
C++ signature: hasSourceSegment(TTAMachine::Segment {lvalue}) -> bool

isConnectedTo(...)
C++ signature: isConnectedTo(TTAMachine::Segment {lvalue}, TTAMachine::Socket socket) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::Segment {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(Segment_wrapper {lvalue}, ObjectState const* state) -> void*

moveAfter(...)
C++ signature: moveAfter(TTAMachine::Segment {lvalue}, TTAMachine::Segment {lvalue} segment) -> void*

moveBefore(...)
C++ signature: moveBefore(TTAMachine::Segment {lvalue}, TTAMachine::Segment {lvalue} segment) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::Segment {lvalue}) -> ObjectState* C++ signature:     saveState(Segment_wrapper {lvalue}) -> ObjectState*

setName(...)
C++ signature: setName(TTAMachine::Segment {lvalue}, std::string name) -> void*

Data descriptors defined here:

OSKEY_DESTINATION

OSKEY_NAME

OSNAME_SEGMENT

Data and other attributes defined here:

__instance_size__ = 44

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class SmartHWOperation(HWOperation)


Method resolution order:

SmartHWOperation

HWOperation

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, Operation operation, UniversalFunctionUnit {lvalue} parent) -> void*

bindPort(...)
C++ signature:     bindPort(SmartHWOperation {lvalue}, int operand, TTAMachine::FUPort port) -> void* C++ signature:     bindPort(SmartHWOperation_wrapper {lvalue}, int operand, TTAMachine::FUPort port) -> void*

loadState(...)
C++ signature:     loadState(SmartHWOperation {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(SmartHWOperation_wrapper {lvalue}, ObjectState const* state) -> void*

parentUnit(...)
C++ signature: parentUnit(SmartHWOperation {lvalue}) -> UniversalFunctionUnit*

port(...)
C++ signature:     port(SmartHWOperation {lvalue}, int operand) -> TTAMachine::FUPort* C++ signature:     port(SmartHWOperation_wrapper {lvalue}, int operand) -> TTAMachine::FUPort*

setName(...)
C++ signature:     setName(SmartHWOperation {lvalue}, std::string name) -> void* C++ signature:     setName(SmartHWOperation_wrapper {lvalue}, std::string name) -> void*

unbindPort(...)
C++ signature:     unbindPort(SmartHWOperation {lvalue}, TTAMachine::FUPort port) -> void* C++ signature:     unbindPort(SmartHWOperation_wrapper {lvalue}, TTAMachine::FUPort port) -> void*

Data and other attributes defined here:

__instance_size__ = 60

Methods inherited from HWOperation:

io(...)
C++ signature: io(TTAMachine::HWOperation {lvalue}, TTAMachine::FUPort port) -> int

isBound(...)
C++ signature: isBound(TTAMachine::HWOperation {lvalue}, TTAMachine::FUPort port) -> bool

latency(...)
C++ signature:     latency(TTAMachine::HWOperation {lvalue}) -> int C++ signature:     latency(TTAMachine::HWOperation {lvalue}, int output) -> int

name(...)
C++ signature: name(TTAMachine::HWOperation {lvalue}) -> std::string

pipeline(...)
C++ signature: pipeline(TTAMachine::HWOperation {lvalue}) -> TTAMachine::ExecutionPipeline*

saveState(...)
C++ signature:     saveState(TTAMachine::HWOperation {lvalue}) -> ObjectState* C++ signature:     saveState(HWOperation_wrapper {lvalue}) -> ObjectState*

slack(...)
C++ signature: slack(TTAMachine::HWOperation {lvalue}, int input) -> int

Data descriptors inherited from HWOperation:

OSKEY_NAME

OSKEY_OPERAND

OSKEY_PORT

OSNAME_OPERAND_BINDING

OSNAME_OPERATION

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Socket(Component)


Method resolution order:

Socket

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name) -> void* C++ signature:     __init__(_object*, ObjectState const* state) -> void*

attachBus(...)
C++ signature: attachBus(TTAMachine::Socket {lvalue}, TTAMachine::Segment {lvalue} bus) -> void*

connection(...)
C++ signature: connection(TTAMachine::Socket {lvalue}, TTAMachine::Segment bus) -> TTAMachine::Connection

detachAllPorts(...)
C++ signature: detachAllPorts(TTAMachine::Socket {lvalue}) -> void*

detachBus(...)
C++ signature:     detachBus(TTAMachine::Socket {lvalue}, TTAMachine::Segment {lvalue} bus) -> void* C++ signature:     detachBus(TTAMachine::Socket {lvalue}, TTAMachine::Bus {lvalue} bus) -> void*

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::Socket {lvalue}, TTAMachine::Bus bus) -> bool C++ signature:     isConnectedTo(TTAMachine::Socket {lvalue}, TTAMachine::Segment bus) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::Socket {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(Socket_wrapper {lvalue}, ObjectState const* state) -> void*

port(...)
C++ signature: port(TTAMachine::Socket {lvalue}, int index) -> TTAMachine::Port*

saveState(...)
C++ signature:     saveState(TTAMachine::Socket {lvalue}) -> ObjectState* C++ signature:     saveState(Socket_wrapper {lvalue}) -> ObjectState*

segment(...)
C++ signature: segment(TTAMachine::Socket {lvalue}, int index) -> TTAMachine::Segment*

setDirection(...)
C++ signature: setDirection(TTAMachine::Socket {lvalue}, TTAMachine::Socket::Direction direction) -> void*

setMachine(...)
C++ signature:     setMachine(TTAMachine::Socket {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(Socket_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

setName(...)
C++ signature:     setName(TTAMachine::Socket {lvalue}, std::string name) -> void* C++ signature:     setName(Socket_wrapper {lvalue}, std::string name) -> void*

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::Socket {lvalue}) -> void* C++ signature:     unsetMachine(Socket_wrapper {lvalue}) -> void*

Data descriptors defined here:

OSKEY_DIRECTION

OSNAME_SOCKET

OSVALUE_INPUT

OSVALUE_OUTPUT

OSVALUE_UNKNOWN

Data and other attributes defined here:

Direction = <class 'TCE.base.TCE.base.mach.Direction'>

INPUT = TCE.base.mach.Direction.INPUT

OUTPUT = TCE.base.mach.Direction.OUTPUT

UNKNOWN = TCE.base.mach.Direction.UNKNOWN

__instance_size__ = 52

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class SpecialRegisterPort(BaseFUPort)


Method resolution order:

SpecialRegisterPort

BaseFUPort

Port

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name, int width, TTAMachine::ControlUnit {lvalue} parent) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Unit {lvalue} parent) -> void*

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAMachine::SpecialRegisterPort {lvalue}) -> bool C++ signature:     isOpcodeSetting(SpecialRegisterPort_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAMachine::SpecialRegisterPort {lvalue}) -> bool C++ signature:     isTriggering(SpecialRegisterPort_wrapper {lvalue}) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::SpecialRegisterPort {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(SpecialRegisterPort_wrapper {lvalue}, ObjectState const* state) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::SpecialRegisterPort {lvalue}) -> ObjectState* C++ signature:     saveState(SpecialRegisterPort_wrapper {lvalue}) -> ObjectState*

Data descriptors defined here:

OSNAME_SPECIAL_REG_PORT

Data and other attributes defined here:

__instance_size__ = 36

Methods inherited from BaseFUPort:

parentUnit(...)
C++ signature: parentUnit(TTAMachine::BaseFUPort {lvalue}) -> TTAMachine::FunctionUnit*

setWidth(...)
C++ signature: setWidth(TTAMachine::BaseFUPort {lvalue}, int width) -> void*

width(...)
C++ signature:     width(TTAMachine::BaseFUPort {lvalue}) -> int C++ signature:     width(BaseFUPort_wrapper {lvalue}) -> int

Data descriptors inherited from BaseFUPort:

OSKEY_WIDTH

Methods inherited from Port:

attachSocket(...)
C++ signature:     attachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     attachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

detachAllSockets(...)
C++ signature:     detachAllSockets(TTAMachine::Port {lvalue}) -> void* C++ signature:     detachAllSockets(Port_wrapper {lvalue}) -> void*

detachSocket(...)
C++ signature:     detachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     detachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

inputSocket(...)
C++ signature:     inputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     inputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::Port {lvalue}, TTAMachine::Socket socket) -> bool C++ signature:     isConnectedTo(Port_wrapper {lvalue}, TTAMachine::Socket socket) -> bool

isInput(...)
C++ signature:     isInput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isInput(Port_wrapper {lvalue}) -> bool

isOutput(...)
C++ signature:     isOutput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isOutput(Port_wrapper {lvalue}) -> bool

name(...)
C++ signature:     name(TTAMachine::Port {lvalue}) -> std::string C++ signature:     name(Port_wrapper {lvalue}) -> std::string

outputSocket(...)
C++ signature:     outputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     outputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

setName(...)
C++ signature:     setName(TTAMachine::Port {lvalue}, std::string name) -> void* C++ signature:     setName(Port_wrapper {lvalue}, std::string name) -> void*

socketCount(...)
C++ signature:     socketCount(TTAMachine::Port {lvalue}) -> int C++ signature:     socketCount(Port_wrapper {lvalue}) -> int

unconnectedSocket(...)
C++ signature:     unconnectedSocket(TTAMachine::Port {lvalue}, int index) -> TTAMachine::Socket* C++ signature:     unconnectedSocket(Port_wrapper {lvalue}, int index) -> TTAMachine::Socket*

Data descriptors inherited from Port:

OSKEY_FIRST_SOCKET

OSKEY_NAME

OSKEY_SECOND_SOCKET

OSNAME_PORT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class SubComponent(MachinePart)


Method resolution order:

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*) -> void*

loadState(...)
C++ signature:     loadState(TTAMachine::SubComponent {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(SubComponent_wrapper {lvalue}, ObjectState const*) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::SubComponent {lvalue}) -> ObjectState* C++ signature:     saveState(SubComponent_wrapper {lvalue}) -> void*

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class TemplateSlot(Boost.Python.instance)


Method resolution order:

TemplateSlot

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, TTAMachine::Bus slot, int width, TTAMachine::ImmediateUnit {lvalue} destination) -> void* C++ signature:     __init__(_object*, TTAMachine::ImmediateSlot slot, int width, TTAMachine::ImmediateUnit {lvalue} destination) -> void*

saveState(...)
C++ signature: saveState(TTAMachine::TemplateSlot {lvalue}) -> ObjectState*

Data descriptors defined here:

OSKEY_DESTINATION

OSKEY_SLOT

OSKEY_WIDTH

OSNAME_TEMPLATE_SLOT

Data and other attributes defined here:

__instance_size__ = 28

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class UnboundedRegisterFile(RegisterFile)


Method resolution order:

UnboundedRegisterFile

RegisterFile

BaseRegisterFile

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, std::string name, int width, TTAMachine::RegisterFile::Type type) -> void*

loadState(...)
C++ signature:     loadState(UnboundedRegisterFile {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(UnboundedRegisterFile_wrapper {lvalue}, ObjectState const* state) -> void*

numberOfRegisters(...)
C++ signature:     numberOfRegisters(UnboundedRegisterFile {lvalue}) -> int C++ signature:     numberOfRegisters(UnboundedRegisterFile_wrapper {lvalue}) -> int

removePort(...)
C++ signature: removePort(UnboundedRegisterFile_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

setMaxReads(...)
C++ signature:     setMaxReads(UnboundedRegisterFile {lvalue}, int reads) -> void* C++ signature:     setMaxReads(UnboundedRegisterFile_wrapper {lvalue}, int reads) -> void*

setMaxWrites(...)
C++ signature:     setMaxWrites(UnboundedRegisterFile {lvalue}, int maxWrites) -> void* C++ signature:     setMaxWrites(UnboundedRegisterFile_wrapper {lvalue}, int maxWrites) -> void*

setName(...)
C++ signature:     setName(UnboundedRegisterFile {lvalue}, std::string name) -> void* C++ signature:     setName(UnboundedRegisterFile_wrapper {lvalue}, std::string name) -> void*

setNumberOfRegisters(...)
C++ signature:     setNumberOfRegisters(UnboundedRegisterFile {lvalue}, int registers) -> void* C++ signature:     setNumberOfRegisters(UnboundedRegisterFile_wrapper {lvalue}, int registers) -> void*

setType(...)
C++ signature:     setType(UnboundedRegisterFile {lvalue}, TTAMachine::RegisterFile::Type type) -> void* C++ signature:     setType(UnboundedRegisterFile_wrapper {lvalue}, TTAMachine::RegisterFile::Type type) -> void*

setWidth(...)
C++ signature:     setWidth(UnboundedRegisterFile {lvalue}, int width) -> void* C++ signature:     setWidth(UnboundedRegisterFile_wrapper {lvalue}, int width) -> void*

Data and other attributes defined here:

__instance_size__ = 60

Methods inherited from RegisterFile:

copy(...)
C++ signature:     copy(TTAMachine::RegisterFile {lvalue}) -> TTAMachine::RegisterFile* C++ signature:     copy(RegisterFile_wrapper {lvalue}) -> TTAMachine::RegisterFile*

guardLatency(...)
C++ signature:     guardLatency(TTAMachine::RegisterFile {lvalue}) -> int C++ signature:     guardLatency(RegisterFile_wrapper {lvalue}) -> int

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::RegisterFile {lvalue}, TTAMachine::RegisterFile rf) -> bool C++ signature:     isArchitectureEqual(RegisterFile_wrapper {lvalue}, TTAMachine::RegisterFile rf) -> bool

isNormal(...)
C++ signature:     isNormal(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isNormal(RegisterFile_wrapper {lvalue}) -> bool

isReserved(...)
C++ signature:     isReserved(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isReserved(RegisterFile_wrapper {lvalue}) -> bool

isUsedAsGuard(...)
C++ signature:     isUsedAsGuard(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isUsedAsGuard(RegisterFile_wrapper {lvalue}) -> bool

isVolatile(...)
C++ signature:     isVolatile(TTAMachine::RegisterFile {lvalue}) -> bool C++ signature:     isVolatile(RegisterFile_wrapper {lvalue}) -> bool

maxReads(...)
C++ signature:     maxReads(TTAMachine::RegisterFile {lvalue}) -> int C++ signature:     maxReads(RegisterFile_wrapper {lvalue}) -> int

maxWrites(...)
C++ signature:     maxWrites(TTAMachine::RegisterFile {lvalue}) -> int C++ signature:     maxWrites(RegisterFile_wrapper {lvalue}) -> int

saveState(...)
C++ signature:     saveState(TTAMachine::RegisterFile {lvalue}) -> ObjectState* C++ signature:     saveState(RegisterFile_wrapper {lvalue}) -> ObjectState*

setGuardLatency(...)
C++ signature:     setGuardLatency(TTAMachine::RegisterFile {lvalue}, int latency) -> void* C++ signature:     setGuardLatency(RegisterFile_wrapper {lvalue}, int latency) -> void*

type(...)
C++ signature:     type(TTAMachine::RegisterFile {lvalue}) -> TTAMachine::RegisterFile::Type C++ signature:     type(RegisterFile_wrapper {lvalue}) -> TTAMachine::RegisterFile::Type

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::RegisterFile {lvalue}) -> void* C++ signature:     unsetMachine(RegisterFile_wrapper {lvalue}) -> void*

updateMaxReadsAndWrites(...)
C++ signature: updateMaxReadsAndWrites(TTAMachine::RegisterFile {lvalue}) -> bool

Data descriptors inherited from RegisterFile:

OSKEY_GUARD_LATENCY

OSKEY_MAX_READS

OSKEY_MAX_WRITES

OSKEY_TYPE

OSNAME_REGISTER_FILE

OSVALUE_NORMAL

OSVALUE_RESERVED

OSVALUE_VOLATILE

Data and other attributes inherited from RegisterFile:

NORMAL = TCE.base.mach.Type.NORMAL

RESERVED = TCE.base.mach.Type.RESERVED

Type = <class 'TCE.base.TCE.base.mach.Type'>

VOLATILE = TCE.base.mach.Type.VOLATILE

Methods inherited from BaseRegisterFile:

port(...)
C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, std::string name) -> TTAMachine::RFPort* C++ signature:     port(TTAMachine::BaseRegisterFile {lvalue}, int index) -> TTAMachine::RFPort* C++ signature:     port(BaseRegisterFile_wrapper {lvalue}, int index) -> TTAMachine::RFPort*

Data descriptors inherited from BaseRegisterFile:

OSKEY_SIZE

OSKEY_WIDTH

OSNAME_BASE_REGISTER_FILE

Methods inherited from Unit:

hasPort(...)
C++ signature:     hasPort(TTAMachine::Unit {lvalue}, std::string name) -> bool C++ signature:     hasPort(Unit_wrapper {lvalue}, std::string name) -> bool

portCount(...)
C++ signature:     portCount(TTAMachine::Unit {lvalue}) -> int C++ signature:     portCount(Unit_wrapper {lvalue}) -> int

setMachine(...)
C++ signature:     setMachine(TTAMachine::Unit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(Unit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

Data descriptors inherited from Unit:

OSNAME_UNIT

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class UnconditionalGuard(Guard)


Method resolution order:

UnconditionalGuard

Guard

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, bool inverted, TTAMachine::Bus {lvalue} parentBus) -> void* C++ signature:     __init__(_object*, ObjectState const* state, TTAMachine::Bus {lvalue} parentBus) -> void*

isEqual(...)
C++ signature:     isEqual(TTAMachine::UnconditionalGuard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isEqual(UnconditionalGuard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::UnconditionalGuard {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(UnconditionalGuard_wrapper {lvalue}, ObjectState const* state) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::UnconditionalGuard {lvalue}) -> ObjectState* C++ signature:     saveState(UnconditionalGuard_wrapper {lvalue}) -> ObjectState*

Data descriptors defined here:

OSNAME_UNCONDITIONAL_GUARD

Data and other attributes defined here:

__instance_size__ = 24

Methods inherited from Guard:

isDisjoint(...)
C++ signature:     isDisjoint(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isDisjoint(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

isLessRestrictive(...)
C++ signature:     isLessRestrictive(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isLessRestrictive(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

isMoreRestrictive(...)
C++ signature:     isMoreRestrictive(TTAMachine::Guard {lvalue}, TTAMachine::Guard guard) -> bool C++ signature:     isMoreRestrictive(Guard_wrapper {lvalue}, TTAMachine::Guard guard) -> bool

Data descriptors inherited from Guard:

OSKEY_INVERTED

OSNAME_GUARD

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class Unit(Component)


Method resolution order:

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*, std::string name) -> void* C++ signature:     __init__(_object*, ObjectState const* state) -> void*

hasPort(...)
C++ signature:     hasPort(TTAMachine::Unit {lvalue}, std::string name) -> bool C++ signature:     hasPort(Unit_wrapper {lvalue}, std::string name) -> bool

loadState(...)
C++ signature:     loadState(TTAMachine::Unit {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(Unit_wrapper {lvalue}, ObjectState const* state) -> void*

port(...)
C++ signature:     port(TTAMachine::Unit {lvalue}, std::string name) -> TTAMachine::Port* C++ signature:     port(Unit_wrapper {lvalue}, std::string name) -> TTAMachine::Port* C++ signature:     port(TTAMachine::Unit {lvalue}, int index) -> TTAMachine::Port* C++ signature:     port(Unit_wrapper {lvalue}, int index) -> TTAMachine::Port*

portCount(...)
C++ signature:     portCount(TTAMachine::Unit {lvalue}) -> int C++ signature:     portCount(Unit_wrapper {lvalue}) -> int

removePort(...)
C++ signature: removePort(Unit_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::Unit {lvalue}) -> ObjectState* C++ signature:     saveState(Unit_wrapper {lvalue}) -> ObjectState*

setMachine(...)
C++ signature:     setMachine(TTAMachine::Unit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(Unit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::Unit {lvalue}) -> void* C++ signature:     unsetMachine(Unit_wrapper {lvalue}) -> void*

Data descriptors defined here:

OSNAME_UNIT

Data and other attributes defined here:

__instance_size__ = 36

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

setName(...)
C++ signature:     setName(TTAMachine::Component {lvalue}, std::string name) -> void* C++ signature:     setName(Component_wrapper {lvalue}, std::string name) -> void*

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class UniversalFUPort(FUPort)


Method resolution order:

UniversalFUPort

FUPort

BaseFUPort

Port

SubComponent

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, std::string name, int width, UniversalFunctionUnit {lvalue} parent, bool isTriggering, bool setsOpcode) -> void*

loadState(...)
C++ signature:     loadState(UniversalFUPort {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(UniversalFUPort_wrapper {lvalue}, ObjectState const* state) -> void*

setName(...)
C++ signature:     setName(UniversalFUPort {lvalue}, std::string name) -> void* C++ signature:     setName(UniversalFUPort_wrapper {lvalue}, std::string name) -> void*

setOpcodeSetting(...)
C++ signature:     setOpcodeSetting(UniversalFUPort {lvalue}, bool setsOpcode) -> void* C++ signature:     setOpcodeSetting(UniversalFUPort_wrapper {lvalue}, bool setsOpcode) -> void*

setTriggering(...)
C++ signature:     setTriggering(UniversalFUPort {lvalue}, bool triggers) -> void* C++ signature:     setTriggering(UniversalFUPort_wrapper {lvalue}, bool triggers) -> void*

setWidth(...)
C++ signature:     setWidth(UniversalFUPort {lvalue}, int width) -> void* C++ signature:     setWidth(UniversalFUPort_wrapper {lvalue}, int width) -> void*

Data and other attributes defined here:

__instance_size__ = 44

Methods inherited from FUPort:

bindingString(...)
C++ signature: bindingString(TTAMachine::FUPort {lvalue}) -> std::string

isArchitectureEqual(...)
C++ signature: isArchitectureEqual(TTAMachine::FUPort {lvalue}, TTAMachine::FUPort* port) -> bool

isOpcodeSetting(...)
C++ signature:     isOpcodeSetting(TTAMachine::FUPort {lvalue}) -> bool C++ signature:     isOpcodeSetting(FUPort_wrapper {lvalue}) -> bool

isTriggering(...)
C++ signature:     isTriggering(TTAMachine::FUPort {lvalue}) -> bool C++ signature:     isTriggering(FUPort_wrapper {lvalue}) -> bool

saveState(...)
C++ signature:     saveState(TTAMachine::FUPort {lvalue}) -> ObjectState* C++ signature:     saveState(FUPort_wrapper {lvalue}) -> ObjectState*

updateBindingString(...)
C++ signature: updateBindingString(TTAMachine::FUPort {lvalue}) -> void*

Data descriptors inherited from FUPort:

OSKEY_OPCODE_SETTING

OSKEY_TRIGGERING

OSNAME_FUPORT

Methods inherited from BaseFUPort:

parentUnit(...)
C++ signature: parentUnit(TTAMachine::BaseFUPort {lvalue}) -> TTAMachine::FunctionUnit*

width(...)
C++ signature:     width(TTAMachine::BaseFUPort {lvalue}) -> int C++ signature:     width(BaseFUPort_wrapper {lvalue}) -> int

Data descriptors inherited from BaseFUPort:

OSKEY_WIDTH

Methods inherited from Port:

attachSocket(...)
C++ signature:     attachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     attachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

detachAllSockets(...)
C++ signature:     detachAllSockets(TTAMachine::Port {lvalue}) -> void* C++ signature:     detachAllSockets(Port_wrapper {lvalue}) -> void*

detachSocket(...)
C++ signature:     detachSocket(TTAMachine::Port {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     detachSocket(Port_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

inputSocket(...)
C++ signature:     inputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     inputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

isConnectedTo(...)
C++ signature:     isConnectedTo(TTAMachine::Port {lvalue}, TTAMachine::Socket socket) -> bool C++ signature:     isConnectedTo(Port_wrapper {lvalue}, TTAMachine::Socket socket) -> bool

isInput(...)
C++ signature:     isInput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isInput(Port_wrapper {lvalue}) -> bool

isOutput(...)
C++ signature:     isOutput(TTAMachine::Port {lvalue}) -> bool C++ signature:     isOutput(Port_wrapper {lvalue}) -> bool

name(...)
C++ signature:     name(TTAMachine::Port {lvalue}) -> std::string C++ signature:     name(Port_wrapper {lvalue}) -> std::string

outputSocket(...)
C++ signature:     outputSocket(TTAMachine::Port {lvalue}) -> TTAMachine::Socket* C++ signature:     outputSocket(Port_wrapper {lvalue}) -> TTAMachine::Socket*

socketCount(...)
C++ signature:     socketCount(TTAMachine::Port {lvalue}) -> int C++ signature:     socketCount(Port_wrapper {lvalue}) -> int

unconnectedSocket(...)
C++ signature:     unconnectedSocket(TTAMachine::Port {lvalue}, int index) -> TTAMachine::Socket* C++ signature:     unconnectedSocket(Port_wrapper {lvalue}, int index) -> TTAMachine::Socket*

Data descriptors inherited from Port:

OSKEY_FIRST_SOCKET

OSKEY_NAME

OSKEY_SECOND_SOCKET

OSNAME_PORT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class UniversalFunctionUnit(FunctionUnit)


Method resolution order:

UniversalFunctionUnit

FunctionUnit

Unit

Component

MachinePart

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature: __init__(_object*, std::string name, OperationPool {lvalue} opPool) -> void*

addPipelineElement(...)
C++ signature:     addPipelineElement(UniversalFunctionUnit {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void* C++ signature:     addPipelineElement(UniversalFunctionUnit_wrapper {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void*

hasOperation(...)
C++ signature:     hasOperation(UniversalFunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasOperation(UniversalFunctionUnit_wrapper {lvalue}, std::string name) -> bool

loadState(...)
C++ signature:     loadState(UniversalFunctionUnit {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(UniversalFunctionUnit_wrapper {lvalue}, ObjectState const* state) -> void*

operation(...)
C++ signature:     operation(UniversalFunctionUnit {lvalue}, std::string name) -> SmartHWOperation* C++ signature:     operation(UniversalFunctionUnit_wrapper {lvalue}, std::string name) -> SmartHWOperation*

port(...)
C++ signature: port(UniversalFunctionUnit {lvalue}, int index, int width) -> TTAMachine::FUPort

portCount(...)
C++ signature: portCount(UniversalFunctionUnit {lvalue}, int width) -> int

removePort(...)
C++ signature: removePort(UniversalFunctionUnit_wrapper {lvalue}, TTAMachine::Port {lvalue} port) -> void*

unsetMachineDerived(...)
C++ signature: unsetMachineDerived(UniversalFunctionUnit_wrapper {lvalue}) -> void*

Static methods defined here:

is32BitOperation(...)
C++ signature: is32BitOperation(std::string opName) -> bool

Data descriptors defined here:

OC_SETTING_PORT_32

OC_SETTING_PORT_64

Data and other attributes defined here:

__instance_size__ = 68

Methods inherited from FunctionUnit:

addOperation(...)
C++ signature:     addOperation(TTAMachine::FunctionUnit {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void* C++ signature:     addOperation(FunctionUnit_wrapper {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void*

addressSpace(...)
C++ signature:     addressSpace(TTAMachine::FunctionUnit {lvalue}) -> TTAMachine::AddressSpace* C++ signature:     addressSpace(FunctionUnit_wrapper {lvalue}) -> TTAMachine::AddressSpace*

cleanup(...)
C++ signature:     cleanup(TTAMachine::FunctionUnit {lvalue}, std::string resource) -> void* C++ signature:     cleanup(FunctionUnit_wrapper {lvalue}, std::string resource) -> void*

copy(...)
C++ signature:     copy(TTAMachine::FunctionUnit {lvalue}) -> TTAMachine::FunctionUnit* C++ signature:     copy(FunctionUnit_wrapper {lvalue}) -> TTAMachine::FunctionUnit*

deleteOperation(...)
C++ signature:     deleteOperation(TTAMachine::FunctionUnit {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void* C++ signature:     deleteOperation(FunctionUnit_wrapper {lvalue}, TTAMachine::HWOperation {lvalue} operation) -> void*

deletePipelineElement(...)
C++ signature:     deletePipelineElement(TTAMachine::FunctionUnit {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void* C++ signature:     deletePipelineElement(FunctionUnit_wrapper {lvalue}, TTAMachine::PipelineElement {lvalue} element) -> void*

hasAddressSpace(...)
C++ signature:     hasAddressSpace(TTAMachine::FunctionUnit {lvalue}) -> bool C++ signature:     hasAddressSpace(FunctionUnit_wrapper {lvalue}) -> bool

hasOperationPort(...)
C++ signature:     hasOperationPort(TTAMachine::FunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasOperationPort(FunctionUnit_wrapper {lvalue}, std::string name) -> bool

hasPipelineElement(...)
C++ signature:     hasPipelineElement(TTAMachine::FunctionUnit {lvalue}, std::string name) -> bool C++ signature:     hasPipelineElement(FunctionUnit_wrapper {lvalue}, std::string name) -> bool

isArchitectureEqual(...)
C++ signature:     isArchitectureEqual(TTAMachine::FunctionUnit {lvalue}, TTAMachine::FunctionUnit const* fu, bool checkPortWidths=True) -> bool C++ signature:     isArchitectureEqual(FunctionUnit_wrapper {lvalue}, TTAMachine::FunctionUnit const* fu, bool checkPortWidths=True) -> bool

maxLatency(...)
C++ signature:     maxLatency(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     maxLatency(FunctionUnit_wrapper {lvalue}) -> int

operationCount(...)
C++ signature:     operationCount(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     operationCount(FunctionUnit_wrapper {lvalue}) -> int

operationPort(...)
C++ signature:     operationPort(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::FUPort* C++ signature:     operationPort(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::FUPort* C++ signature:     operationPort(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::FUPort* C++ signature:     operationPort(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::FUPort*

operationPortCount(...)
C++ signature:     operationPortCount(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     operationPortCount(FunctionUnit_wrapper {lvalue}) -> int

pipelineElement(...)
C++ signature:     pipelineElement(TTAMachine::FunctionUnit {lvalue}, int index) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(FunctionUnit_wrapper {lvalue}, int index) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(TTAMachine::FunctionUnit {lvalue}, std::string name) -> TTAMachine::PipelineElement* C++ signature:     pipelineElement(FunctionUnit_wrapper {lvalue}, std::string name) -> TTAMachine::PipelineElement*

pipelineElementCount(...)
C++ signature:     pipelineElementCount(TTAMachine::FunctionUnit {lvalue}) -> int C++ signature:     pipelineElementCount(FunctionUnit_wrapper {lvalue}) -> int

saveState(...)
C++ signature:     saveState(TTAMachine::FunctionUnit {lvalue}) -> ObjectState* C++ signature:     saveState(FunctionUnit_wrapper {lvalue}) -> ObjectState*

setAddressSpace(...)
C++ signature:     setAddressSpace(TTAMachine::FunctionUnit {lvalue}, TTAMachine::AddressSpace* as) -> void* C++ signature:     setAddressSpace(FunctionUnit_wrapper {lvalue}, TTAMachine::AddressSpace* as) -> void*

setName(...)
C++ signature:     setName(TTAMachine::FunctionUnit {lvalue}, std::string name) -> void* C++ signature:     setName(FunctionUnit_wrapper {lvalue}, std::string name) -> void*

unsetMachine(...)
C++ signature:     unsetMachine(TTAMachine::FunctionUnit {lvalue}) -> void* C++ signature:     unsetMachine(FunctionUnit_wrapper {lvalue}) -> void*

Data descriptors inherited from FunctionUnit:

OSKEY_AS

OSNAME_FU

Methods inherited from Unit:

hasPort(...)
C++ signature:     hasPort(TTAMachine::Unit {lvalue}, std::string name) -> bool C++ signature:     hasPort(Unit_wrapper {lvalue}, std::string name) -> bool

setMachine(...)
C++ signature:     setMachine(TTAMachine::Unit {lvalue}, TTAMachine::Machine {lvalue} mach) -> void* C++ signature:     setMachine(Unit_wrapper {lvalue}, TTAMachine::Machine {lvalue} mach) -> void*

Data descriptors inherited from Unit:

OSNAME_UNIT

Methods inherited from Component:

ensureRegistration(...)
C++ signature:     ensureRegistration(TTAMachine::Component {lvalue}, TTAMachine::Component component) -> void* C++ signature:     ensureRegistration(Component_wrapper {lvalue}, TTAMachine::Component component) -> void*

isRegistered(...)
C++ signature:     isRegistered(TTAMachine::Component {lvalue}) -> bool C++ signature:     isRegistered(Component_wrapper {lvalue}) -> bool

machine(...)
C++ signature:     machine(TTAMachine::Component {lvalue}) -> TTAMachine::Machine* C++ signature:     machine(Component_wrapper {lvalue}) -> TTAMachine::Machine*

name(...)
C++ signature:     name(TTAMachine::Component {lvalue}) -> std::string C++ signature:     name(Component_wrapper {lvalue}) -> std::string

Data descriptors inherited from Component:

OSKEY_NAME

OSNAME_COMPONENT

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class UniversalMachine(Machine)


Method resolution order:

UniversalMachine

Machine

Boost.Python.instance

__builtin__.object

Methods defined here:

__init__(...)
C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*) -> void* C++ signature:     __init__(_object*, OperationPool {lvalue} arg0) -> void*

addAddressSpace(...)
C++ signature:     addAddressSpace(UniversalMachine {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void* C++ signature:     addAddressSpace(UniversalMachine_wrapper {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void*

addBridge(...)
C++ signature:     addBridge(UniversalMachine {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     addBridge(UniversalMachine_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

addBus(...)
C++ signature:     addBus(UniversalMachine {lvalue}, TTAMachine::Bus {lvalue} bus) -> void* C++ signature:     addBus(UniversalMachine_wrapper {lvalue}, TTAMachine::Bus {lvalue} bus) -> void*

addFunctionUnit(...)
C++ signature:     addFunctionUnit(UniversalMachine {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void* C++ signature:     addFunctionUnit(UniversalMachine_wrapper {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void*

addImmediateUnit(...)
C++ signature:     addImmediateUnit(UniversalMachine {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void* C++ signature:     addImmediateUnit(UniversalMachine_wrapper {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void*

addInstructionTemplate(...)
C++ signature:     addInstructionTemplate(UniversalMachine {lvalue}, TTAMachine::InstructionTemplate {lvalue} iTemp) -> void* C++ signature:     addInstructionTemplate(UniversalMachine_wrapper {lvalue}, TTAMachine::InstructionTemplate {lvalue} iTemp) -> void*

addRegisterFile(...)
C++ signature:     addRegisterFile(UniversalMachine {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void* C++ signature:     addRegisterFile(UniversalMachine_wrapper {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void*

addSocket(...)
C++ signature:     addSocket(UniversalMachine {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     addSocket(UniversalMachine_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

booleanRegisterFile(...)
C++ signature: booleanRegisterFile(UniversalMachine {lvalue}) -> TTAMachine::RegisterFile

dataAddressSpace(...)
C++ signature: dataAddressSpace(UniversalMachine {lvalue}) -> TTAMachine::AddressSpace

deleteAddressSpace(...)
C++ signature:     deleteAddressSpace(UniversalMachine {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void* C++ signature:     deleteAddressSpace(UniversalMachine_wrapper {lvalue}, TTAMachine::AddressSpace {lvalue} as) -> void*

doubleRegisterFile(...)
C++ signature: doubleRegisterFile(UniversalMachine {lvalue}) -> UnboundedRegisterFile

instructionAddressSpace(...)
C++ signature: instructionAddressSpace(UniversalMachine {lvalue}) -> TTAMachine::AddressSpace

integerRegisterFile(...)
C++ signature: integerRegisterFile(UniversalMachine {lvalue}) -> UnboundedRegisterFile

loadState(...)
C++ signature:     loadState(UniversalMachine {lvalue}, ObjectState const* state) -> void* C++ signature:     loadState(UniversalMachine_wrapper {lvalue}, ObjectState const* state) -> void*

removeBus(...)
C++ signature:     removeBus(UniversalMachine {lvalue}, TTAMachine::Bus {lvalue} bus) -> void* C++ signature:     removeBus(UniversalMachine_wrapper {lvalue}, TTAMachine::Bus {lvalue} bus) -> void*

removeFunctionUnit(...)
C++ signature:     removeFunctionUnit(UniversalMachine {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void* C++ signature:     removeFunctionUnit(UniversalMachine_wrapper {lvalue}, TTAMachine::FunctionUnit {lvalue} unit) -> void*

removeRegisterFile(...)
C++ signature:     removeRegisterFile(UniversalMachine {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void* C++ signature:     removeRegisterFile(UniversalMachine_wrapper {lvalue}, TTAMachine::RegisterFile {lvalue} unit) -> void*

removeSocket(...)
C++ signature:     removeSocket(UniversalMachine {lvalue}, TTAMachine::Socket {lvalue} socket) -> void* C++ signature:     removeSocket(UniversalMachine_wrapper {lvalue}, TTAMachine::Socket {lvalue} socket) -> void*

setGlobalControl(...)
C++ signature:     setGlobalControl(UniversalMachine {lvalue}, TTAMachine::ControlUnit {lvalue} unit) -> void* C++ signature:     setGlobalControl(UniversalMachine_wrapper {lvalue}, TTAMachine::ControlUnit {lvalue} unit) -> void*

specialRegisterFile(...)
C++ signature: specialRegisterFile(UniversalMachine {lvalue}) -> TTAMachine::RegisterFile

universalBus(...)
C++ signature: universalBus(UniversalMachine {lvalue}) -> TTAMachine::Bus

universalFunctionUnit(...)
C++ signature: universalFunctionUnit(UniversalMachine {lvalue}) -> UniversalFunctionUnit

unsetGlobalControl(...)
C++ signature:     unsetGlobalControl(UniversalMachine {lvalue}) -> void* C++ signature:     unsetGlobalControl(UniversalMachine_wrapper {lvalue}) -> void*

Data and other attributes defined here:

__instance_size__ = 192

Methods inherited from Machine:

addImmediateSlot(...)
C++ signature:     addImmediateSlot(TTAMachine::Machine {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void* C++ signature:     addImmediateSlot(Machine_wrapper {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void*

addUnit(...)
C++ signature: addUnit(TTAMachine::Machine {lvalue}, TTAMachine::Unit {lvalue} unit) -> void*

addressSpaceNavigator(...)
C++ signature:     addressSpaceNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::AddressSpace> C++ signature:     addressSpaceNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::AddressSpace>

bridgeNavigator(...)
C++ signature:     bridgeNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bridge> C++ signature:     bridgeNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bridge>

busNavigator(...)
C++ signature:     busNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bus> C++ signature:     busNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Bus>

controlUnit(...)
C++ signature:     controlUnit(TTAMachine::Machine {lvalue}) -> TTAMachine::ControlUnit* C++ signature:     controlUnit(Machine_wrapper {lvalue}) -> TTAMachine::ControlUnit*

deleteBridge(...)
C++ signature:     deleteBridge(TTAMachine::Machine {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void* C++ signature:     deleteBridge(Machine_wrapper {lvalue}, TTAMachine::Bridge {lvalue} bridge) -> void*

deleteImmediateSlot(...)
C++ signature:     deleteImmediateSlot(TTAMachine::Machine {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void* C++ signature:     deleteImmediateSlot(Machine_wrapper {lvalue}, TTAMachine::ImmediateSlot {lvalue} slot) -> void*

deleteInstructionTemplate(...)
C++ signature:     deleteInstructionTemplate(TTAMachine::Machine {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void* C++ signature:     deleteInstructionTemplate(Machine_wrapper {lvalue}, TTAMachine::InstructionTemplate {lvalue} instrTempl) -> void*

functionUnitNavigator(...)
C++ signature:     functionUnitNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::FunctionUnit> C++ signature:     functionUnitNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::FunctionUnit>

immediateSlotNavigator(...)
C++ signature:     immediateSlotNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateSlot> C++ signature:     immediateSlotNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateSlot>

immediateUnitNavigator(...)
C++ signature:     immediateUnitNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateUnit> C++ signature:     immediateUnitNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::ImmediateUnit>

instructionTemplateNavigator(...)
C++ signature:     instructionTemplateNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::InstructionTemplate> C++ signature:     instructionTemplateNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::InstructionTemplate>

machineTester(...)
C++ signature: machineTester(TTAMachine::Machine {lvalue}) -> MachineTester

registerFileNavigator(...)
C++ signature:     registerFileNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::RegisterFile> C++ signature:     registerFileNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::RegisterFile>

removeImmediateUnit(...)
C++ signature:     removeImmediateUnit(TTAMachine::Machine {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void* C++ signature:     removeImmediateUnit(Machine_wrapper {lvalue}, TTAMachine::ImmediateUnit {lvalue} unit) -> void*

removeUnit(...)
C++ signature:     removeUnit(TTAMachine::Machine {lvalue}, TTAMachine::Unit {lvalue} unit) -> void* C++ signature:     removeUnit(Machine_wrapper {lvalue}, TTAMachine::Unit {lvalue} unit) -> void*

saveState(...)
C++ signature:     saveState(TTAMachine::Machine {lvalue}) -> ObjectState* C++ signature:     saveState(Machine_wrapper {lvalue}) -> ObjectState*

setBusPosition(...)
C++ signature: setBusPosition(TTAMachine::Machine {lvalue}, TTAMachine::Bus bus, int newPosition) -> void*

socketNavigator(...)
C++ signature:     socketNavigator(TTAMachine::Machine {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Socket> C++ signature:     socketNavigator(Machine_wrapper {lvalue}) -> TTAMachine::Machine::Navigator<TTAMachine::Socket>

Static methods inherited from Machine:

loadFromADF(...)
C++ signature: loadFromADF(std::string adfFileName) -> TTAMachine::Machine*

Data descriptors inherited from Machine:

OSNAME_MACHINE

Data and other attributes inherited from Machine:

Extension = <class 'TCE.base.TCE.base.mach.Extension'>

SIGN = TCE.base.mach.Extension.SIGN

ZERO = TCE.base.mach.Extension.ZERO

Data descriptors inherited from Boost.Python.instance:

__dict__

__weakref__

Data and other attributes inherited from Boost.Python.instance:

__new__ = <built-in method __new__ of Boost.Python.class object at 0x40c1a320>
T.__new__(S, ...) -> a new object with type S, a subtype of T