class AbsoluteForceSensorService :
    _NP_RepositoryId = _0_OpenHRP._d_AbsoluteForceSensorService[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    
    # typedef ... DblSequence3
    class DblSequence3:
        _NP_RepositoryId = "IDL:OpenHRP/AbsoluteForceSensorService/DblSequence3:1.0"
        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")
    _d_DblSequence3  = (omniORB.tcInternal.tv_sequence, omniORB.tcInternal.tv_double, 3)
    _ad_DblSequence3 = (omniORB.tcInternal.tv_alias, DblSequence3._NP_RepositoryId, "DblSequence3", (omniORB.tcInternal.tv_sequence, omniORB.tcInternal.tv_double, 3))
    _tc_DblSequence3 = omniORB.tcInternal.createTypeCode(_ad_DblSequence3)
    omniORB.registerType(DblSequence3._NP_RepositoryId, _ad_DblSequence3, _tc_DblSequence3)
    
    # struct forcemomentOffsetParam
    _0_OpenHRP.AbsoluteForceSensorService.forcemomentOffsetParam = omniORB.newEmptyClass()
    class forcemomentOffsetParam (omniORB.StructBase):
        _NP_RepositoryId = "IDL:OpenHRP/AbsoluteForceSensorService/forcemomentOffsetParam:1.0"

        _NP_ClassName = "OpenHRP.AbsoluteForceSensorService.forcemomentOffsetParam"

        def __init__(self, force_offset, moment_offset, link_offset_centroid, link_offset_mass):
            self.force_offset = force_offset
            self.moment_offset = moment_offset
            self.link_offset_centroid = link_offset_centroid
            self.link_offset_mass = link_offset_mass
    
    _d_forcemomentOffsetParam  = _0_OpenHRP.AbsoluteForceSensorService._d_forcemomentOffsetParam = (omniORB.tcInternal.tv_struct, forcemomentOffsetParam, forcemomentOffsetParam._NP_RepositoryId, "forcemomentOffsetParam", "force_offset", omniORB.typeMapping["IDL:OpenHRP/AbsoluteForceSensorService/DblSequence3:1.0"], "moment_offset", omniORB.typeMapping["IDL:OpenHRP/AbsoluteForceSensorService/DblSequence3:1.0"], "link_offset_centroid", omniORB.typeMapping["IDL:OpenHRP/AbsoluteForceSensorService/DblSequence3:1.0"], "link_offset_mass", omniORB.tcInternal.tv_double)
    _tc_forcemomentOffsetParam = omniORB.tcInternal.createTypeCode(_d_forcemomentOffsetParam)
    omniORB.registerType(forcemomentOffsetParam._NP_RepositoryId, _d_forcemomentOffsetParam, _tc_forcemomentOffsetParam)
Esempio n. 2
0
class TraversalCriteria :
    _NP_RepositoryId = _0_CosGraphs._d_TraversalCriteria[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    
    # struct WeightedEdge
    _0_CosGraphs.TraversalCriteria.WeightedEdge = omniORB.newEmptyClass()
    class WeightedEdge (omniORB.StructBase):
        _NP_RepositoryId = "IDL:omg.org/CosGraphs/TraversalCriteria/WeightedEdge:1.0"

        _NP_ClassName = "CosGraphs.TraversalCriteria.WeightedEdge"

        def __init__(self, the_edge, weight, next_nodes):
            self.the_edge = the_edge
            self.weight = weight
            self.next_nodes = next_nodes
    
    _d_WeightedEdge  = _0_CosGraphs.TraversalCriteria._d_WeightedEdge = (omniORB.tcInternal.tv_struct, WeightedEdge, WeightedEdge._NP_RepositoryId, "WeightedEdge", "the_edge", omniORB.typeMapping["IDL:omg.org/CosGraphs/Edge:1.0"], "weight", omniORB.tcInternal.tv_ulong, "next_nodes", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:omg.org/CosGraphs/NodeHandle:1.0"], 0))
    _tc_WeightedEdge = omniORB.tcInternal.createTypeCode(_d_WeightedEdge)
    omniORB.registerType(WeightedEdge._NP_RepositoryId, _d_WeightedEdge, _tc_WeightedEdge)
    
    # typedef ... WeightedEdges
    class WeightedEdges:
        _NP_RepositoryId = "IDL:omg.org/CosGraphs/TraversalCriteria/WeightedEdges:1.0"
        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")
    _d_WeightedEdges  = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:omg.org/CosGraphs/TraversalCriteria/WeightedEdge:1.0"], 0)
    _ad_WeightedEdges = (omniORB.tcInternal.tv_alias, WeightedEdges._NP_RepositoryId, "WeightedEdges", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:omg.org/CosGraphs/TraversalCriteria/WeightedEdge:1.0"], 0))
    _tc_WeightedEdges = omniORB.tcInternal.createTypeCode(_ad_WeightedEdges)
    omniORB.registerType(WeightedEdges._NP_RepositoryId, _ad_WeightedEdges, _tc_WeightedEdges)
Esempio n. 3
0
class Node(_0_CosObjectIdentity.IdentifiableObject):
    _NP_RepositoryId = _0_CosGraphs._d_Node[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # typedef ... Roles
    class Roles:
        _NP_RepositoryId = "IDL:omg.org/CosGraphs/Node/Roles:1.0"

        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")

    _d_Roles = (omniORB.tcInternal.tv_sequence,
                omniORB.typeMapping["IDL:omg.org/CosGraphs/Role:1.0"], 0)
    _ad_Roles = (omniORB.tcInternal.tv_alias, Roles._NP_RepositoryId, "Roles",
                 (omniORB.tcInternal.tv_sequence,
                  omniORB.typeMapping["IDL:omg.org/CosGraphs/Role:1.0"], 0))
    _tc_Roles = omniORB.tcInternal.createTypeCode(_ad_Roles)
    omniORB.registerType(Roles._NP_RepositoryId, _ad_Roles, _tc_Roles)

    # exception NoSuchRole
    _0_CosGraphs.Node.NoSuchRole = omniORB.newEmptyClass()

    class NoSuchRole(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosGraphs/Node/NoSuchRole:1.0"

        _NP_ClassName = "CosGraphs.Node.NoSuchRole"

        def __init__(self):
            CORBA.UserException.__init__(self)

    _d_NoSuchRole = (omniORB.tcInternal.tv_except, NoSuchRole,
                     NoSuchRole._NP_RepositoryId, "NoSuchRole")
    _tc_NoSuchRole = omniORB.tcInternal.createTypeCode(_d_NoSuchRole)
    omniORB.registerType(NoSuchRole._NP_RepositoryId, _d_NoSuchRole,
                         _tc_NoSuchRole)

    # exception DuplicateRoleType
    _0_CosGraphs.Node.DuplicateRoleType = omniORB.newEmptyClass()

    class DuplicateRoleType(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosGraphs/Node/DuplicateRoleType:1.0"

        _NP_ClassName = "CosGraphs.Node.DuplicateRoleType"

        def __init__(self):
            CORBA.UserException.__init__(self)

    _d_DuplicateRoleType = (omniORB.tcInternal.tv_except, DuplicateRoleType,
                            DuplicateRoleType._NP_RepositoryId,
                            "DuplicateRoleType")
    _tc_DuplicateRoleType = omniORB.tcInternal.createTypeCode(
        _d_DuplicateRoleType)
    omniORB.registerType(DuplicateRoleType._NP_RepositoryId,
                         _d_DuplicateRoleType, _tc_DuplicateRoleType)
Esempio n. 4
0
class SubjectManager :
    _NP_RepositoryId = _0_tweek._d_SubjectManager[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    
    # struct RegisteredSubject
    _0_tweek.SubjectManager.RegisteredSubject = omniORB.newEmptyClass()
    class RegisteredSubject:
        _NP_RepositoryId = "IDL:tweek/SubjectManager/RegisteredSubject:1.0"

        def __init__(self, subject_name, subject_ref):
            self.subject_name = subject_name
            self.subject_ref = subject_ref
    
    _d_RegisteredSubject  = _0_tweek.SubjectManager._d_RegisteredSubject = (omniORB.tcInternal.tv_struct, RegisteredSubject, RegisteredSubject._NP_RepositoryId, "RegisteredSubject", "subject_name", (omniORB.tcInternal.tv_string,0), "subject_ref", omniORB.typeMapping["IDL:tweek/Subject:1.0"])
    _tc_RegisteredSubject = omniORB.tcInternal.createTypeCode(_d_RegisteredSubject)
    omniORB.registerType(RegisteredSubject._NP_RepositoryId, _d_RegisteredSubject, _tc_RegisteredSubject)
    
    # struct SubjectMgrInfoItem
    _0_tweek.SubjectManager.SubjectMgrInfoItem = omniORB.newEmptyClass()
    class SubjectMgrInfoItem:
        _NP_RepositoryId = "IDL:tweek/SubjectManager/SubjectMgrInfoItem:1.0"

        def __init__(self, key, value):
            self.key = key
            self.value = value
    
    _d_SubjectMgrInfoItem  = _0_tweek.SubjectManager._d_SubjectMgrInfoItem = (omniORB.tcInternal.tv_struct, SubjectMgrInfoItem, SubjectMgrInfoItem._NP_RepositoryId, "SubjectMgrInfoItem", "key", (omniORB.tcInternal.tv_string,0), "value", (omniORB.tcInternal.tv_string,0))
    _tc_SubjectMgrInfoItem = omniORB.tcInternal.createTypeCode(_d_SubjectMgrInfoItem)
    omniORB.registerType(SubjectMgrInfoItem._NP_RepositoryId, _d_SubjectMgrInfoItem, _tc_SubjectMgrInfoItem)
    
    # typedef ... SubjectList
    class SubjectList:
        _NP_RepositoryId = "IDL:tweek/SubjectManager/SubjectList:1.0"
        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")
    _d_SubjectList  = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:tweek/SubjectManager/RegisteredSubject:1.0"], 0)
    _ad_SubjectList = (omniORB.tcInternal.tv_alias, SubjectList._NP_RepositoryId, "SubjectList", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:tweek/SubjectManager/RegisteredSubject:1.0"], 0))
    _tc_SubjectList = omniORB.tcInternal.createTypeCode(_ad_SubjectList)
    omniORB.registerType(SubjectList._NP_RepositoryId, _ad_SubjectList, _tc_SubjectList)
    
    # typedef ... SubjectManagerInfoList
    class SubjectManagerInfoList:
        _NP_RepositoryId = "IDL:tweek/SubjectManager/SubjectManagerInfoList:1.0"
        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")
    _d_SubjectManagerInfoList  = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:tweek/SubjectManager/SubjectMgrInfoItem:1.0"], 0)
    _ad_SubjectManagerInfoList = (omniORB.tcInternal.tv_alias, SubjectManagerInfoList._NP_RepositoryId, "SubjectManagerInfoList", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:tweek/SubjectManager/SubjectMgrInfoItem:1.0"], 0))
    _tc_SubjectManagerInfoList = omniORB.tcInternal.createTypeCode(_ad_SubjectManagerInfoList)
    omniORB.registerType(SubjectManagerInfoList._NP_RepositoryId, _ad_SubjectManagerInfoList, _tc_SubjectManagerInfoList)
Esempio n. 5
0
class POAManager (CORBA.Object) :
    _NP_RepositoryId = "IDL:omg.org/PortableServer/POAManager:1.0"

    def __init__(self):
        self.__release = _omnipy.poamanager_func.releaseRef

    def __del__(self):
        self.__release(self)

    def activate(self):
        _omnipy.poamanager_func.activate(self)

    def hold_requests(self, wait_for_completion):
        _omnipy.poamanager_func.hold_requests(self, wait_for_completion)
    
    def discard_requests(self, wait_for_completion):
        _omnipy.poamanager_func.discard_requests(self, wait_for_completion)
    
    def deactivate(self, etherialize_objects, wait_for_completion):
        _omnipy.poamanager_func.deactivate(self, etherialize_objects,
                                           wait_for_completion)

    def get_state(self):
        return self.State._item(_omnipy.poamanager_func.get_state(self))

    __methods__ = ["activate", "hold_requests", "discard_requests",
                   "deactivate", "get_state"] + CORBA.Object.__methods__

    # Generated declarations

    class AdapterInactive (CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/PortableServer/POAManager/AdapterInactive:1.0"

    _d_AdapterInactive  = (omniORB.tcInternal.tv_except, AdapterInactive,
                           AdapterInactive._NP_RepositoryId, "AdapterInactive")
    _tc_AdapterInactive = omniORB.tcInternal.createTypeCode(_d_AdapterInactive)
    omniORB.registerType(AdapterInactive._NP_RepositoryId,
                         _d_AdapterInactive, _tc_AdapterInactive)
    
    HOLDING    = omniORB.EnumItem("HOLDING", 0)
    ACTIVE     = omniORB.EnumItem("ACTIVE", 1)
    DISCARDING = omniORB.EnumItem("DISCARDING", 2)
    INACTIVE   = omniORB.EnumItem("INACTIVE", 3)
    State = omniORB.Enum("IDL:omg.org/PortableServer/POAManager/State:1.0",
                         (HOLDING, ACTIVE, DISCARDING, INACTIVE))
    
    _d_State  = (omniORB.tcInternal.tv_enum, State._NP_RepositoryId,
                 "State", State._items)
    _tc_State = omniORB.tcInternal.createTypeCode(_d_State)
    omniORB.registerType(State._NP_RepositoryId, _d_State, _tc_State)
Esempio n. 6
0
class RobotViewer:
    _NP_RepositoryId = _0_robotviewer_corba._d_RobotViewer[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # exception InvalidKey
    _0_robotviewer_corba.RobotViewer.InvalidKey = omniORB.newEmptyClass()

    class InvalidKey(CORBA.UserException):
        _NP_RepositoryId = "IDL:robotviewer_corba/RobotViewer/InvalidKey:1.0"

        _NP_ClassName = "robotviewer_corba.RobotViewer.InvalidKey"

        def __init__(self, reason):
            CORBA.UserException.__init__(self, reason)
            self.reason = reason

    _d_InvalidKey = (omniORB.tcInternal.tv_except, InvalidKey,
                     InvalidKey._NP_RepositoryId, "InvalidKey", "reason",
                     (omniORB.tcInternal.tv_string, 0))
    _tc_InvalidKey = omniORB.tcInternal.createTypeCode(_d_InvalidKey)
    omniORB.registerType(InvalidKey._NP_RepositoryId, _d_InvalidKey,
                         _tc_InvalidKey)
Esempio n. 7
0
class GetInfoProcess:
    _NP_RepositoryId = _0__GlobalIDL._d_GetInfoProcess[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # typedef ... Matrix4_4
    class Matrix4_4:
        _NP_RepositoryId = "IDL:GetInfoProcess/Matrix4_4:1.0"

        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")

    _d_Matrix4_4 = (omniORB.tcInternal.tv_array,
                    (omniORB.tcInternal.tv_array, omniORB.tcInternal.tv_double,
                     4), 4)
    _ad_Matrix4_4 = (omniORB.tcInternal.tv_alias, Matrix4_4._NP_RepositoryId,
                     "Matrix4_4", (omniORB.tcInternal.tv_array,
                                   (omniORB.tcInternal.tv_array,
                                    omniORB.tcInternal.tv_double, 4), 4))
    _tc_Matrix4_4 = omniORB.tcInternal.createTypeCode(_ad_Matrix4_4)
    omniORB.registerType(Matrix4_4._NP_RepositoryId, _ad_Matrix4_4,
                         _tc_Matrix4_4)
class Relationship(_0_CosObjectIdentity.IdentifiableObject):
    _NP_RepositoryId = _0_CosRelationships._d_Relationship[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # exception CannotUnlink
    _0_CosRelationships.Relationship.CannotUnlink = omniORB.newEmptyClass()

    class CannotUnlink(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosRelationships/Relationship/CannotUnlink:1.0"

        _NP_ClassName = "CosRelationships.Relationship.CannotUnlink"

        def __init__(self, offending_roles):
            CORBA.UserException.__init__(self, offending_roles)
            self.offending_roles = offending_roles

    _d_CannotUnlink = (
        omniORB.tcInternal.tv_except, CannotUnlink,
        CannotUnlink._NP_RepositoryId, "CannotUnlink", "offending_roles",
        omniORB.typeMapping["IDL:omg.org/CosRelationships/Roles:1.0"])
    _tc_CannotUnlink = omniORB.tcInternal.createTypeCode(_d_CannotUnlink)
    omniORB.registerType(CannotUnlink._NP_RepositoryId, _d_CannotUnlink,
                         _tc_CannotUnlink)
Esempio n. 9
0
class CommandInjectMngr:
    _NP_RepositoryId = _0_ITC_INJ._d_CommandInjectMngr[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # exception InjectionFailed
    _0_ITC_INJ.CommandInjectMngr.InjectionFailed = omniORB.newEmptyClass()

    class InjectionFailed(CORBA.UserException):
        _NP_RepositoryId = "IDL:ITC_INJ/CommandInjectMngr/InjectionFailed:1.0"

        _NP_ClassName = "ITC_INJ.CommandInjectMngr.InjectionFailed"

        def __init__(self, reason):
            CORBA.UserException.__init__(self, reason)
            self.reason = reason

    _d_InjectionFailed = (omniORB.tcInternal.tv_except, InjectionFailed,
                          InjectionFailed._NP_RepositoryId, "InjectionFailed",
                          "reason", (omniORB.tcInternal.tv_string, 0))
    _tc_InjectionFailed = omniORB.tcInternal.createTypeCode(_d_InjectionFailed)
    omniORB.registerType(InjectionFailed._NP_RepositoryId, _d_InjectionFailed,
                         _tc_InjectionFailed)
class Node(_0_CosGraphs.Node):
    _NP_RepositoryId = _0_CosCompoundLifeCycle._d_Node[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # exception NotLifeCycleObject
    _0_CosCompoundLifeCycle.Node.NotLifeCycleObject = omniORB.newEmptyClass()

    class NotLifeCycleObject(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosCompoundLifeCycle/Node/NotLifeCycleObject:1.0"

        _NP_ClassName = "CosCompoundLifeCycle.Node.NotLifeCycleObject"

        def __init__(self):
            CORBA.UserException.__init__(self)

    _d_NotLifeCycleObject = (omniORB.tcInternal.tv_except, NotLifeCycleObject,
                             NotLifeCycleObject._NP_RepositoryId,
                             "NotLifeCycleObject")
    _tc_NotLifeCycleObject = omniORB.tcInternal.createTypeCode(
        _d_NotLifeCycleObject)
    omniORB.registerType(NotLifeCycleObject._NP_RepositoryId,
                         _d_NotLifeCycleObject, _tc_NotLifeCycleObject)
Esempio n. 11
0
class TCinjectServerMngr:
    _NP_RepositoryId = _0_ITC_INJ._d_TCinjectServerMngr[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    ServiceName = "TC_INJ_002"

    # exception RegistrationFailed
    _0_ITC_INJ.TCinjectServerMngr.RegistrationFailed = omniORB.newEmptyClass()

    class RegistrationFailed(CORBA.UserException):
        _NP_RepositoryId = "IDL:ITC_INJ/TCinjectServerMngr/RegistrationFailed:1.0"

        _NP_ClassName = "ITC_INJ.TCinjectServerMngr.RegistrationFailed"

        def __init__(self, reason):
            CORBA.UserException.__init__(self, reason)
            self.reason = reason

    _d_RegistrationFailed = (omniORB.tcInternal.tv_except, RegistrationFailed,
                             RegistrationFailed._NP_RepositoryId,
                             "RegistrationFailed", "reason",
                             (omniORB.tcInternal.tv_string, 0))
    _tc_RegistrationFailed = omniORB.tcInternal.createTypeCode(
        _d_RegistrationFailed)
    omniORB.registerType(RegistrationFailed._NP_RepositoryId,
                         _d_RegistrationFailed, _tc_RegistrationFailed)
Esempio n. 12
0
class CommonCommands:
    _NP_RepositoryId = _0__GlobalIDL._d_CommonCommands[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # struct RETURN_ID
    _0__GlobalIDL.CommonCommands.RETURN_ID = omniORB.newEmptyClass()

    class RETURN_ID(omniORB.StructBase):
        _NP_RepositoryId = "IDL:CommonCommands/RETURN_ID:1.0"

        _NP_ClassName = "_GlobalIDL.CommonCommands.RETURN_ID"

        def __init__(self, id, comment):
            self.id = id
            self.comment = comment

    _d_RETURN_ID = _0__GlobalIDL.CommonCommands._d_RETURN_ID = (
        omniORB.tcInternal.tv_struct, RETURN_ID, RETURN_ID._NP_RepositoryId,
        "RETURN_ID", "id", omniORB.tcInternal.tv_long, "comment",
        (omniORB.tcInternal.tv_string, 0))
    _tc_RETURN_ID = omniORB.tcInternal.createTypeCode(_d_RETURN_ID)
    omniORB.registerType(RETURN_ID._NP_RepositoryId, _d_RETURN_ID,
                         _tc_RETURN_ID)
Esempio n. 13
0
class Current (CORBA.Object) :
    _NP_RepositoryId = "IDL:omg.org/PortableServer/Current:1.0"

    def __init__(self):
        self.__release = _omnipy.poacurrent_func.releaseRef

    def __del__(self):
        self.__release(self)

    def get_POA(self):
        return _omnipy.poacurrent_func.get_POA(self)

    def get_object_id(self):
        return _omnipy.poacurrent_func.get_object_id(self)

    def get_reference(self):
        return _omnipy.poacurrent_func.get_reference(self)

    def get_servant(self):
        return _omnipy.poacurrent_func.get_servant(self)

    __methods__ = ["get_POA", "get_object_id",
                   "get_reference", "get_servant"] + CORBA.Object.__methods__

    # Generated declarations

    class NoContext (CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/PortableServer/Current/NoContext:1.0"

    _d_NoContext  = (omniORB.tcInternal.tv_except, NoContext,
                     NoContext._NP_RepositoryId, "NoContext")
    _tc_NoContext = omniORB.tcInternal.createTypeCode(_d_NoContext)
    omniORB.registerType(NoContext._NP_RepositoryId,
                         _d_NoContext, _tc_NoContext)
Esempio n. 14
0
class Current(CORBA.Object):
    _NP_RepositoryId = "IDL:omg.org/PortableServer/Current:1.0"

    def __init__(self, pc):
        CORBA.Object.__init__(self, pc)

    def get_POA(self):
        return self._obj.get_POA()

    def get_object_id(self):
        return self._obj.get_object_id()

    def get_reference(self):
        return self._obj.get_reference()

    def get_servant(self):
        return self._obj.get_servant()

    # Generated declarations

    class NoContext(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/PortableServer/Current/NoContext:1.0"

    _d_NoContext = (omniORB.tcInternal.tv_except, NoContext,
                    NoContext._NP_RepositoryId, "NoContext")
    _tc_NoContext = omniORB.tcInternal.createTypeCode(_d_NoContext)
    omniORB.registerType(NoContext._NP_RepositoryId, _d_NoContext,
                         _tc_NoContext)
Esempio n. 15
0
class RoleFactory :
    _NP_RepositoryId = _0_CosRelationships._d_RoleFactory[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    
    # exception NilRelatedObject
    _0_CosRelationships.RoleFactory.NilRelatedObject = omniORB.newEmptyClass()
    class NilRelatedObject (CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosRelationships/RoleFactory/NilRelatedObject:1.0"

        _NP_ClassName = "CosRelationships.RoleFactory.NilRelatedObject"

        def __init__(self):
            CORBA.UserException.__init__(self)
    
    _d_NilRelatedObject  = (omniORB.tcInternal.tv_except, NilRelatedObject, NilRelatedObject._NP_RepositoryId, "NilRelatedObject")
    _tc_NilRelatedObject = omniORB.tcInternal.createTypeCode(_d_NilRelatedObject)
    omniORB.registerType(NilRelatedObject._NP_RepositoryId, _d_NilRelatedObject, _tc_NilRelatedObject)
    
    # exception RelatedObjectTypeError
    _0_CosRelationships.RoleFactory.RelatedObjectTypeError = omniORB.newEmptyClass()
    class RelatedObjectTypeError (CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosRelationships/RoleFactory/RelatedObjectTypeError:1.0"

        _NP_ClassName = "CosRelationships.RoleFactory.RelatedObjectTypeError"

        def __init__(self):
            CORBA.UserException.__init__(self)
    
    _d_RelatedObjectTypeError  = (omniORB.tcInternal.tv_except, RelatedObjectTypeError, RelatedObjectTypeError._NP_RepositoryId, "RelatedObjectTypeError")
    _tc_RelatedObjectTypeError = omniORB.tcInternal.createTypeCode(_d_RelatedObjectTypeError)
    omniORB.registerType(RelatedObjectTypeError._NP_RepositoryId, _d_RelatedObjectTypeError, _tc_RelatedObjectTypeError)
    
    # typedef ... InterfaceDefs
    class InterfaceDefs:
        _NP_RepositoryId = "IDL:omg.org/CosRelationships/RoleFactory/InterfaceDefs:1.0"
        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")
    _d_InterfaceDefs  = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:omg.org/CORBA/InterfaceDef:1.0"], 0)
    _ad_InterfaceDefs = (omniORB.tcInternal.tv_alias, InterfaceDefs._NP_RepositoryId, "InterfaceDefs", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:omg.org/CORBA/InterfaceDef:1.0"], 0))
    _tc_InterfaceDefs = omniORB.tcInternal.createTypeCode(_ad_InterfaceDefs)
    omniORB.registerType(InterfaceDefs._NP_RepositoryId, _ad_InterfaceDefs, _tc_InterfaceDefs)
Esempio n. 16
0
class PollableSet:
    _NP_RepositoryId = _0_CORBA._d_PollableSet[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # exception NoPossiblePollable
    _0_CORBA.PollableSet.NoPossiblePollable = omniORB.newEmptyClass()

    class NoPossiblePollable(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CORBA/PollableSet/NoPossiblePollable:1.0"

        _NP_ClassName = "CORBA.PollableSet.NoPossiblePollable"

        def __init__(self):
            CORBA.UserException.__init__(self)

    _d_NoPossiblePollable = (omniORB.tcInternal.tv_except, NoPossiblePollable,
                             NoPossiblePollable._NP_RepositoryId,
                             "NoPossiblePollable")
    _tc_NoPossiblePollable = omniORB.tcInternal.createTypeCode(
        _d_NoPossiblePollable)
    omniORB.registerType(NoPossiblePollable._NP_RepositoryId,
                         _d_NoPossiblePollable, _tc_NoPossiblePollable)

    # exception UnknownPollable
    _0_CORBA.PollableSet.UnknownPollable = omniORB.newEmptyClass()

    class UnknownPollable(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CORBA/PollableSet/UnknownPollable:1.0"

        _NP_ClassName = "CORBA.PollableSet.UnknownPollable"

        def __init__(self):
            CORBA.UserException.__init__(self)

    _d_UnknownPollable = (omniORB.tcInternal.tv_except, UnknownPollable,
                          UnknownPollable._NP_RepositoryId, "UnknownPollable")
    _tc_UnknownPollable = omniORB.tcInternal.createTypeCode(_d_UnknownPollable)
    omniORB.registerType(UnknownPollable._NP_RepositoryId, _d_UnknownPollable,
                         _tc_UnknownPollable)
Esempio n. 17
0
class POAManager(CORBA.Object):
    _NP_RepositoryId = "IDL:omg.org/PortableServer/POAManager:2.4"

    def __init__(self, pm):
        CORBA.Object.__init__(self, pm)

    def activate(self):
        self._obj.activate()

    def hold_requests(self, wait_for_completion):
        self._obj.hold_requests(wait_for_completion)

    def discard_requests(self, wait_for_completion):
        self._obj.discard_requests(wait_for_completion)

    def deactivate(self, etherialize_objects, wait_for_completion):
        self._obj.deactivate(etherialize_objects, wait_for_completion)

    def get_state(self):
        return self.State._item(self._obj.get_state())

    # Generated declarations

    class AdapterInactive(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/PortableServer/POAManager/AdapterInactive:2.4"

    _d_AdapterInactive = (omniORB.tcInternal.tv_except, AdapterInactive,
                          AdapterInactive._NP_RepositoryId, "AdapterInactive")
    _tc_AdapterInactive = omniORB.tcInternal.createTypeCode(_d_AdapterInactive)
    omniORB.registerType(AdapterInactive._NP_RepositoryId, _d_AdapterInactive,
                         _tc_AdapterInactive)

    HOLDING = omniORB.EnumItem("HOLDING", 0)
    ACTIVE = omniORB.EnumItem("ACTIVE", 1)
    DISCARDING = omniORB.EnumItem("DISCARDING", 2)
    INACTIVE = omniORB.EnumItem("INACTIVE", 3)
    State = omniORB.Enum("IDL:omg.org/PortableServer/POAManager/State:2.4",
                         (HOLDING, ACTIVE, DISCARDING, INACTIVE))

    _d_State = (omniORB.tcInternal.tv_enum, State._NP_RepositoryId, "State",
                State._items)
    _tc_State = omniORB.tcInternal.createTypeCode(_d_State)
    omniORB.registerType(State._NP_RepositoryId, _d_State, _tc_State)
Esempio n. 18
0
class QueryEvaluator :
    _NP_RepositoryId = _0_CosQuery._d_QueryEvaluator[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    
    # typedef ... QLTypes
    class QLTypes:
        _NP_RepositoryId = "IDL:omg.org/CosQuery/QueryEvaluator/QLTypes:1.0"
        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")
    _d_QLTypes  = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:omg.org/CosQuery/QLType:1.0"], 0)
    _ad_QLTypes = (omniORB.tcInternal.tv_alias, QLTypes._NP_RepositoryId, "QLTypes", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:omg.org/CosQuery/QLType:1.0"], 0))
    _tc_QLTypes = omniORB.tcInternal.createTypeCode(_ad_QLTypes)
    omniORB.registerType(QLTypes._NP_RepositoryId, _ad_QLTypes, _tc_QLTypes)
Esempio n. 19
0
class EventInjectMngr :
    _NP_RepositoryId = _0_IEV_INJ._d_EventInjectMngr[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    ServiceName = "EV_INJ_001"
    
    # exception BadEvent
    _0_IEV_INJ.EventInjectMngr.BadEvent = omniORB.newEmptyClass()
    class BadEvent (CORBA.UserException):
        _NP_RepositoryId = "IDL:IEV_INJ/EventInjectMngr/BadEvent:1.0"

        _NP_ClassName = "IEV_INJ.EventInjectMngr.BadEvent"

        def __init__(self):
            CORBA.UserException.__init__(self)
    
    _d_BadEvent  = (omniORB.tcInternal.tv_except, BadEvent, BadEvent._NP_RepositoryId, "BadEvent")
    _tc_BadEvent = omniORB.tcInternal.createTypeCode(_d_BadEvent)
    omniORB.registerType(BadEvent._NP_RepositoryId, _d_BadEvent, _tc_BadEvent)
Esempio n. 20
0
class ComImProcess:
    _NP_RepositoryId = _0__GlobalIDL._d_ComImProcess[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # typedef ... MultiImage
    class MultiImage:
        _NP_RepositoryId = "IDL:ComImProcess/MultiImage:1.0"

        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")

    _d_MultiImage = (omniORB.tcInternal.tv_array,
                     omniORB.typeMapping["IDL:RTC/CameraImage:1.0"], 4)
    _ad_MultiImage = (omniORB.tcInternal.tv_alias, MultiImage._NP_RepositoryId,
                      "MultiImage",
                      (omniORB.tcInternal.tv_array,
                       omniORB.typeMapping["IDL:RTC/CameraImage:1.0"], 4))
    _tc_MultiImage = omniORB.tcInternal.createTypeCode(_ad_MultiImage)
    omniORB.registerType(MultiImage._NP_RepositoryId, _ad_MultiImage,
                         _tc_MultiImage)
Esempio n. 21
0
class CameraControlProcess:
    _NP_RepositoryId = _0__GlobalIDL._d_CameraControlProcess[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # typedef ... CameraSetting
    class CameraSetting:
        _NP_RepositoryId = "IDL:CameraControlProcess/CameraSetting:1.0"

        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")

    _d_CameraSetting = (omniORB.tcInternal.tv_array,
                        omniORB.tcInternal.tv_long, 9)
    _ad_CameraSetting = (omniORB.tcInternal.tv_alias,
                         CameraSetting._NP_RepositoryId, "CameraSetting",
                         (omniORB.tcInternal.tv_array,
                          omniORB.tcInternal.tv_long, 9))
    _tc_CameraSetting = omniORB.tcInternal.createTypeCode(_ad_CameraSetting)
    omniORB.registerType(CameraSetting._NP_RepositoryId, _ad_CameraSetting,
                         _tc_CameraSetting)
Esempio n. 22
0
class EmsSession_I(_0_session.Session_I):
    _NP_RepositoryId = _0_emsSession._d_EmsSession_I[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # typedef ... managerNames_T
    class managerNames_T:
        _NP_RepositoryId = "IDL:mtnm.tmforum.org/emsSession/EmsSession_I/managerNames_T:1.0"

        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")

    _d_managerNames_T = (omniORB.tcInternal.tv_sequence,
                         (omniORB.tcInternal.tv_string, 0), 0)
    _ad_managerNames_T = (omniORB.tcInternal.tv_alias,
                          managerNames_T._NP_RepositoryId, "managerNames_T",
                          (omniORB.tcInternal.tv_sequence,
                           (omniORB.tcInternal.tv_string, 0), 0))
    _tc_managerNames_T = omniORB.tcInternal.createTypeCode(_ad_managerNames_T)
    omniORB.registerType(managerNames_T._NP_RepositoryId, _ad_managerNames_T,
                         _tc_managerNames_T)
Esempio n. 23
0
# interface mWriter
_0_Writer._d_mWriter = (omniORB.tcInternal.tv_objref, "IDL:Writer/mWriter:1.0", "mWriter")
omniORB.typeMapping["IDL:Writer/mWriter:1.0"] = _0_Writer._d_mWriter
_0_Writer.mWriter = omniORB.newEmptyClass()
class mWriter :
    _NP_RepositoryId = _0_Writer._d_mWriter[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_Writer.mWriter = mWriter
_0_Writer._tc_mWriter = omniORB.tcInternal.createTypeCode(_0_Writer._d_mWriter)
omniORB.registerType(mWriter._NP_RepositoryId, _0_Writer._d_mWriter, _0_Writer._tc_mWriter)

# mWriter operations and attributes
mWriter._d_oCurrentCursorPositionX = ((), (omniORB.tcInternal.tv_float, ), None)
mWriter._d_oCurrentCursorPositionY = ((), (omniORB.tcInternal.tv_float, ), None)
mWriter._d_gotoStart = ((omniORB.tcInternal.tv_boolean, ), (), None)
mWriter._d_gotoEnd = ((omniORB.tcInternal.tv_boolean, ), (), None)
mWriter._d_gotoStartOfLine = ((omniORB.tcInternal.tv_boolean, ), (), None)
mWriter._d_gotoEndOfLine = ((omniORB.tcInternal.tv_boolean, ), (), None)

# mWriter object reference
class _objref_mWriter (CORBA.Object):
    _NP_RepositoryId = mWriter._NP_RepositoryId

    def __init__(self):
        CORBA.Object.__init__(self)
Esempio n. 24
0
class ServiceTypeRepository:
    _NP_RepositoryId = _0_CosTradingRepos._d_ServiceTypeRepository[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil

    # typedef ... ServiceTypeNameSeq
    class ServiceTypeNameSeq:
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/ServiceTypeNameSeq:1.0"

        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")

    _d_ServiceTypeNameSeq = (
        omniORB.tcInternal.tv_sequence,
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"], 0)
    _ad_ServiceTypeNameSeq = (
        omniORB.tcInternal.tv_alias, ServiceTypeNameSeq._NP_RepositoryId,
        "ServiceTypeNameSeq",
        (omniORB.tcInternal.tv_sequence,
         omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"], 0))
    _tc_ServiceTypeNameSeq = omniORB.tcInternal.createTypeCode(
        _ad_ServiceTypeNameSeq)
    omniORB.registerType(ServiceTypeNameSeq._NP_RepositoryId,
                         _ad_ServiceTypeNameSeq, _tc_ServiceTypeNameSeq)

    # enum PropertyMode
    PROP_NORMAL = omniORB.EnumItem("PROP_NORMAL", 0)
    PROP_READONLY = omniORB.EnumItem("PROP_READONLY", 1)
    PROP_MANDATORY = omniORB.EnumItem("PROP_MANDATORY", 2)
    PROP_MANDATORY_READONLY = omniORB.EnumItem("PROP_MANDATORY_READONLY", 3)
    PropertyMode = omniORB.Enum(
        "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropertyMode:1.0", (
            PROP_NORMAL,
            PROP_READONLY,
            PROP_MANDATORY,
            PROP_MANDATORY_READONLY,
        ))

    _d_PropertyMode = (omniORB.tcInternal.tv_enum,
                       PropertyMode._NP_RepositoryId, "PropertyMode",
                       PropertyMode._items)
    _tc_PropertyMode = omniORB.tcInternal.createTypeCode(_d_PropertyMode)
    omniORB.registerType(PropertyMode._NP_RepositoryId, _d_PropertyMode,
                         _tc_PropertyMode)

    # struct PropStruct
    _0_CosTradingRepos.ServiceTypeRepository.PropStruct = omniORB.newEmptyClass(
    )

    class PropStruct(omniORB.StructBase):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropStruct:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.PropStruct"

        def __init__(self, name, value_type, mode):
            self.name = name
            self.value_type = value_type
            self.mode = mode

    _d_PropStruct = _0_CosTradingRepos.ServiceTypeRepository._d_PropStruct = (
        omniORB.tcInternal.tv_struct, PropStruct, PropStruct._NP_RepositoryId,
        "PropStruct", "name",
        omniORB.typeMapping["IDL:omg.org/CosTrading/PropertyName:1.0"],
        "value_type", omniORB.tcInternal.tv_TypeCode, "mode",
        omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropertyMode:1.0"]
    )
    _tc_PropStruct = omniORB.tcInternal.createTypeCode(_d_PropStruct)
    omniORB.registerType(PropStruct._NP_RepositoryId, _d_PropStruct,
                         _tc_PropStruct)

    # typedef ... PropStructSeq
    class PropStructSeq:
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropStructSeq:1.0"

        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")

    _d_PropStructSeq = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping[
        "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropStruct:1.0"], 0)
    _ad_PropStructSeq = (
        omniORB.tcInternal.tv_alias, PropStructSeq._NP_RepositoryId,
        "PropStructSeq", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropStruct:1.0"],
                          0))
    _tc_PropStructSeq = omniORB.tcInternal.createTypeCode(_ad_PropStructSeq)
    omniORB.registerType(PropStructSeq._NP_RepositoryId, _ad_PropStructSeq,
                         _tc_PropStructSeq)

    # typedef ... Identifier
    class Identifier:
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/Identifier:1.0"

        def __init__(self, *args, **kw):
            raise RuntimeError("Cannot construct objects of this type.")

    _d_Identifier = omniORB.typeMapping["IDL:omg.org/CosTrading/Istring:1.0"]
    _ad_Identifier = (
        omniORB.tcInternal.tv_alias, Identifier._NP_RepositoryId, "Identifier",
        omniORB.typeCodeMapping["IDL:omg.org/CosTrading/Istring:1.0"]._d)
    _tc_Identifier = omniORB.tcInternal.createTypeCode(_ad_Identifier)
    omniORB.registerType(Identifier._NP_RepositoryId, _ad_Identifier,
                         _tc_Identifier)

    # struct IncarnationNumber
    _0_CosTradingRepos.ServiceTypeRepository.IncarnationNumber = omniORB.newEmptyClass(
    )

    class IncarnationNumber(omniORB.StructBase):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/IncarnationNumber:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.IncarnationNumber"

        def __init__(self, high, low):
            self.high = high
            self.low = low

    _d_IncarnationNumber = _0_CosTradingRepos.ServiceTypeRepository._d_IncarnationNumber = (
        omniORB.tcInternal.tv_struct, IncarnationNumber,
        IncarnationNumber._NP_RepositoryId, "IncarnationNumber", "high",
        omniORB.tcInternal.tv_ulong, "low", omniORB.tcInternal.tv_ulong)
    _tc_IncarnationNumber = omniORB.tcInternal.createTypeCode(
        _d_IncarnationNumber)
    omniORB.registerType(IncarnationNumber._NP_RepositoryId,
                         _d_IncarnationNumber, _tc_IncarnationNumber)

    # struct TypeStruct
    _0_CosTradingRepos.ServiceTypeRepository.TypeStruct = omniORB.newEmptyClass(
    )

    class TypeStruct(omniORB.StructBase):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/TypeStruct:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.TypeStruct"

        def __init__(self, if_name, props, super_types, masked, incarnation):
            self.if_name = if_name
            self.props = props
            self.super_types = super_types
            self.masked = masked
            self.incarnation = incarnation

    _d_TypeStruct = _0_CosTradingRepos.ServiceTypeRepository._d_TypeStruct = (
        omniORB.tcInternal.tv_struct, TypeStruct, TypeStruct._NP_RepositoryId,
        "TypeStruct", "if_name", omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/Identifier:1.0"],
        "props", omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropStructSeq:1.0"],
        "super_types", omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/ServiceTypeNameSeq:1.0"],
        "masked", omniORB.tcInternal.tv_boolean, "incarnation",
        omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/IncarnationNumber:1.0"]
    )
    _tc_TypeStruct = omniORB.tcInternal.createTypeCode(_d_TypeStruct)
    omniORB.registerType(TypeStruct._NP_RepositoryId, _d_TypeStruct,
                         _tc_TypeStruct)

    # enum ListOption
    all = omniORB.EnumItem("all", 0)
    since = omniORB.EnumItem("since", 1)
    ListOption = omniORB.Enum(
        "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/ListOption:1.0", (
            all,
            since,
        ))

    _d_ListOption = (omniORB.tcInternal.tv_enum, ListOption._NP_RepositoryId,
                     "ListOption", ListOption._items)
    _tc_ListOption = omniORB.tcInternal.createTypeCode(_d_ListOption)
    omniORB.registerType(ListOption._NP_RepositoryId, _d_ListOption,
                         _tc_ListOption)

    # union SpecifiedServiceTypes
    _0_CosTradingRepos.ServiceTypeRepository.SpecifiedServiceTypes = omniORB.newEmptyClass(
    )

    class SpecifiedServiceTypes(omniORB.Union):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/SpecifiedServiceTypes:1.0"
        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.SpecifiedServiceTypes"

    SpecifiedServiceTypes._m_to_d = {"incarnation": since}
    SpecifiedServiceTypes._d_to_m = {since: "incarnation"}
    SpecifiedServiceTypes._def_m = None
    SpecifiedServiceTypes._def_d = None

    _m_SpecifiedServiceTypes = ((since, "incarnation", omniORB.typeMapping[
        "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/IncarnationNumber:1.0"]
                                 ), )
    _d_SpecifiedServiceTypes = _0_CosTradingRepos.ServiceTypeRepository._d_SpecifiedServiceTypes = (
        omniORB.tcInternal.tv_union, SpecifiedServiceTypes,
        SpecifiedServiceTypes._NP_RepositoryId, "SpecifiedServiceTypes",
        omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/ListOption:1.0"],
        -1, _m_SpecifiedServiceTypes, None, {
            since: _m_SpecifiedServiceTypes[0]
        })
    _tc_SpecifiedServiceTypes = omniORB.tcInternal.createTypeCode(
        _d_SpecifiedServiceTypes)
    omniORB.registerType(SpecifiedServiceTypes._NP_RepositoryId,
                         _d_SpecifiedServiceTypes, _tc_SpecifiedServiceTypes)

    # exception ServiceTypeExists
    _0_CosTradingRepos.ServiceTypeRepository.ServiceTypeExists = omniORB.newEmptyClass(
    )

    class ServiceTypeExists(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/ServiceTypeExists:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.ServiceTypeExists"

        def __init__(self, name):
            CORBA.UserException.__init__(self, name)
            self.name = name

    _d_ServiceTypeExists = (
        omniORB.tcInternal.tv_except, ServiceTypeExists,
        ServiceTypeExists._NP_RepositoryId, "ServiceTypeExists", "name",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"])
    _tc_ServiceTypeExists = omniORB.tcInternal.createTypeCode(
        _d_ServiceTypeExists)
    omniORB.registerType(ServiceTypeExists._NP_RepositoryId,
                         _d_ServiceTypeExists, _tc_ServiceTypeExists)

    # exception InterfaceTypeMismatch
    _0_CosTradingRepos.ServiceTypeRepository.InterfaceTypeMismatch = omniORB.newEmptyClass(
    )

    class InterfaceTypeMismatch(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/InterfaceTypeMismatch:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.InterfaceTypeMismatch"

        def __init__(self, base_service, base_if, derived_service, derived_if):
            CORBA.UserException.__init__(self, base_service, base_if,
                                         derived_service, derived_if)
            self.base_service = base_service
            self.base_if = base_if
            self.derived_service = derived_service
            self.derived_if = derived_if

    _d_InterfaceTypeMismatch = (
        omniORB.tcInternal.tv_except, InterfaceTypeMismatch,
        InterfaceTypeMismatch._NP_RepositoryId, "InterfaceTypeMismatch",
        "base_service",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"],
        "base_if", omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/Identifier:1.0"],
        "derived_service",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"],
        "derived_if", omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/Identifier:1.0"]
    )
    _tc_InterfaceTypeMismatch = omniORB.tcInternal.createTypeCode(
        _d_InterfaceTypeMismatch)
    omniORB.registerType(InterfaceTypeMismatch._NP_RepositoryId,
                         _d_InterfaceTypeMismatch, _tc_InterfaceTypeMismatch)

    # exception HasSubTypes
    _0_CosTradingRepos.ServiceTypeRepository.HasSubTypes = omniORB.newEmptyClass(
    )

    class HasSubTypes(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/HasSubTypes:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.HasSubTypes"

        def __init__(self, the_type, sub_type):
            CORBA.UserException.__init__(self, the_type, sub_type)
            self.the_type = the_type
            self.sub_type = sub_type

    _d_HasSubTypes = (
        omniORB.tcInternal.tv_except, HasSubTypes,
        HasSubTypes._NP_RepositoryId, "HasSubTypes", "the_type",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"],
        "sub_type",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"])
    _tc_HasSubTypes = omniORB.tcInternal.createTypeCode(_d_HasSubTypes)
    omniORB.registerType(HasSubTypes._NP_RepositoryId, _d_HasSubTypes,
                         _tc_HasSubTypes)

    # exception AlreadyMasked
    _0_CosTradingRepos.ServiceTypeRepository.AlreadyMasked = omniORB.newEmptyClass(
    )

    class AlreadyMasked(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/AlreadyMasked:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.AlreadyMasked"

        def __init__(self, name):
            CORBA.UserException.__init__(self, name)
            self.name = name

    _d_AlreadyMasked = (
        omniORB.tcInternal.tv_except, AlreadyMasked,
        AlreadyMasked._NP_RepositoryId, "AlreadyMasked", "name",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"])
    _tc_AlreadyMasked = omniORB.tcInternal.createTypeCode(_d_AlreadyMasked)
    omniORB.registerType(AlreadyMasked._NP_RepositoryId, _d_AlreadyMasked,
                         _tc_AlreadyMasked)

    # exception NotMasked
    _0_CosTradingRepos.ServiceTypeRepository.NotMasked = omniORB.newEmptyClass(
    )

    class NotMasked(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/NotMasked:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.NotMasked"

        def __init__(self, name):
            CORBA.UserException.__init__(self, name)
            self.name = name

    _d_NotMasked = (
        omniORB.tcInternal.tv_except, NotMasked, NotMasked._NP_RepositoryId,
        "NotMasked", "name",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"])
    _tc_NotMasked = omniORB.tcInternal.createTypeCode(_d_NotMasked)
    omniORB.registerType(NotMasked._NP_RepositoryId, _d_NotMasked,
                         _tc_NotMasked)

    # exception ValueTypeRedefinition
    _0_CosTradingRepos.ServiceTypeRepository.ValueTypeRedefinition = omniORB.newEmptyClass(
    )

    class ValueTypeRedefinition(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/ValueTypeRedefinition:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.ValueTypeRedefinition"

        def __init__(self, type_1, definition_1, type_2, definition_2):
            CORBA.UserException.__init__(self, type_1, definition_1, type_2,
                                         definition_2)
            self.type_1 = type_1
            self.definition_1 = definition_1
            self.type_2 = type_2
            self.definition_2 = definition_2

    _d_ValueTypeRedefinition = (
        omniORB.tcInternal.tv_except, ValueTypeRedefinition,
        ValueTypeRedefinition._NP_RepositoryId, "ValueTypeRedefinition",
        "type_1",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"],
        "definition_1", omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropStruct:1.0"],
        "type_2",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"],
        "definition_2", omniORB.typeMapping[
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropStruct:1.0"]
    )
    _tc_ValueTypeRedefinition = omniORB.tcInternal.createTypeCode(
        _d_ValueTypeRedefinition)
    omniORB.registerType(ValueTypeRedefinition._NP_RepositoryId,
                         _d_ValueTypeRedefinition, _tc_ValueTypeRedefinition)

    # exception DuplicateServiceTypeName
    _0_CosTradingRepos.ServiceTypeRepository.DuplicateServiceTypeName = omniORB.newEmptyClass(
    )

    class DuplicateServiceTypeName(CORBA.UserException):
        _NP_RepositoryId = "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/DuplicateServiceTypeName:1.0"

        _NP_ClassName = "CosTradingRepos.ServiceTypeRepository.DuplicateServiceTypeName"

        def __init__(self, name):
            CORBA.UserException.__init__(self, name)
            self.name = name

    _d_DuplicateServiceTypeName = (
        omniORB.tcInternal.tv_except, DuplicateServiceTypeName,
        DuplicateServiceTypeName._NP_RepositoryId, "DuplicateServiceTypeName",
        "name",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"])
    _tc_DuplicateServiceTypeName = omniORB.tcInternal.createTypeCode(
        _d_DuplicateServiceTypeName)
    omniORB.registerType(DuplicateServiceTypeName._NP_RepositoryId,
                         _d_DuplicateServiceTypeName,
                         _tc_DuplicateServiceTypeName)

class TypedPushConsumer(_0_CosEventComm.PushConsumer):
    _NP_RepositoryId = _0_CosTypedEventComm._d_TypedPushConsumer[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_CosTypedEventComm.TypedPushConsumer = TypedPushConsumer
_0_CosTypedEventComm._tc_TypedPushConsumer = omniORB.tcInternal.createTypeCode(
    _0_CosTypedEventComm._d_TypedPushConsumer)
omniORB.registerType(TypedPushConsumer._NP_RepositoryId,
                     _0_CosTypedEventComm._d_TypedPushConsumer,
                     _0_CosTypedEventComm._tc_TypedPushConsumer)

# TypedPushConsumer operations and attributes
TypedPushConsumer._d_get_typed_consumer = ((), (
    omniORB.typeMapping["IDL:omg.org/CORBA/Object:1.0"], ), None)


# TypedPushConsumer object reference
class _objref_TypedPushConsumer(_0_CosEventComm._objref_PushConsumer):
    _NP_RepositoryId = TypedPushConsumer._NP_RepositoryId

    def __init__(self):
        _0_CosEventComm._objref_PushConsumer.__init__(self)

    def get_typed_consumer(self, *args):
Esempio n. 26
0
_0_globaldefs__POA = omniORB.openModule("globaldefs__POA", r"globaldefs.idl")


# struct NameAndStringValue_T
_0_globaldefs.NameAndStringValue_T = omniORB.newEmptyClass()
class NameAndStringValue_T (omniORB.StructBase):
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/globaldefs/NameAndStringValue_T:1.0"

    def __init__(self, name, value):
        self.name = name
        self.value = value

_0_globaldefs.NameAndStringValue_T = NameAndStringValue_T
_0_globaldefs._d_NameAndStringValue_T  = (omniORB.tcInternal.tv_struct, NameAndStringValue_T, NameAndStringValue_T._NP_RepositoryId, "NameAndStringValue_T", "name", (omniORB.tcInternal.tv_string,0), "value", (omniORB.tcInternal.tv_string,0))
_0_globaldefs._tc_NameAndStringValue_T = omniORB.tcInternal.createTypeCode(_0_globaldefs._d_NameAndStringValue_T)
omniORB.registerType(NameAndStringValue_T._NP_RepositoryId, _0_globaldefs._d_NameAndStringValue_T, _0_globaldefs._tc_NameAndStringValue_T)
del NameAndStringValue_T

# typedef ... NVSList_T
class NVSList_T:
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/globaldefs/NVSList_T:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_globaldefs.NVSList_T = NVSList_T
_0_globaldefs._d_NVSList_T  = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/NameAndStringValue_T:1.0"], 0)
_0_globaldefs._ad_NVSList_T = (omniORB.tcInternal.tv_alias, NVSList_T._NP_RepositoryId, "NVSList_T", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/NameAndStringValue_T:1.0"], 0))
_0_globaldefs._tc_NVSList_T = omniORB.tcInternal.createTypeCode(_0_globaldefs._ad_NVSList_T)
omniORB.registerType(NVSList_T._NP_RepositoryId, _0_globaldefs._ad_NVSList_T, _0_globaldefs._tc_NVSList_T)
del NVSList_T

# typedef ... NamingAttributes_T
Esempio n. 27
0
class Disconnected(CORBA.UserException):
    _NP_RepositoryId = "IDL:omg.org/CosEventComm/Disconnected:1.0"

    def __init__(self):
        CORBA.UserException.__init__(self)


_0_CosEventComm.Disconnected = Disconnected
_0_CosEventComm._d_Disconnected = (
    omniORB.tcInternal.tv_except,
    Disconnected,
    Disconnected._NP_RepositoryId,
    "Disconnected",
)
_0_CosEventComm._tc_Disconnected = omniORB.tcInternal.createTypeCode(_0_CosEventComm._d_Disconnected)
omniORB.registerType(Disconnected._NP_RepositoryId, _0_CosEventComm._d_Disconnected, _0_CosEventComm._tc_Disconnected)
del Disconnected

# interface PushConsumer
_0_CosEventComm._d_PushConsumer = (
    omniORB.tcInternal.tv_objref,
    "IDL:omg.org/CosEventComm/PushConsumer:1.0",
    "PushConsumer",
)
omniORB.typeMapping["IDL:omg.org/CosEventComm/PushConsumer:1.0"] = _0_CosEventComm._d_PushConsumer
_0_CosEventComm.PushConsumer = omniORB.newEmptyClass()


class PushConsumer:
    _NP_RepositoryId = _0_CosEventComm._d_PushConsumer[1]
Esempio n. 28
0
class MaintenanceOperation_T:
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/maintenanceOps/MaintenanceOperation_T:1.0"

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")


_0_maintenanceOps.MaintenanceOperation_T = MaintenanceOperation_T
_0_maintenanceOps._d_MaintenanceOperation_T = (omniORB.tcInternal.tv_string, 0)
_0_maintenanceOps._ad_MaintenanceOperation_T = (
    omniORB.tcInternal.tv_alias, MaintenanceOperation_T._NP_RepositoryId,
    "MaintenanceOperation_T", (omniORB.tcInternal.tv_string, 0))
_0_maintenanceOps._tc_MaintenanceOperation_T = omniORB.tcInternal.createTypeCode(
    _0_maintenanceOps._ad_MaintenanceOperation_T)
omniORB.registerType(MaintenanceOperation_T._NP_RepositoryId,
                     _0_maintenanceOps._ad_MaintenanceOperation_T,
                     _0_maintenanceOps._tc_MaintenanceOperation_T)
del MaintenanceOperation_T

# enum MaintenanceOperationMode_T
_0_maintenanceOps.MOM_OPERATE = omniORB.EnumItem("MOM_OPERATE", 0)
_0_maintenanceOps.MOM_RELEASE = omniORB.EnumItem("MOM_RELEASE", 1)
_0_maintenanceOps.MaintenanceOperationMode_T = omniORB.Enum(
    "IDL:mtnm.tmforum.org/maintenanceOps/MaintenanceOperationMode_T:1.0", (
        _0_maintenanceOps.MOM_OPERATE,
        _0_maintenanceOps.MOM_RELEASE,
    ))

_0_maintenanceOps._d_MaintenanceOperationMode_T = (
    omniORB.tcInternal.tv_enum,
    _0_maintenanceOps.MaintenanceOperationMode_T._NP_RepositoryId,
Esempio n. 29
0

# forward interface IDLType;
_0_CORBA._d_IDLType = (omniORB.tcInternal.tv_objref, "IDL:omg.org/CORBA/IDLType:1.0", "IDLType")
omniORB.typeMapping["IDL:omg.org/CORBA/IDLType:1.0"] = _0_CORBA._d_IDLType

# typedef ... Identifier
class Identifier:
    _NP_RepositoryId = "IDL:omg.org/CORBA/Identifier:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_CORBA.Identifier = Identifier
_0_CORBA._d_Identifier  = (omniORB.tcInternal.tv_string,0)
_0_CORBA._ad_Identifier = (omniORB.tcInternal.tv_alias, Identifier._NP_RepositoryId, "Identifier", (omniORB.tcInternal.tv_string,0))
_0_CORBA._tc_Identifier = omniORB.tcInternal.createTypeCode(_0_CORBA._ad_Identifier)
omniORB.registerType(Identifier._NP_RepositoryId, _0_CORBA._ad_Identifier, _0_CORBA._tc_Identifier)
del Identifier

# typedef ... RepositoryId
class RepositoryId:
    _NP_RepositoryId = "IDL:omg.org/CORBA/RepositoryId:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_CORBA.RepositoryId = RepositoryId
_0_CORBA._d_RepositoryId  = (omniORB.tcInternal.tv_string,0)
_0_CORBA._ad_RepositoryId = (omniORB.tcInternal.tv_alias, RepositoryId._NP_RepositoryId, "RepositoryId", (omniORB.tcInternal.tv_string,0))
_0_CORBA._tc_RepositoryId = omniORB.tcInternal.createTypeCode(_0_CORBA._ad_RepositoryId)
omniORB.registerType(RepositoryId._NP_RepositoryId, _0_CORBA._ad_RepositoryId, _0_CORBA._tc_RepositoryId)
del RepositoryId

# typedef ... VersionSpec
        _0_trafficDescriptor.SC_NA,
    ),
)

_0_trafficDescriptor._d_ServiceCategory_T = (
    omniORB.tcInternal.tv_enum,
    _0_trafficDescriptor.ServiceCategory_T._NP_RepositoryId,
    "ServiceCategory_T",
    _0_trafficDescriptor.ServiceCategory_T._items,
)
_0_trafficDescriptor._tc_ServiceCategory_T = omniORB.tcInternal.createTypeCode(
    _0_trafficDescriptor._d_ServiceCategory_T
)
omniORB.registerType(
    _0_trafficDescriptor.ServiceCategory_T._NP_RepositoryId,
    _0_trafficDescriptor._d_ServiceCategory_T,
    _0_trafficDescriptor._tc_ServiceCategory_T,
)

# typedef ... TrafficParameterList_T
class TrafficParameterList_T:
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/trafficDescriptor/TrafficParameterList_T:1.0"

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")


_0_trafficDescriptor.TrafficParameterList_T = TrafficParameterList_T
_0_trafficDescriptor._d_TrafficParameterList_T = omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/NVSList_T:1.0"]
_0_trafficDescriptor._ad_TrafficParameterList_T = (
    omniORB.tcInternal.tv_alias,
Esempio n. 31
0
#
__name__ = "mLSNPP"
_0_mLSNPP = omniORB.openModule("mLSNPP", r"mLSNPP.idl")
_0_mLSNPP__POA = omniORB.openModule("mLSNPP__POA", r"mLSNPP.idl")


# typedef ... TNAName_T
class TNAName_T:
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/mLSNPP/TNAName_T:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_mLSNPP.TNAName_T = TNAName_T
_0_mLSNPP._d_TNAName_T  = (omniORB.tcInternal.tv_string,0)
_0_mLSNPP._ad_TNAName_T = (omniORB.tcInternal.tv_alias, TNAName_T._NP_RepositoryId, "TNAName_T", (omniORB.tcInternal.tv_string,0))
_0_mLSNPP._tc_TNAName_T = omniORB.tcInternal.createTypeCode(_0_mLSNPP._ad_TNAName_T)
omniORB.registerType(TNAName_T._NP_RepositoryId, _0_mLSNPP._ad_TNAName_T, _0_mLSNPP._tc_TNAName_T)
del TNAName_T

# typedef ... TNAList_T
class TNAList_T:
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/mLSNPP/TNAList_T:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_mLSNPP.TNAList_T = TNAList_T
_0_mLSNPP._d_TNAList_T  = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:mtnm.tmforum.org/mLSNPP/TNAName_T:1.0"], 0)
_0_mLSNPP._ad_TNAList_T = (omniORB.tcInternal.tv_alias, TNAList_T._NP_RepositoryId, "TNAList_T", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:mtnm.tmforum.org/mLSNPP/TNAName_T:1.0"], 0))
_0_mLSNPP._tc_TNAList_T = omniORB.tcInternal.createTypeCode(_0_mLSNPP._ad_TNAList_T)
omniORB.registerType(TNAList_T._NP_RepositoryId, _0_mLSNPP._ad_TNAList_T, _0_mLSNPP._tc_TNAList_T)
del TNAList_T

# struct SNP_T
# interface DataFlowComponent
_0_OpenRTM._d_DataFlowComponent = (omniORB.tcInternal.tv_objref, "IDL:openrtm.aist.go.jp/OpenRTM/DataFlowComponent:1.0", "DataFlowComponent")
omniORB.typeMapping["IDL:openrtm.aist.go.jp/OpenRTM/DataFlowComponent:1.0"] = _0_OpenRTM._d_DataFlowComponent
_0_OpenRTM.DataFlowComponent = omniORB.newEmptyClass()
class DataFlowComponent (_0_RTC.RTObject, _0_RTC.DataFlowComponent):
    _NP_RepositoryId = _0_OpenRTM._d_DataFlowComponent[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_OpenRTM.DataFlowComponent = DataFlowComponent
_0_OpenRTM._tc_DataFlowComponent = omniORB.tcInternal.createTypeCode(_0_OpenRTM._d_DataFlowComponent)
omniORB.registerType(DataFlowComponent._NP_RepositoryId, _0_OpenRTM._d_DataFlowComponent, _0_OpenRTM._tc_DataFlowComponent)

# DataFlowComponent object reference
class _objref_DataFlowComponent (_0_RTC._objref_RTObject, _0_RTC._objref_DataFlowComponent):
    _NP_RepositoryId = DataFlowComponent._NP_RepositoryId

    def __init__(self):
        _0_RTC._objref_RTObject.__init__(self)
        _0_RTC._objref_DataFlowComponent.__init__(self)

    __methods__ = [] + _0_RTC._objref_RTObject.__methods__ + _0_RTC._objref_DataFlowComponent.__methods__

omniORB.registerObjref(DataFlowComponent._NP_RepositoryId, _objref_DataFlowComponent)
_0_OpenRTM._objref_DataFlowComponent = _objref_DataFlowComponent
del DataFlowComponent, _objref_DataFlowComponent
Esempio n. 33
0
# Start of module "common"
#
__name__ = "common"
_0_common = omniORB.openModule("common", r"common.idl")
_0_common__POA = omniORB.openModule("common__POA", r"common.idl")


# typedef ... Capability_T
class Capability_T (_0_globaldefs.NameAndStringValue_T):
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/common/Capability_T:1.0"

_0_common.Capability_T = Capability_T
_0_common._d_Capability_T  = omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/NameAndStringValue_T:1.0"]
_0_common._ad_Capability_T = (omniORB.tcInternal.tv_alias, Capability_T._NP_RepositoryId, "Capability_T", omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/NameAndStringValue_T:1.0"])
_0_common._tc_Capability_T = omniORB.tcInternal.createTypeCode(_0_common._ad_Capability_T)
omniORB.registerType(Capability_T._NP_RepositoryId, _0_common._ad_Capability_T, _0_common._tc_Capability_T)
del Capability_T

# typedef ... CapabilityList_T
class CapabilityList_T:
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/common/CapabilityList_T:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_common.CapabilityList_T = CapabilityList_T
_0_common._d_CapabilityList_T  = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:mtnm.tmforum.org/common/Capability_T:1.0"], 0)
_0_common._ad_CapabilityList_T = (omniORB.tcInternal.tv_alias, CapabilityList_T._NP_RepositoryId, "CapabilityList_T", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:mtnm.tmforum.org/common/Capability_T:1.0"], 0))
_0_common._tc_CapabilityList_T = omniORB.tcInternal.createTypeCode(_0_common._ad_CapabilityList_T)
omniORB.registerType(CapabilityList_T._NP_RepositoryId, _0_common._ad_CapabilityList_T, _0_common._tc_CapabilityList_T)
del CapabilityList_T

# interface Common_I
Esempio n. 34
0
#
__name__ = "CORBA"
_0_CORBA = omniORB.openModule("CORBA", r"/usr/local/share/idl/omniORB/boxes.idl")
_0_CORBA__POA = omniORB.openModule("CORBA__POA", r"/usr/local/share/idl/omniORB/boxes.idl")


# valuebox StringValue
class StringValue:
    _NP_RepositoryId = "IDL:omg.org/CORBA/StringValue:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

_0_CORBA.StringValue = StringValue
_0_CORBA._d_StringValue  = (omniORB.tcInternal.tv_value_box, StringValue, StringValue._NP_RepositoryId, "StringValue", (omniORB.tcInternal.tv_string,0))
_0_CORBA._tc_StringValue = omniORB.tcInternal.createTypeCode(_0_CORBA._d_StringValue)
omniORB.registerType(StringValue._NP_RepositoryId, _0_CORBA._d_StringValue, _0_CORBA._tc_StringValue)
omniORB.registerValueFactory(StringValue._NP_RepositoryId, StringValue)
del StringValue


# valuebox WStringValue
class WStringValue:
    _NP_RepositoryId = "IDL:omg.org/CORBA/WStringValue:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

_0_CORBA.WStringValue = WStringValue
_0_CORBA._d_WStringValue  = (omniORB.tcInternal.tv_value_box, WStringValue, WStringValue._NP_RepositoryId, "WStringValue", (omniORB.tcInternal.tv_wstring,0))
_0_CORBA._tc_WStringValue = omniORB.tcInternal.createTypeCode(_0_CORBA._d_WStringValue)
omniORB.registerType(WStringValue._NP_RepositoryId, _0_CORBA._d_WStringValue, _0_CORBA._tc_WStringValue)
omniORB.registerValueFactory(WStringValue._NP_RepositoryId, WStringValue)
Esempio n. 35
0
#
__name__ = "terminationPoint"
_0_terminationPoint = omniORB.openModule("terminationPoint", r"terminationPoint.idl")
_0_terminationPoint__POA = omniORB.openModule("terminationPoint__POA", r"terminationPoint.idl")


# enum Directionality_T
_0_terminationPoint.D_NA = omniORB.EnumItem("D_NA", 0)
_0_terminationPoint.D_BIDIRECTIONAL = omniORB.EnumItem("D_BIDIRECTIONAL", 1)
_0_terminationPoint.D_SOURCE = omniORB.EnumItem("D_SOURCE", 2)
_0_terminationPoint.D_SINK = omniORB.EnumItem("D_SINK", 3)
_0_terminationPoint.Directionality_T = omniORB.Enum("IDL:mtnm.tmforum.org/terminationPoint/Directionality_T:1.0", (_0_terminationPoint.D_NA, _0_terminationPoint.D_BIDIRECTIONAL, _0_terminationPoint.D_SOURCE, _0_terminationPoint.D_SINK,))

_0_terminationPoint._d_Directionality_T  = (omniORB.tcInternal.tv_enum, _0_terminationPoint.Directionality_T._NP_RepositoryId, "Directionality_T", _0_terminationPoint.Directionality_T._items)
_0_terminationPoint._tc_Directionality_T = omniORB.tcInternal.createTypeCode(_0_terminationPoint._d_Directionality_T)
omniORB.registerType(_0_terminationPoint.Directionality_T._NP_RepositoryId, _0_terminationPoint._d_Directionality_T, _0_terminationPoint._tc_Directionality_T)

# enum TPConnectionState_T
_0_terminationPoint.TPCS_NA = omniORB.EnumItem("TPCS_NA", 0)
_0_terminationPoint.TPCS_SOURCE_CONNECTED = omniORB.EnumItem("TPCS_SOURCE_CONNECTED", 1)
_0_terminationPoint.TPCS_SINK_CONNECTED = omniORB.EnumItem("TPCS_SINK_CONNECTED", 2)
_0_terminationPoint.TPCS_BI_CONNECTED = omniORB.EnumItem("TPCS_BI_CONNECTED", 3)
_0_terminationPoint.TPCS_NOT_CONNECTED = omniORB.EnumItem("TPCS_NOT_CONNECTED", 4)
_0_terminationPoint.TPConnectionState_T = omniORB.Enum("IDL:mtnm.tmforum.org/terminationPoint/TPConnectionState_T:1.0", (_0_terminationPoint.TPCS_NA, _0_terminationPoint.TPCS_SOURCE_CONNECTED, _0_terminationPoint.TPCS_SINK_CONNECTED, _0_terminationPoint.TPCS_BI_CONNECTED, _0_terminationPoint.TPCS_NOT_CONNECTED,))

_0_terminationPoint._d_TPConnectionState_T  = (omniORB.tcInternal.tv_enum, _0_terminationPoint.TPConnectionState_T._NP_RepositoryId, "TPConnectionState_T", _0_terminationPoint.TPConnectionState_T._items)
_0_terminationPoint._tc_TPConnectionState_T = omniORB.tcInternal.createTypeCode(_0_terminationPoint._d_TPConnectionState_T)
omniORB.registerType(_0_terminationPoint.TPConnectionState_T._NP_RepositoryId, _0_terminationPoint._d_TPConnectionState_T, _0_terminationPoint._tc_TPConnectionState_T)

# enum TPType_T
_0_terminationPoint.TPT_PTP = omniORB.EnumItem("TPT_PTP", 0)
Esempio n. 36
0
#
__name__ = "_GlobalIDL"
_0__GlobalIDL = omniORB.openModule("_GlobalIDL", r"DataBase.idl")
_0__GlobalIDL__POA = omniORB.openModule("_GlobalIDL__POA", r"DataBase.idl")


# typedef ... StringSeq
class StringSeq:
    _NP_RepositoryId = "IDL:StringSeq:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0__GlobalIDL.StringSeq = StringSeq
_0__GlobalIDL._d_StringSeq  = (omniORB.tcInternal.tv_sequence, (omniORB.tcInternal.tv_string,0), 0)
_0__GlobalIDL._ad_StringSeq = (omniORB.tcInternal.tv_alias, StringSeq._NP_RepositoryId, "StringSeq", (omniORB.tcInternal.tv_sequence, (omniORB.tcInternal.tv_string,0), 0))
_0__GlobalIDL._tc_StringSeq = omniORB.tcInternal.createTypeCode(_0__GlobalIDL._ad_StringSeq)
omniORB.registerType(StringSeq._NP_RepositoryId, _0__GlobalIDL._ad_StringSeq, _0__GlobalIDL._tc_StringSeq)
del StringSeq

#
# Start of module "DataBase"
#
__name__ = "DataBase"
_0_DataBase = omniORB.openModule("DataBase", r"DataBase.idl")
_0_DataBase__POA = omniORB.openModule("DataBase__POA", r"DataBase.idl")


# interface mDataBase
_0_DataBase._d_mDataBase = (omniORB.tcInternal.tv_objref, "IDL:DataBase/mDataBase:1.0", "mDataBase")
omniORB.typeMapping["IDL:DataBase/mDataBase:1.0"] = _0_DataBase._d_mDataBase
_0_DataBase.mDataBase = omniORB.newEmptyClass()
class mDataBase :
Esempio n. 37
0
# interface DomeServer
_0_acsdomeServer._d_DomeServer = (omniORB.tcInternal.tv_objref, "IDL:alma/acsdomeServer/DomeServer:1.0", "DomeServer")
omniORB.typeMapping["IDL:alma/acsdomeServer/DomeServer:1.0"] = _0_acsdomeServer._d_DomeServer
_0_acsdomeServer.DomeServer = omniORB.newEmptyClass()
class DomeServer (_0_ACS.CharacteristicComponent):
    _NP_RepositoryId = _0_acsdomeServer._d_DomeServer[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_acsdomeServer.DomeServer = DomeServer
_0_acsdomeServer._tc_DomeServer = omniORB.tcInternal.createTypeCode(_0_acsdomeServer._d_DomeServer)
omniORB.registerType(DomeServer._NP_RepositoryId, _0_acsdomeServer._d_DomeServer, _0_acsdomeServer._tc_DomeServer)

# DomeServer operations and attributes
DomeServer._d_displayMessage = ((), (), None)
DomeServer._d_badMethod = ((), (), {_0_ACSErrTypeCommon.UnknownEx._NP_RepositoryId: _0_ACSErrTypeCommon._d_UnknownEx})
DomeServer._d__get_domeCurrentPosition = ((),(omniORB.typeMapping["IDL:alma/ACS/RWdouble:1.0"],),None)
DomeServer._d__get_slitCurrentState = ((),(omniORB.typeMapping["IDL:alma/ACS/RWlong:1.0"],),None)

# DomeServer object reference
class _objref_DomeServer (_0_ACS._objref_CharacteristicComponent):
    _NP_RepositoryId = DomeServer._NP_RepositoryId

    def __init__(self):
        _0_ACS._objref_CharacteristicComponent.__init__(self)

    def displayMessage(self, *args):
Esempio n. 38
0
# interface NmsSession_I
_0_nmsSession._d_NmsSession_I = (omniORB.tcInternal.tv_objref, "IDL:mtnm.tmforum.org/nmsSession/NmsSession_I:1.0", "NmsSession_I")
omniORB.typeMapping["IDL:mtnm.tmforum.org/nmsSession/NmsSession_I:1.0"] = _0_nmsSession._d_NmsSession_I
_0_nmsSession.NmsSession_I = omniORB.newEmptyClass()
class NmsSession_I (_0_session.Session_I):
    _NP_RepositoryId = _0_nmsSession._d_NmsSession_I[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_nmsSession.NmsSession_I = NmsSession_I
_0_nmsSession._tc_NmsSession_I = omniORB.tcInternal.createTypeCode(_0_nmsSession._d_NmsSession_I)
omniORB.registerType(NmsSession_I._NP_RepositoryId, _0_nmsSession._d_NmsSession_I, _0_nmsSession._tc_NmsSession_I)

# NmsSession_I operations and attributes
NmsSession_I._d_eventLossOccurred = ((omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/Time_T:1.0"], (omniORB.tcInternal.tv_string,0)), (), None)
NmsSession_I._d_eventLossCleared = ((omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/Time_T:1.0"], ), (), None)
NmsSession_I._d_alarmLossOccurred = ((omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/Time_T:1.0"], (omniORB.tcInternal.tv_string,0)), (), None)

# NmsSession_I object reference
class _objref_NmsSession_I (_0_session._objref_Session_I):
    _NP_RepositoryId = NmsSession_I._NP_RepositoryId

    def __init__(self, obj):
        _0_session._objref_Session_I.__init__(self, obj)

    def eventLossOccurred(self, *args):
        return self._obj.invoke("eventLossOccurred", _0_nmsSession.NmsSession_I._d_eventLossOccurred, args)
Esempio n. 39
0
__name__ = "NamingAuthority"
_0_NamingAuthority = omniORB.openModule("NamingAuthority", r"NamingAuthority.idl")
_0_NamingAuthority__POA = omniORB.openModule("NamingAuthority__POA", r"NamingAuthority.idl")


# enum RegistrationAuthority
_0_NamingAuthority.OTHER = omniORB.EnumItem("OTHER", 0)
_0_NamingAuthority.ISO = omniORB.EnumItem("ISO", 1)
_0_NamingAuthority.DNS = omniORB.EnumItem("DNS", 2)
_0_NamingAuthority.IDL = omniORB.EnumItem("IDL", 3)
_0_NamingAuthority.DCE = omniORB.EnumItem("DCE", 4)
_0_NamingAuthority.RegistrationAuthority = omniORB.Enum("IDL:omg.org/NamingAuthority/RegistrationAuthority:1.0", (_0_NamingAuthority.OTHER, _0_NamingAuthority.ISO, _0_NamingAuthority.DNS, _0_NamingAuthority.IDL, _0_NamingAuthority.DCE,))

_0_NamingAuthority._d_RegistrationAuthority  = (omniORB.tcInternal.tv_enum, _0_NamingAuthority.RegistrationAuthority._NP_RepositoryId, "RegistrationAuthority", _0_NamingAuthority.RegistrationAuthority._items)
_0_NamingAuthority._tc_RegistrationAuthority = omniORB.tcInternal.createTypeCode(_0_NamingAuthority._d_RegistrationAuthority)
omniORB.registerType(_0_NamingAuthority.RegistrationAuthority._NP_RepositoryId, _0_NamingAuthority._d_RegistrationAuthority, _0_NamingAuthority._tc_RegistrationAuthority)

# typedef ... NamingEntity
class NamingEntity:
    _NP_RepositoryId = "IDL:omg.org/NamingAuthority/NamingEntity:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_NamingAuthority.NamingEntity = NamingEntity
_0_NamingAuthority._d_NamingEntity  = (omniORB.tcInternal.tv_string,0)
_0_NamingAuthority._ad_NamingEntity = (omniORB.tcInternal.tv_alias, NamingEntity._NP_RepositoryId, "NamingEntity", (omniORB.tcInternal.tv_string,0))
_0_NamingAuthority._tc_NamingEntity = omniORB.tcInternal.createTypeCode(_0_NamingAuthority._ad_NamingEntity)
omniORB.registerType(NamingEntity._NP_RepositoryId, _0_NamingAuthority._ad_NamingEntity, _0_NamingAuthority._tc_NamingEntity)
del NamingEntity

# struct AuthorityId
_0_NamingAuthority.AuthorityId = omniORB.newEmptyClass()
    "userLabel", (omniORB.tcInternal.tv_string, 0), "nativeEMSName",
    (omniORB.tcInternal.tv_string, 0), "owner", (omniORB.tcInternal.tv_string,
                                                 0), "direction", omniORB.
    typeMapping["IDL:mtnm.tmforum.org/globaldefs/ConnectionDirection_T:1.0"],
    "rate", omniORB.
    typeMapping["IDL:mtnm.tmforum.org/transmissionParameters/LayerRate_T:1.0"],
    "aEndTP", omniORB.
    typeMapping["IDL:mtnm.tmforum.org/globaldefs/NamingAttributes_T:1.0"],
    "zEndTP", omniORB.
    typeMapping["IDL:mtnm.tmforum.org/globaldefs/NamingAttributes_T:1.0"],
    "additionalInfo",
    omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/NVSList_T:1.0"])
_0_topologicalLink._tc_TopologicalLink_T = omniORB.tcInternal.createTypeCode(
    _0_topologicalLink._d_TopologicalLink_T)
omniORB.registerType(TopologicalLink_T._NP_RepositoryId,
                     _0_topologicalLink._d_TopologicalLink_T,
                     _0_topologicalLink._tc_TopologicalLink_T)
del TopologicalLink_T


# typedef ... TopologicalLinkList_T
class TopologicalLinkList_T:
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/topologicalLink/TopologicalLinkList_T:1.0"

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")


_0_topologicalLink.TopologicalLinkList_T = TopologicalLinkList_T
_0_topologicalLink._d_TopologicalLinkList_T = (
    omniORB.tcInternal.tv_sequence, omniORB.
#
__name__ = "RTM"
_0_RTM = omniORB.openModule("RTM", r"/home/openrtm/svn/OpenRTM-aist-Python/OpenRTM_aist/RTM_IDL/Manager.idl")
_0_RTM__POA = omniORB.openModule("RTM__POA", r"/home/openrtm/svn/OpenRTM-aist-Python/OpenRTM_aist/RTM_IDL/Manager.idl")


# typedef ... NVList
class NVList:
    _NP_RepositoryId = "IDL:RTM/NVList:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_RTM.NVList = NVList
_0_RTM._d_NVList  = omniORB.typeMapping["IDL:org.omg/SDOPackage/NVList:1.0"]
_0_RTM._ad_NVList = (omniORB.tcInternal.tv_alias, NVList._NP_RepositoryId, "NVList", omniORB.typeCodeMapping["IDL:org.omg/SDOPackage/NVList:1.0"]._d)
_0_RTM._tc_NVList = omniORB.tcInternal.createTypeCode(_0_RTM._ad_NVList)
omniORB.registerType(NVList._NP_RepositoryId, _0_RTM._ad_NVList, _0_RTM._tc_NVList)
del NVList

# struct ModuleProfile
_0_RTM.ModuleProfile = omniORB.newEmptyClass()
class ModuleProfile (omniORB.StructBase):
    _NP_RepositoryId = "IDL:RTM/ModuleProfile:1.0"

    def __init__(self, properties):
        self.properties = properties

_0_RTM.ModuleProfile = ModuleProfile
_0_RTM._d_ModuleProfile  = (omniORB.tcInternal.tv_struct, ModuleProfile, ModuleProfile._NP_RepositoryId, "ModuleProfile", "properties", omniORB.typeMapping["IDL:RTM/NVList:1.0"])
_0_RTM._tc_ModuleProfile = omniORB.tcInternal.createTypeCode(_0_RTM._d_ModuleProfile)
omniORB.registerType(ModuleProfile._NP_RepositoryId, _0_RTM._d_ModuleProfile, _0_RTM._tc_ModuleProfile)
del ModuleProfile
Esempio n. 42
0
# interface Relationship
_0_CosReference._d_Relationship = (omniORB.tcInternal.tv_objref, "IDL:omg.org/CosReference/Relationship:1.0", "Relationship")
omniORB.typeMapping["IDL:omg.org/CosReference/Relationship:1.0"] = _0_CosReference._d_Relationship
_0_CosReference.Relationship = omniORB.newEmptyClass()
class Relationship (_0_CosRelationships.Relationship):
    _NP_RepositoryId = _0_CosReference._d_Relationship[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_CosReference.Relationship = Relationship
_0_CosReference._tc_Relationship = omniORB.tcInternal.createTypeCode(_0_CosReference._d_Relationship)
omniORB.registerType(Relationship._NP_RepositoryId, _0_CosReference._d_Relationship, _0_CosReference._tc_Relationship)

# Relationship object reference
class _objref_Relationship (_0_CosRelationships._objref_Relationship):
    _NP_RepositoryId = Relationship._NP_RepositoryId

    def __init__(self, obj):
        _0_CosRelationships._objref_Relationship.__init__(self, obj)

omniORB.registerObjref(Relationship._NP_RepositoryId, _objref_Relationship)
_0_CosReference._objref_Relationship = _objref_Relationship
del Relationship, _objref_Relationship

# Relationship skeleton
__name__ = "CosReference__POA"
class Relationship (_0_CosRelationships__POA.Relationship):
Esempio n. 43
0
        op_desc = (in_d, out_d, exc_d)

        def omni_dynamic_op(*args):
            return self._obj.invoke(name, op_desc, args)

        try:
            omni_dynamic_op.__name__ = "dynamic<%s>" % name
        except AttributeError:
            pass

        return omni_dynamic_op


_d_Object  = (omniORB.tcInternal.tv_objref, Object._NP_RepositoryId, "Object")
TC_Object  = _tc_Object = omniORB.tcInternal.createTypeCode(_d_Object)
omniORB.registerType(Object._NP_RepositoryId, _d_Object, _tc_Object)
omniORB.registerObjref(Object._NP_RepositoryId, Object)
other_id = "IDL:omg.org/CORBA/Object:1.0"
omniORB.registerType(other_id, _d_Object, _tc_Object)
omniORB.registerObjref(other_id, Object)
del other_id

#############################################################################
#                                                                           #
# LocalObject                                                               #
#                                                                           #
#############################################################################

class LocalObject (Object):

    _NP_RepositoryId = "IDL:omg.org/CORBA/LocalObject:1.0"
Esempio n. 44
0

# exception CompressionException
_0_Compression.CompressionException = omniORB.newEmptyClass()
class CompressionException (CORBA.UserException):
    _NP_RepositoryId = "IDL:omg.org/Compression/CompressionException:1.0"

    def __init__(self, reason, description):
        CORBA.UserException.__init__(self, reason, description)
        self.reason = reason
        self.description = description

_0_Compression.CompressionException = CompressionException
_0_Compression._d_CompressionException  = (omniORB.tcInternal.tv_except, CompressionException, CompressionException._NP_RepositoryId, "CompressionException", "reason", omniORB.tcInternal.tv_long, "description", (omniORB.tcInternal.tv_string,0))
_0_Compression._tc_CompressionException = omniORB.tcInternal.createTypeCode(_0_Compression._d_CompressionException)
omniORB.registerType(CompressionException._NP_RepositoryId, _0_Compression._d_CompressionException, _0_Compression._tc_CompressionException)
del CompressionException

# exception FactoryAlreadyRegistered
_0_Compression.FactoryAlreadyRegistered = omniORB.newEmptyClass()
class FactoryAlreadyRegistered (CORBA.UserException):
    _NP_RepositoryId = "IDL:omg.org/Compression/FactoryAlreadyRegistered:1.0"

    def __init__(self):
        CORBA.UserException.__init__(self)

_0_Compression.FactoryAlreadyRegistered = FactoryAlreadyRegistered
_0_Compression._d_FactoryAlreadyRegistered  = (omniORB.tcInternal.tv_except, FactoryAlreadyRegistered, FactoryAlreadyRegistered._NP_RepositoryId, "FactoryAlreadyRegistered")
_0_Compression._tc_FactoryAlreadyRegistered = omniORB.tcInternal.createTypeCode(_0_Compression._d_FactoryAlreadyRegistered)
omniORB.registerType(FactoryAlreadyRegistered._NP_RepositoryId, _0_Compression._d_FactoryAlreadyRegistered, _0_Compression._tc_FactoryAlreadyRegistered)
del FactoryAlreadyRegistered
Esempio n. 45
0
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")


_0_PersonIdTraits.NullTraitType = NullTraitType
_0_PersonIdTraits._d_NullTraitType = omniORB.tcInternal.tv_any
_0_PersonIdTraits._ad_NullTraitType = (
    omniORB.tcInternal.tv_alias,
    NullTraitType._NP_RepositoryId,
    "NullTraitType",
    omniORB.tcInternal.tv_any,
)
_0_PersonIdTraits._tc_NullTraitType = omniORB.tcInternal.createTypeCode(_0_PersonIdTraits._ad_NullTraitType)
omniORB.registerType(
    NullTraitType._NP_RepositoryId, _0_PersonIdTraits._ad_NullTraitType, _0_PersonIdTraits._tc_NullTraitType
)
del NullTraitType
_0_PersonIdTraits.INTERNAL_ID = "PIDS/InternalId"

# typedef ... InternalIdType
class InternalIdType:
    _NP_RepositoryId = "IDL:omg.org/PersonIdTraits/InternalIdType:1.0"

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")


_0_PersonIdTraits.InternalIdType = InternalIdType
_0_PersonIdTraits._d_InternalIdType = omniORB.typeMapping["IDL:omg.org/PersonIdService/PersonId:1.0"]
_0_PersonIdTraits._ad_InternalIdType = (
Esempio n. 46
0
_0__GlobalIDL = omniORB.openModule("_GlobalIDL", r"idl/SpreadSheet.idl")
_0__GlobalIDL__POA = omniORB.openModule("_GlobalIDL__POA", r"idl/SpreadSheet.idl")


# struct StringLine
_0__GlobalIDL.StringLine = omniORB.newEmptyClass()
class StringLine (omniORB.StructBase):
    _NP_RepositoryId = "IDL:StringLine:1.0"

    def __init__(self, value):
        self.value = value

_0__GlobalIDL.StringLine = StringLine
_0__GlobalIDL._d_StringLine  = (omniORB.tcInternal.tv_struct, StringLine, StringLine._NP_RepositoryId, "StringLine", "value", (omniORB.tcInternal.tv_sequence, (omniORB.tcInternal.tv_string,0), 0))
_0__GlobalIDL._tc_StringLine = omniORB.tcInternal.createTypeCode(_0__GlobalIDL._d_StringLine)
omniORB.registerType(StringLine._NP_RepositoryId, _0__GlobalIDL._d_StringLine, _0__GlobalIDL._tc_StringLine)
del StringLine

# typedef ... StringList
class StringList:
    _NP_RepositoryId = "IDL:StringList:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0__GlobalIDL.StringList = StringList
_0__GlobalIDL._d_StringList  = (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:StringLine:1.0"], 0)
_0__GlobalIDL._ad_StringList = (omniORB.tcInternal.tv_alias, StringList._NP_RepositoryId, "StringList", (omniORB.tcInternal.tv_sequence, omniORB.typeMapping["IDL:StringLine:1.0"], 0))
_0__GlobalIDL._tc_StringList = omniORB.tcInternal.createTypeCode(_0__GlobalIDL._ad_StringList)
omniORB.registerType(StringList._NP_RepositoryId, _0__GlobalIDL._ad_StringList, _0__GlobalIDL._tc_StringList)
del StringList

# struct ValueLine
Esempio n. 47
0
# interface TelescopeServer
_0_acstelescopeServer._d_TelescopeServer = (omniORB.tcInternal.tv_objref, "IDL:alma/acstelescopeServer/TelescopeServer:1.0", "TelescopeServer")
omniORB.typeMapping["IDL:alma/acstelescopeServer/TelescopeServer:1.0"] = _0_acstelescopeServer._d_TelescopeServer
_0_acstelescopeServer.TelescopeServer = omniORB.newEmptyClass()
class TelescopeServer (_0_ACS.CharacteristicComponent):
    _NP_RepositoryId = _0_acstelescopeServer._d_TelescopeServer[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_acstelescopeServer.TelescopeServer = TelescopeServer
_0_acstelescopeServer._tc_TelescopeServer = omniORB.tcInternal.createTypeCode(_0_acstelescopeServer._d_TelescopeServer)
omniORB.registerType(TelescopeServer._NP_RepositoryId, _0_acstelescopeServer._d_TelescopeServer, _0_acstelescopeServer._tc_TelescopeServer)

# TelescopeServer operations and attributes
TelescopeServer._d_displayMessage = ((), (), None)
TelescopeServer._d_badMethod = ((), (), {_0_ACSErrTypeCommon.UnknownEx._NP_RepositoryId: _0_ACSErrTypeCommon._d_UnknownEx})
TelescopeServer._d_startTelescope = ((), (omniORB.tcInternal.tv_double, ), None)
TelescopeServer._d_slewTelescopeNorth = ((), (omniORB.tcInternal.tv_double, ), None)
TelescopeServer._d_slewTelescopeSouth = ((), (omniORB.tcInternal.tv_double, ), None)
TelescopeServer._d_slewTelescopeWest = ((), (omniORB.tcInternal.tv_double, ), None)
TelescopeServer._d_slewTelescopeEast = ((), (omniORB.tcInternal.tv_double, ), None)
TelescopeServer._d_getAltitude = ((), (omniORB.tcInternal.tv_double, ), None)
TelescopeServer._d_getAzimuth = ((), (omniORB.tcInternal.tv_double, ), None)
TelescopeServer._d_stopSlewing = ((), (omniORB.tcInternal.tv_double, ), None)
TelescopeServer._d__get_currentPositionAlpha = ((),(omniORB.typeMapping["IDL:alma/ACS/RWdouble:1.0"],),None)
TelescopeServer._d__get_currentPositionDelta = ((),(omniORB.typeMapping["IDL:alma/ACS/RWdouble:1.0"],),None)
#
__name__ = "RTC"
_0_RTC = omniORB.openModule("RTC", r"ManipulatorCommonInterface_MiddleLevel.idl")
_0_RTC__POA = omniORB.openModule("RTC__POA", r"ManipulatorCommonInterface_MiddleLevel.idl")


# typedef ... HgMatrix
class HgMatrix:
    _NP_RepositoryId = "IDL:RTC/HgMatrix:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_RTC.HgMatrix = HgMatrix
_0_RTC._d_HgMatrix  = (omniORB.tcInternal.tv_array, (omniORB.tcInternal.tv_array, omniORB.tcInternal.tv_double, 4), 3)
_0_RTC._ad_HgMatrix = (omniORB.tcInternal.tv_alias, HgMatrix._NP_RepositoryId, "HgMatrix", (omniORB.tcInternal.tv_array, (omniORB.tcInternal.tv_array, omniORB.tcInternal.tv_double, 4), 3))
_0_RTC._tc_HgMatrix = omniORB.tcInternal.createTypeCode(_0_RTC._ad_HgMatrix)
omniORB.registerType(HgMatrix._NP_RepositoryId, _0_RTC._ad_HgMatrix, _0_RTC._tc_HgMatrix)
del HgMatrix

# struct CarPosWithElbow
_0_RTC.CarPosWithElbow = omniORB.newEmptyClass()
class CarPosWithElbow (omniORB.StructBase):
    _NP_RepositoryId = "IDL:RTC/CarPosWithElbow:1.0"

    def __init__(self, carPos, elbow, structFlag):
        self.carPos = carPos
        self.elbow = elbow
        self.structFlag = structFlag

_0_RTC.CarPosWithElbow = CarPosWithElbow
_0_RTC._d_CarPosWithElbow  = (omniORB.tcInternal.tv_struct, CarPosWithElbow, CarPosWithElbow._NP_RepositoryId, "CarPosWithElbow", "carPos", omniORB.typeMapping["IDL:RTC/HgMatrix:1.0"], "elbow", omniORB.tcInternal.tv_double, "structFlag", omniORB.typeMapping["IDL:RTC/ULONG:1.0"])
_0_RTC._tc_CarPosWithElbow = omniORB.tcInternal.createTypeCode(_0_RTC._d_CarPosWithElbow)

class EventChannelFactory(_0_CosLifeCycle.GenericFactory):
    _NP_RepositoryId = _0_EventChannelAdmin._d_EventChannelFactory[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_EventChannelAdmin.EventChannelFactory = EventChannelFactory
_0_EventChannelAdmin._tc_EventChannelFactory = omniORB.tcInternal.createTypeCode(
    _0_EventChannelAdmin._d_EventChannelFactory)
omniORB.registerType(EventChannelFactory._NP_RepositoryId,
                     _0_EventChannelAdmin._d_EventChannelFactory,
                     _0_EventChannelAdmin._tc_EventChannelFactory)


# EventChannelFactory object reference
class _objref_EventChannelFactory(_0_CosLifeCycle._objref_GenericFactory):
    _NP_RepositoryId = EventChannelFactory._NP_RepositoryId

    def __init__(self):
        _0_CosLifeCycle._objref_GenericFactory.__init__(self)

    __methods__ = [] + _0_CosLifeCycle._objref_GenericFactory.__methods__


omniORB.registerObjref(EventChannelFactory._NP_RepositoryId,
                       _objref_EventChannelFactory)
#
__name__ = "Projection"
_0_Projection = omniORB.openModule("Projection", r"geodetic_computation.idl")
_0_Projection__POA = omniORB.openModule("Projection__POA", r"geodetic_computation.idl")


# typedef ... latitude
class latitude:
    _NP_RepositoryId = "IDL:Projection/latitude:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_Projection.latitude = latitude
_0_Projection._d_latitude  = omniORB.tcInternal.tv_float
_0_Projection._ad_latitude = (omniORB.tcInternal.tv_alias, latitude._NP_RepositoryId, "latitude", omniORB.tcInternal.tv_float)
_0_Projection._tc_latitude = omniORB.tcInternal.createTypeCode(_0_Projection._ad_latitude)
omniORB.registerType(latitude._NP_RepositoryId, _0_Projection._ad_latitude, _0_Projection._tc_latitude)
del latitude

# typedef ... longitude
class longitude:
    _NP_RepositoryId = "IDL:Projection/longitude:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_Projection.longitude = longitude
_0_Projection._d_longitude  = omniORB.tcInternal.tv_float
_0_Projection._ad_longitude = (omniORB.tcInternal.tv_alias, longitude._NP_RepositoryId, "longitude", omniORB.tcInternal.tv_float)
_0_Projection._tc_longitude = omniORB.tcInternal.createTypeCode(_0_Projection._ad_longitude)
omniORB.registerType(longitude._NP_RepositoryId, _0_Projection._ad_longitude, _0_Projection._tc_longitude)
del longitude

# typedef ... azimuth
#
__name__ = "JARA_ARM"
_0_JARA_ARM = omniORB.openModule("JARA_ARM", r"idl/ManipulatorCommonInterface_DataTypes.idl")
_0_JARA_ARM__POA = omniORB.openModule("JARA_ARM__POA", r"idl/ManipulatorCommonInterface_DataTypes.idl")


# typedef ... DoubleSeq
class DoubleSeq:
    _NP_RepositoryId = "IDL:JARA_ARM/DoubleSeq:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_JARA_ARM.DoubleSeq = DoubleSeq
_0_JARA_ARM._d_DoubleSeq  = (omniORB.tcInternal.tv_sequence, omniORB.tcInternal.tv_double, 0)
_0_JARA_ARM._ad_DoubleSeq = (omniORB.tcInternal.tv_alias, DoubleSeq._NP_RepositoryId, "DoubleSeq", (omniORB.tcInternal.tv_sequence, omniORB.tcInternal.tv_double, 0))
_0_JARA_ARM._tc_DoubleSeq = omniORB.tcInternal.createTypeCode(_0_JARA_ARM._ad_DoubleSeq)
omniORB.registerType(DoubleSeq._NP_RepositoryId, _0_JARA_ARM._ad_DoubleSeq, _0_JARA_ARM._tc_DoubleSeq)
del DoubleSeq

# typedef ... JointPos
class JointPos:
    _NP_RepositoryId = "IDL:JARA_ARM/JointPos:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_JARA_ARM.JointPos = JointPos
_0_JARA_ARM._d_JointPos  = (omniORB.tcInternal.tv_sequence, omniORB.tcInternal.tv_double, 0)
_0_JARA_ARM._ad_JointPos = (omniORB.tcInternal.tv_alias, JointPos._NP_RepositoryId, "JointPos", (omniORB.tcInternal.tv_sequence, omniORB.tcInternal.tv_double, 0))
_0_JARA_ARM._tc_JointPos = omniORB.tcInternal.createTypeCode(_0_JARA_ARM._ad_JointPos)
omniORB.registerType(JointPos._NP_RepositoryId, _0_JARA_ARM._ad_JointPos, _0_JARA_ARM._tc_JointPos)
del JointPos

# struct LimitValue
Esempio n. 52
0
# interface Service
_0__GlobalIdl._d_Service = (omniORB.tcInternal.tv_objref, "IDL:Service:1.0", "Service")
omniORB.typeMapping["IDL:Service:1.0"] = _0__GlobalIdl._d_Service
_0__GlobalIdl.Service = omniORB.newEmptyClass()
class Service :
    _NP_RepositoryId = _0__GlobalIdl._d_Service[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0__GlobalIdl.Service = Service
_0__GlobalIdl._tc_Service = omniORB.tcInternal.createTypeCode(_0__GlobalIdl._d_Service)
omniORB.registerType(Service._NP_RepositoryId, _0__GlobalIdl._d_Service, _0__GlobalIdl._tc_Service)

# Service operations and attributes
Service._d_ping = ((), (), None)
Service._d_hello = (((omniORB.tcInternal.tv_string,0), ), ((omniORB.tcInternal.tv_string,0), ), None)

# Service object reference
class _objref_Service (CORBA.Object):
    _NP_RepositoryId = Service._NP_RepositoryId

    def __init__(self, obj):
        CORBA.Object.__init__(self, obj)

    def ping(self, *args):
        return self._obj.invoke("ping", _0__GlobalIdl.Service._d_ping, args)
Esempio n. 53
0
# interface Test1
_0_RTR._d_Test1 = (omniORB.tcInternal.tv_objref, "IDL:RTR/Test1:1.0", "Test1")
omniORB.typeMapping["IDL:RTR/Test1:1.0"] = _0_RTR._d_Test1
_0_RTR.Test1 = omniORB.newEmptyClass()
class Test1 :
    _NP_RepositoryId = _0_RTR._d_Test1[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_RTR.Test1 = Test1
_0_RTR._tc_Test1 = omniORB.tcInternal.createTypeCode(_0_RTR._d_Test1)
omniORB.registerType(Test1._NP_RepositoryId, _0_RTR._d_Test1, _0_RTR._tc_Test1)

# Test1 operations and attributes
Test1._d_hoge = ((omniORB.tcInternal.tv_double, ), (omniORB.tcInternal.tv_double, ), None)

# Test1 object reference
class _objref_Test1 (CORBA.Object):
    _NP_RepositoryId = Test1._NP_RepositoryId

    def __init__(self):
        CORBA.Object.__init__(self)

    def hoge(self, *args):
        return _omnipy.invoke(self, "hoge", _0_RTR.Test1._d_hoge, args)

    __methods__ = ["hoge"] + CORBA.Object.__methods__
# Start of module "RTC"
#
__name__ = "RTC"
_0_RTC = omniORB.openModule("RTC", r"idl\ManipulatorCommonInterface_Common.idl")
_0_RTC__POA = omniORB.openModule("RTC__POA", r"idl\ManipulatorCommonInterface_Common.idl")


# enum AlarmType
_0_RTC.FAULT = omniORB.EnumItem("FAULT", 0)
_0_RTC.WARNING = omniORB.EnumItem("WARNING", 1)
_0_RTC.UNKNOWN = omniORB.EnumItem("UNKNOWN", 2)
_0_RTC.AlarmType = omniORB.Enum("IDL:RTC/AlarmType:1.0", (_0_RTC.FAULT, _0_RTC.WARNING, _0_RTC.UNKNOWN,))

_0_RTC._d_AlarmType  = (omniORB.tcInternal.tv_enum, _0_RTC.AlarmType._NP_RepositoryId, "AlarmType", _0_RTC.AlarmType._items)
_0_RTC._tc_AlarmType = omniORB.tcInternal.createTypeCode(_0_RTC._d_AlarmType)
omniORB.registerType(_0_RTC.AlarmType._NP_RepositoryId, _0_RTC._d_AlarmType, _0_RTC._tc_AlarmType)

# struct Alarm
_0_RTC.Alarm = omniORB.newEmptyClass()
class Alarm (omniORB.StructBase):
    _NP_RepositoryId = "IDL:RTC/Alarm:1.0"

    def __init__(self, code, type, description):
        self.code = code
        self.type = type
        self.description = description

_0_RTC.Alarm = Alarm
_0_RTC._d_Alarm  = (omniORB.tcInternal.tv_struct, Alarm, Alarm._NP_RepositoryId, "Alarm", "code", omniORB.tcInternal.tv_ulong, "type", omniORB.typeMapping["IDL:RTC/AlarmType:1.0"], "description", (omniORB.tcInternal.tv_string,0))
_0_RTC._tc_Alarm = omniORB.tcInternal.createTypeCode(_0_RTC._d_Alarm)
omniORB.registerType(Alarm._NP_RepositoryId, _0_RTC._d_Alarm, _0_RTC._tc_Alarm)
Esempio n. 55
0
        omniORB.tcInternal.tv_except, DuplicateServiceTypeName,
        DuplicateServiceTypeName._NP_RepositoryId, "DuplicateServiceTypeName",
        "name",
        omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"])
    _tc_DuplicateServiceTypeName = omniORB.tcInternal.createTypeCode(
        _d_DuplicateServiceTypeName)
    omniORB.registerType(DuplicateServiceTypeName._NP_RepositoryId,
                         _d_DuplicateServiceTypeName,
                         _tc_DuplicateServiceTypeName)


_0_CosTradingRepos.ServiceTypeRepository = ServiceTypeRepository
_0_CosTradingRepos._tc_ServiceTypeRepository = omniORB.tcInternal.createTypeCode(
    _0_CosTradingRepos._d_ServiceTypeRepository)
omniORB.registerType(ServiceTypeRepository._NP_RepositoryId,
                     _0_CosTradingRepos._d_ServiceTypeRepository,
                     _0_CosTradingRepos._tc_ServiceTypeRepository)

# ServiceTypeRepository operations and attributes
ServiceTypeRepository._d__get_incarnation = ((), (omniORB.typeMapping[
    "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/IncarnationNumber:1.0"],
                                                  ), None)
ServiceTypeRepository._d_add_type = ((
    omniORB.typeMapping["IDL:omg.org/CosTrading/ServiceTypeName:1.0"],
    omniORB.typeMapping[
        "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/Identifier:1.0"],
    omniORB.typeMapping[
        "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/PropStructSeq:1.0"],
    omniORB.typeMapping[
        "IDL:omg.org/CosTradingRepos/ServiceTypeRepository/ServiceTypeNameSeq:1.0"]
), (
Esempio n. 56
0
#
__name__ = "CosNotifyFilter"
_0_CosNotifyFilter = omniORB.openModule("CosNotifyFilter", r"/usr/local/share/idl/omniORB/COS/CosNotifyFilter.idl")
_0_CosNotifyFilter__POA = omniORB.openModule("CosNotifyFilter__POA", r"/usr/local/share/idl/omniORB/COS/CosNotifyFilter.idl")


# typedef ... ConstraintID
class ConstraintID:
    _NP_RepositoryId = "IDL:omg.org/CosNotifyFilter/ConstraintID:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_CosNotifyFilter.ConstraintID = ConstraintID
_0_CosNotifyFilter._d_ConstraintID  = omniORB.tcInternal.tv_long
_0_CosNotifyFilter._ad_ConstraintID = (omniORB.tcInternal.tv_alias, ConstraintID._NP_RepositoryId, "ConstraintID", omniORB.tcInternal.tv_long)
_0_CosNotifyFilter._tc_ConstraintID = omniORB.tcInternal.createTypeCode(_0_CosNotifyFilter._ad_ConstraintID)
omniORB.registerType(ConstraintID._NP_RepositoryId, _0_CosNotifyFilter._ad_ConstraintID, _0_CosNotifyFilter._tc_ConstraintID)
del ConstraintID

# struct ConstraintExp
_0_CosNotifyFilter.ConstraintExp = omniORB.newEmptyClass()
class ConstraintExp (omniORB.StructBase):
    _NP_RepositoryId = "IDL:omg.org/CosNotifyFilter/ConstraintExp:1.0"

    def __init__(self, event_types, constraint_expr):
        self.event_types = event_types
        self.constraint_expr = constraint_expr

_0_CosNotifyFilter.ConstraintExp = ConstraintExp
_0_CosNotifyFilter._d_ConstraintExp  = (omniORB.tcInternal.tv_struct, ConstraintExp, ConstraintExp._NP_RepositoryId, "ConstraintExp", "event_types", omniORB.typeMapping["IDL:omg.org/CosNotification/EventTypeSeq:1.0"], "constraint_expr", (omniORB.tcInternal.tv_string,0))
_0_CosNotifyFilter._tc_ConstraintExp = omniORB.tcInternal.createTypeCode(_0_CosNotifyFilter._d_ConstraintExp)
omniORB.registerType(ConstraintExp._NP_RepositoryId, _0_CosNotifyFilter._d_ConstraintExp, _0_CosNotifyFilter._tc_ConstraintExp)
Esempio n. 57
0
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")


_0_hpp.constraints_idl.Implicits = Implicits
_0_hpp.constraints_idl._d_Implicits = (
    omniORB.tcInternal.tv_sequence,
    omniORB.typeMapping["IDL:hpp/constraints_idl/Implicit:1.0"], 0)
_0_hpp.constraints_idl._ad_Implicits = (
    omniORB.tcInternal.tv_alias, Implicits._NP_RepositoryId, "Implicits",
    (omniORB.tcInternal.tv_sequence,
     omniORB.typeMapping["IDL:hpp/constraints_idl/Implicit:1.0"], 0))
_0_hpp.constraints_idl._tc_Implicits = omniORB.tcInternal.createTypeCode(
    _0_hpp.constraints_idl._ad_Implicits)
omniORB.registerType(Implicits._NP_RepositoryId,
                     _0_hpp.constraints_idl._ad_Implicits,
                     _0_hpp.constraints_idl._tc_Implicits)
del Implicits

# interface LockedJoint;
_0_hpp.constraints_idl._d_LockedJoint = (
    omniORB.tcInternal.tv_objref, "IDL:hpp/constraints_idl/LockedJoint:1.0",
    "LockedJoint")
omniORB.typeMapping[
    "IDL:hpp/constraints_idl/LockedJoint:1.0"] = _0_hpp.constraints_idl._d_LockedJoint


# typedef ... LockedJoints
class LockedJoints:
    _NP_RepositoryId = "IDL:hpp/constraints_idl/LockedJoints:1.0"
Esempio n. 58
0
class EMS_T (omniORB.StructBase):
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/emsMgr/EMS_T:1.0"

    def __init__(self, name, userLabel, nativeEMSName, owner, emsVersion, type, additionalInfo):
        self.name = name
        self.userLabel = userLabel
        self.nativeEMSName = nativeEMSName
        self.owner = owner
        self.emsVersion = emsVersion
        self.type = type
        self.additionalInfo = additionalInfo

_0_emsMgr.EMS_T = EMS_T
_0_emsMgr._d_EMS_T  = (omniORB.tcInternal.tv_struct, EMS_T, EMS_T._NP_RepositoryId, "EMS_T", "name", omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/NamingAttributes_T:1.0"], "userLabel", (omniORB.tcInternal.tv_string,0), "nativeEMSName", (omniORB.tcInternal.tv_string,0), "owner", (omniORB.tcInternal.tv_string,0), "emsVersion", (omniORB.tcInternal.tv_string,0), "type", (omniORB.tcInternal.tv_string,0), "additionalInfo", omniORB.typeMapping["IDL:mtnm.tmforum.org/globaldefs/NVSList_T:1.0"])
_0_emsMgr._tc_EMS_T = omniORB.tcInternal.createTypeCode(_0_emsMgr._d_EMS_T)
omniORB.registerType(EMS_T._NP_RepositoryId, _0_emsMgr._d_EMS_T, _0_emsMgr._tc_EMS_T)
del EMS_T

# typedef ... AlarmSerialNoList_T
class AlarmSerialNoList_T:
    _NP_RepositoryId = "IDL:mtnm.tmforum.org/emsMgr/AlarmSerialNoList_T:1.0"
    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")
_0_emsMgr.AlarmSerialNoList_T = AlarmSerialNoList_T
_0_emsMgr._d_AlarmSerialNoList_T  = (omniORB.tcInternal.tv_sequence, (omniORB.tcInternal.tv_string,0), 0)
_0_emsMgr._ad_AlarmSerialNoList_T = (omniORB.tcInternal.tv_alias, AlarmSerialNoList_T._NP_RepositoryId, "AlarmSerialNoList_T", (omniORB.tcInternal.tv_sequence, (omniORB.tcInternal.tv_string,0), 0))
_0_emsMgr._tc_AlarmSerialNoList_T = omniORB.tcInternal.createTypeCode(_0_emsMgr._ad_AlarmSerialNoList_T)
omniORB.registerType(AlarmSerialNoList_T._NP_RepositoryId, _0_emsMgr._ad_AlarmSerialNoList_T, _0_emsMgr._tc_AlarmSerialNoList_T)
del AlarmSerialNoList_T

# struct ClockSourceStatus_T
# interface RemoteNavSubject
_0_vrj._d_RemoteNavSubject = (omniORB.tcInternal.tv_objref, "IDL:vrj/RemoteNavSubject:1.0", "RemoteNavSubject")
omniORB.typeMapping["IDL:vrj/RemoteNavSubject:1.0"] = _0_vrj._d_RemoteNavSubject
_0_vrj.RemoteNavSubject = omniORB.newEmptyClass()
class RemoteNavSubject (_0_tweek.Subject):
    _NP_RepositoryId = _0_vrj._d_RemoteNavSubject[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_vrj.RemoteNavSubject = RemoteNavSubject
_0_vrj._tc_RemoteNavSubject = omniORB.tcInternal.createTypeCode(_0_vrj._d_RemoteNavSubject)
omniORB.registerType(RemoteNavSubject._NP_RepositoryId, _0_vrj._d_RemoteNavSubject, _0_vrj._tc_RemoteNavSubject)

# RemoteNavSubject operations and attributes
RemoteNavSubject._d_setPosition = ((omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float), (), None)
RemoteNavSubject._d_getPosition = ((), (omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float), None)
RemoteNavSubject._d_getOrientation = ((), (omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float), None)
RemoteNavSubject._d_setOrientation = ((omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float), (), None)
RemoteNavSubject._d_setVelocity = ((omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float), (), None)
RemoteNavSubject._d_setRotationalVelocity = ((omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float, omniORB.tcInternal.tv_float), (), None)
RemoteNavSubject._d_setWalkMode = ((omniORB.tcInternal.tv_boolean, ), (), None)

# RemoteNavSubject object reference
class _objref_RemoteNavSubject (_0_tweek._objref_Subject):
    _NP_RepositoryId = RemoteNavSubject._NP_RepositoryId

    def __init__(self):
Esempio n. 60
0
omniORB.typeMapping["IDL:Example/Echo:1.0"] = _0_Example._d_Echo
_0_Example.Echo = omniORB.newEmptyClass()


class Echo:
    _NP_RepositoryId = _0_Example._d_Echo[1]

    def __init__(self, *args, **kw):
        raise RuntimeError("Cannot construct objects of this type.")

    _nil = CORBA.Object._nil


_0_Example.Echo = Echo
_0_Example._tc_Echo = omniORB.tcInternal.createTypeCode(_0_Example._d_Echo)
omniORB.registerType(Echo._NP_RepositoryId, _0_Example._d_Echo, _0_Example._tc_Echo)

# Echo operations and attributes
Echo._d_echoString = (((omniORB.tcInternal.tv_string, 0),), ((omniORB.tcInternal.tv_string, 0),), None)

# Echo object reference
class _objref_Echo(CORBA.Object):
    _NP_RepositoryId = Echo._NP_RepositoryId

    def __init__(self):
        CORBA.Object.__init__(self)

    def echoString(self, *args):
        return _omnipy.invoke(self, "echoString", _0_Example.Echo._d_echoString, args)

    __methods__ = ["echoString"] + CORBA.Object.__methods__