# Stubs for "CosPropertyService"
#
# This file was automatically generated with ILU (version 2.0alpha8) tools
# at Mon Aug 26 09:59:52 1996 by `'
# running "/usr/local/ilu20a8/bin/python-stubber" of Mon Aug 26 09:58:20 1996
# on "/coho/0/hassan/dldev/src/COS/ICosProperty/CosPropertyService.isl" of Mon Aug 12 12:34:40 1996,
# and "/usr/local/ilu20a8/interfaces/ilu.isl" of Tue Jul 30 16:05:50 1996.
#
# ILU is Copyright 1991-1996 Xerox Corporation, All Rights Reserved.
# ILU information:  ftp://ftp.parc.xerox.com/pub/ilu/ilu.html.

_imported_modules = {};
import iluRt

ConstraintNotSupported = 'ilu:CosPropertyService.ConstraintNotSupported'
InvalidPropertyName = 'ilu:CosPropertyService.InvalidPropertyName'
ConflictingProperty = 'ilu:CosPropertyService.ConflictingProperty'
PropertyNotFound = 'ilu:CosPropertyService.PropertyNotFound'
UnsupportedTypeCode = 'ilu:CosPropertyService.UnsupportedTypeCode'
UnsupportedProperty = 'ilu:CosPropertyService.UnsupportedProperty'
UnsupportedMode = 'ilu:CosPropertyService.UnsupportedMode'
FixedProperty = 'ilu:CosPropertyService.FixedProperty'
ReadOnlyProperty = 'ilu:CosPropertyService.ReadOnlyProperty'
MultipleExceptions = 'ilu:CosPropertyService.MultipleExceptions'

class PropertiesIterator(iluRt.IluObjSurr):
    _IluClass = iluRt.FormClassRecord(\
	'CosPropertyService.PropertiesIterator',\
	'',\
	'ilu:d8p5qs9qvcHEB5eRpch5NTaTBDg',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('reset', 1, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('next-one', 2, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('next-n', 3, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('destroy', 4, iluRt.FALSE, iluRt.FALSE, ()),\
	),\
	()\
	)

    def reset(_self):
	_call = iluRt.BeginCall(_self, PropertiesIterator._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertiesIterator))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertiesIterator)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertiesIterator._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def next_one(_self):
	_result = None
	_call = iluRt.BeginCall(_self, PropertiesIterator._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertiesIterator))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertiesIterator)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertiesIterator._IluClass, _ecode)
	    _result = iluRt.InputBoolean(_call),\
	      _Input_Property(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def next_n(_self, how_many):
	_result = None
	_call = iluRt.BeginCall(_self, PropertiesIterator._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertiesIterator)\
	      + iluRt.SizeOfCardinal(_call, how_many))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertiesIterator)
	    iluRt.OutputCardinal(_call, how_many)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertiesIterator._IluClass, _ecode)
	    _result = iluRt.InputBoolean(_call),\
	      _Input_Properties(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def destroy(_self):
	_call = iluRt.BeginCall(_self, PropertiesIterator._IluClass, 4)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertiesIterator))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertiesIterator)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertiesIterator._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

iluRt.RegisterClass(PropertiesIterator)

class PropertyNamesIterator(iluRt.IluObjSurr):
    _IluClass = iluRt.FormClassRecord(\
	'CosPropertyService.PropertyNamesIterator',\
	'',\
	'ilu:lEdekYBP0ICBdN2gnewyvORwUW8',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('reset', 1, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('next-one', 2, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('next-n', 3, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('destroy', 4, iluRt.FALSE, iluRt.FALSE, ()),\
	),\
	()\
	)

    def reset(_self):
	_call = iluRt.BeginCall(_self, PropertyNamesIterator._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertyNamesIterator))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertyNamesIterator)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertyNamesIterator._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def next_one(_self):
	_result = None
	_call = iluRt.BeginCall(_self, PropertyNamesIterator._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertyNamesIterator))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertyNamesIterator)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertyNamesIterator._IluClass, _ecode)
	    _result = iluRt.InputBoolean(_call),\
	      iluRt.InputString(_call, 0)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def next_n(_self, how_many):
	_result = None
	_call = iluRt.BeginCall(_self, PropertyNamesIterator._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertyNamesIterator)\
	      + iluRt.SizeOfCardinal(_call, how_many))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertyNamesIterator)
	    iluRt.OutputCardinal(_call, how_many)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertyNamesIterator._IluClass, _ecode)
	    _result = iluRt.InputBoolean(_call),\
	      _Input_PropertyNames(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def destroy(_self):
	_call = iluRt.BeginCall(_self, PropertyNamesIterator._IluClass, 4)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertyNamesIterator))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertyNamesIterator)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertyNamesIterator._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

iluRt.RegisterClass(PropertyNamesIterator)

class PropertySetDefFactory(iluRt.IluObjSurr):
    _IluClass = iluRt.FormClassRecord(\
	'CosPropertyService.PropertySetDefFactory',\
	'',\
	'ilu:c8Dy2pdpYfBfmJ92ekcRHMxEZ2v',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('create-propertysetdef', 1, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('create-constrained-propertysetdef', 2, iluRt.FALSE, iluRt.FALSE, (ConstraintNotSupported,)),\
	    ('create-initial-propertysetdef', 3, iluRt.FALSE, iluRt.FALSE, (MultipleExceptions,)),\
	),\
	()\
	)

    def create_propertysetdef(_self):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetDefFactory._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDefFactory))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDefFactory)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDefFactory._IluClass, _ecode)
	    _result = iluRt.InputObjectID(_call, iluRt.FALSE, PropertySetDef)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def create_constrained_propertysetdef(_self, allowed_property_types, allowed_property_defs):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetDefFactory._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDefFactory)\
	      + _SizeOf_PropertyTypes(_call, allowed_property_types)\
	      + _SizeOf_PropertyDefs(_call, allowed_property_defs))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDefFactory)
	    _Output_PropertyTypes(_call, allowed_property_types)
	    _Output_PropertyDefs(_call, allowed_property_defs)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDefFactory._IluClass, _ecode)
	    _result = iluRt.InputObjectID(_call, iluRt.FALSE, PropertySetDef)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def create_initial_propertysetdef(_self, initial_property_defs):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetDefFactory._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDefFactory)\
	      + _SizeOf_PropertyDefs(_call, initial_property_defs))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDefFactory)
	    _Output_PropertyDefs(_call, initial_property_defs)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDefFactory._IluClass, _ecode)
	    _result = iluRt.InputObjectID(_call, iluRt.FALSE, PropertySetDef)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

iluRt.RegisterClass(PropertySetDefFactory)

class PropertySet(iluRt.IluObjSurr):
    _IluClass = iluRt.FormClassRecord(\
	'CosPropertyService.PropertySet',\
	'',\
	'ilu:eb0+qUv+DgNAQ73VDZb33mDCrxh',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('define-property', 1, iluRt.FALSE, iluRt.FALSE, (InvalidPropertyName, ConflictingProperty, UnsupportedTypeCode, UnsupportedProperty, ReadOnlyProperty)),\
	    ('define-properties', 2, iluRt.FALSE, iluRt.FALSE, (MultipleExceptions,)),\
	    ('get-number-of-properties', 3, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('get-all-property-names', 4, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('get-property-value', 5, iluRt.FALSE, iluRt.FALSE, (PropertyNotFound, InvalidPropertyName)),\
	    ('get-properties', 6, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('get-all-properties', 7, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('delete-property', 8, iluRt.FALSE, iluRt.FALSE, (PropertyNotFound, InvalidPropertyName, FixedProperty)),\
	    ('delete-properties', 9, iluRt.FALSE, iluRt.FALSE, (MultipleExceptions,)),\
	    ('delete-all-properties', 10, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('is-property-defined', 11, iluRt.FALSE, iluRt.FALSE, (InvalidPropertyName,)),\
	),\
	()\
	)

    def define_property(_self, property_name, property_value):
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet)\
	      + iluRt.SizeOfString(_call, property_name, 0)\
	      + _SizeOf_Any(_call, property_value))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    iluRt.OutputString(_call, property_name, 0)
	    _Output_Any(_call, property_value)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def define_properties(_self, nproperties):
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet)\
	      + _SizeOf_Properties(_call, nproperties))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    _Output_Properties(_call, nproperties)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def get_number_of_properties(_self):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    _result = iluRt.InputCardinal(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def get_all_property_names(_self, how_many):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 4)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet)\
	      + iluRt.SizeOfCardinal(_call, how_many))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    iluRt.OutputCardinal(_call, how_many)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    _result = _Input_PropertyNames(_call),\
	      iluRt.InputObjectID(_call, iluRt.FALSE, PropertyNamesIterator)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def get_property_value(_self, property_name):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 5)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet)\
	      + iluRt.SizeOfString(_call, property_name, 0))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    iluRt.OutputString(_call, property_name, 0)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    _result = _Input_Any(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def get_properties(_self, property_names):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 6)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet)\
	      + _SizeOf_PropertyNames(_call, property_names))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    _Output_PropertyNames(_call, property_names)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    _result = iluRt.InputBoolean(_call),\
	      _Input_Properties(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def get_all_properties(_self, how_many):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 7)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet)\
	      + iluRt.SizeOfCardinal(_call, how_many))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    iluRt.OutputCardinal(_call, how_many)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    _result = _Input_Properties(_call),\
	      iluRt.InputObjectID(_call, iluRt.FALSE, PropertiesIterator)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def delete_property(_self, property_name):
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 8)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet)\
	      + iluRt.SizeOfString(_call, property_name, 0))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    iluRt.OutputString(_call, property_name, 0)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def delete_properties(_self, property_names):
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 9)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet)\
	      + _SizeOf_PropertyNames(_call, property_names))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    _Output_PropertyNames(_call, property_names)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def delete_all_properties(_self):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 10)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    _result = iluRt.InputBoolean(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def is_property_defined(_self, property_name):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySet._IluClass, 11)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySet)\
	      + iluRt.SizeOfString(_call, property_name, 0))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySet)
	    iluRt.OutputString(_call, property_name, 0)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySet._IluClass, _ecode)
	    _result = iluRt.InputBoolean(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

iluRt.RegisterClass(PropertySet)

class PropertySetDef(PropertySet):
    _IluClass = iluRt.FormClassRecord(\
	'CosPropertyService.PropertySetDef',\
	'',\
	'ilu:mw4uDTurspg+XLw5VGw3bD78EN2',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('get-allowed-property-types', 1, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('get-allowed-properties', 2, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('define-property-with-mode', 3, iluRt.FALSE, iluRt.FALSE, (InvalidPropertyName, ConflictingProperty, UnsupportedTypeCode, UnsupportedProperty, UnsupportedMode, ReadOnlyProperty)),\
	    ('define-properties-with-modes', 4, iluRt.FALSE, iluRt.FALSE, (MultipleExceptions,)),\
	    ('get-property-mode', 5, iluRt.FALSE, iluRt.FALSE, (PropertyNotFound, InvalidPropertyName)),\
	    ('get-property-modes', 6, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('set-property-mode', 7, iluRt.FALSE, iluRt.FALSE, (InvalidPropertyName, PropertyNotFound, UnsupportedMode)),\
	    ('set-property-modes', 8, iluRt.FALSE, iluRt.FALSE, (MultipleExceptions,)),\
	),\
	(PropertySet._IluClass,)\
	)

    def get_allowed_property_types(_self):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetDef._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDef))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDef)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDef._IluClass, _ecode)
	    _result = _Input_PropertyTypes(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def get_allowed_properties(_self):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetDef._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDef))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDef)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDef._IluClass, _ecode)
	    _result = _Input_PropertyDefs(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def define_property_with_mode(_self, property_name, property_value, property_mode):
	_call = iluRt.BeginCall(_self, PropertySetDef._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDef)\
	      + iluRt.SizeOfString(_call, property_name, 0)\
	      + _SizeOf_Any(_call, property_value)\
	      + iluRt.SizeOfEnum(_call, property_mode))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDef)
	    iluRt.OutputString(_call, property_name, 0)
	    _Output_Any(_call, property_value)
	    iluRt.OutputEnum(_call, property_mode)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDef._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def define_properties_with_modes(_self, property_defs):
	_call = iluRt.BeginCall(_self, PropertySetDef._IluClass, 4)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDef)\
	      + _SizeOf_PropertyDefs(_call, property_defs))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDef)
	    _Output_PropertyDefs(_call, property_defs)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDef._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def get_property_mode(_self, property_name):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetDef._IluClass, 5)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDef)\
	      + iluRt.SizeOfString(_call, property_name, 0))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDef)
	    iluRt.OutputString(_call, property_name, 0)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDef._IluClass, _ecode)
	    _result = iluRt.InputEnum(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def get_property_modes(_self, property_names):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetDef._IluClass, 6)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDef)\
	      + _SizeOf_PropertyNames(_call, property_names))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDef)
	    _Output_PropertyNames(_call, property_names)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDef._IluClass, _ecode)
	    _result = iluRt.InputBoolean(_call),\
	      _Input_PropertyModes(_call)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def set_property_mode(_self, property_name, property_mode):
	_call = iluRt.BeginCall(_self, PropertySetDef._IluClass, 7)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDef)\
	      + iluRt.SizeOfString(_call, property_name, 0)\
	      + iluRt.SizeOfEnum(_call, property_mode))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDef)
	    iluRt.OutputString(_call, property_name, 0)
	    iluRt.OutputEnum(_call, property_mode)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDef._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

    def set_property_modes(_self, property_modes):
	_call = iluRt.BeginCall(_self, PropertySetDef._IluClass, 8)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetDef)\
	      + _SizeOf_PropertyModes(_call, property_modes))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetDef)
	    _Output_PropertyModes(_call, property_modes)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetDef._IluClass, _ecode)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)

iluRt.RegisterClass(PropertySetDef)

class PropertySetFactory(iluRt.IluObjSurr):
    _IluClass = iluRt.FormClassRecord(\
	'CosPropertyService.PropertySetFactory',\
	'',\
	'ilu:pQUyviZZ4YCowHk1pOWXbrAbL6E',\
	None,\
	iluRt.FALSE,\
	iluRt.TRUE,\
	None,\
	(\
	    ('create-propertyset', 1, iluRt.FALSE, iluRt.FALSE, ()),\
	    ('create-constrained-propertyset', 2, iluRt.FALSE, iluRt.FALSE, (ConstraintNotSupported,)),\
	    ('create-initial-propertyset', 3, iluRt.FALSE, iluRt.FALSE, (MultipleExceptions,)),\
	),\
	()\
	)

    def create_propertyset(_self):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetFactory._IluClass, 1)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetFactory))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetFactory)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetFactory._IluClass, _ecode)
	    _result = iluRt.InputObjectID(_call, iluRt.FALSE, PropertySet)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def create_constrained_propertyset(_self, allowed_property_types, allowed_properties):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetFactory._IluClass, 2)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetFactory)\
	      + _SizeOf_PropertyTypes(_call, allowed_property_types)\
	      + _SizeOf_Properties(_call, allowed_properties))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetFactory)
	    _Output_PropertyTypes(_call, allowed_property_types)
	    _Output_Properties(_call, allowed_properties)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetFactory._IluClass, _ecode)
	    _result = iluRt.InputObjectID(_call, iluRt.FALSE, PropertySet)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

    def create_initial_propertyset(_self, initial_properties):
	_result = None
	_call = iluRt.BeginCall(_self, PropertySetFactory._IluClass, 3)
	try:
	    iluRt.BeginRequest(_call,\
	      iluRt.SizeOfObjectID(_call, _self, iluRt.TRUE, PropertySetFactory)\
	      + _SizeOf_Properties(_call, initial_properties))
	    iluRt.OutputObjectID(_call, _self, iluRt.TRUE, PropertySetFactory)
	    _Output_Properties(_call, initial_properties)
	    iluRt.FinishRequest(_call)
	    _ecode = iluRt.GetReply(_call)
	    if _ecode != 0:
		_CatchException(_call, PropertySetFactory._IluClass, _ecode)
	    _result = iluRt.InputObjectID(_call, iluRt.FALSE, PropertySet)
	    iluRt.ReplyRead(_call)
	finally:
	    iluRt.FinishCall(_call)
	return _result

iluRt.RegisterClass(PropertySetFactory)

class R_MultipleExceptions (iluRt.IluRecord):
    __ilu_type_name__ = 'CosPropertyService.R-MultipleExceptions'
    def __init__(self, _exceptions):
        self.exceptions = _exceptions;

    def __getinitargs__(self):
      return (self.exceptions, )

def _Input_R_MultipleExceptions(_call):
    iluRt.InputRecord(_call)
    _value = R_MultipleExceptions (None)
    _value.exceptions = _Input_PropertyExceptions(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_R_MultipleExceptions(_call, _value):
    iluRt.OutputRecord(_call)
    _Output_PropertyExceptions(_call, _value['exceptions'])
    iluRt.EndRecord(_call)

def _SizeOf_R_MultipleExceptions(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + _SizeOf_PropertyExceptions(_call, _value['exceptions'])
    iluRt.EndRecord(_call)
    return _size

def _Input_PropertyExceptions(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_PropertyException(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_PropertyExceptions(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_PropertyException(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_PropertyExceptions(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_PropertyException(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

class PropertyException (iluRt.IluRecord):
    __ilu_type_name__ = 'CosPropertyService.PropertyException'
    def __init__(self, _reason, _failing_property_name):
        self.reason = _reason;
        self.failing_property_name = _failing_property_name;

    def __getinitargs__(self):
      return (self.reason, self.failing_property_name, )

def _Input_PropertyException(_call):
    iluRt.InputRecord(_call)
    _value = PropertyException (None, None)
    _value.reason = iluRt.InputEnum(_call)
    _value.failing_property_name = iluRt.InputString(_call, 0)
    iluRt.EndRecord(_call)
    return _value

def _Output_PropertyException(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputEnum(_call, _value['reason'])
    iluRt.OutputString(_call, _value['failing_property_name'], 0)
    iluRt.EndRecord(_call)

def _SizeOf_PropertyException(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfEnum(_call, _value['reason'])\
      + iluRt.SizeOfString(_call, _value['failing_property_name'], 0)
    iluRt.EndRecord(_call)
    return _size

class ExceptionReason:
    invalid_property_name = 0;
    conflicting_property = 1;
    property_not_found = 2;
    unsupported_type_code = 3;
    unsupported_property = 4;
    unsupported_mode = 5;
    fixed_property = 6;
    read_only_property = 7;
    __image__ = {
          invalid_property_name : 'invalid_property_name',
          conflicting_property : 'conflicting_property',
          property_not_found : 'property_not_found',
          unsupported_type_code : 'unsupported_type_code',
          unsupported_property : 'unsupported_property',
          unsupported_mode : 'unsupported_mode',
          fixed_property : 'fixed_property',
          read_only_property : 'read_only_property'}

def _Input_PropertyTypes(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(iluRt.InputEnum(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_PropertyTypes(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        iluRt.OutputEnum(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_PropertyTypes(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + iluRt.SizeOfEnum(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_PropertyModes(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_PropertyMode(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_PropertyModes(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_PropertyMode(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_PropertyModes(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_PropertyMode(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_PropertyDefs(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_PropertyDef(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_PropertyDefs(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_PropertyDef(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_PropertyDefs(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_PropertyDef(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_PropertyNames(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(iluRt.InputString(_call, 0))
    iluRt.EndSequence(_call)
    return _value

def _Output_PropertyNames(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        iluRt.OutputString(_call, _value[_i], 0)
    iluRt.EndSequence(_call)

def _SizeOf_PropertyNames(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + iluRt.SizeOfString(_call, _value[_i], 0)
    iluRt.EndSequence(_call)
    return _size

class PropertyMode (iluRt.IluRecord):
    __ilu_type_name__ = 'CosPropertyService.PropertyMode'
    def __init__(self, _property_name, _property_mode):
        self.property_name = _property_name;
        self.property_mode = _property_mode;

    def __getinitargs__(self):
      return (self.property_name, self.property_mode, )

def _Input_PropertyMode(_call):
    iluRt.InputRecord(_call)
    _value = PropertyMode (None, None)
    _value.property_name = iluRt.InputString(_call, 0)
    _value.property_mode = iluRt.InputEnum(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_PropertyMode(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['property_name'], 0)
    iluRt.OutputEnum(_call, _value['property_mode'])
    iluRt.EndRecord(_call)

def _SizeOf_PropertyMode(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['property_name'], 0)\
      + iluRt.SizeOfEnum(_call, _value['property_mode'])
    iluRt.EndRecord(_call)
    return _size

class PropertyDef (iluRt.IluRecord):
    __ilu_type_name__ = 'CosPropertyService.PropertyDef'
    def __init__(self, _property_name, _property_value, _property_mode):
        self.property_name = _property_name;
        self.property_value = _property_value;
        self.property_mode = _property_mode;

    def __getinitargs__(self):
      return (self.property_name, self.property_value, self.property_mode, )

def _Input_PropertyDef(_call):
    iluRt.InputRecord(_call)
    _value = PropertyDef (None, None, None)
    _value.property_name = iluRt.InputString(_call, 0)
    _value.property_value = _Input_Any(_call)
    _value.property_mode = iluRt.InputEnum(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_PropertyDef(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['property_name'], 0)
    _Output_Any(_call, _value['property_value'])
    iluRt.OutputEnum(_call, _value['property_mode'])
    iluRt.EndRecord(_call)

def _SizeOf_PropertyDef(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['property_name'], 0)\
      + _SizeOf_Any(_call, _value['property_value'])\
      + iluRt.SizeOfEnum(_call, _value['property_mode'])
    iluRt.EndRecord(_call)
    return _size

class PropertyModeType:
    normal = 0;
    read_only = 1;
    fixed_normal = 2;
    fixed_readonly = 3;
    undefined = 4;
    __image__ = {
          normal : 'normal',
          read_only : 'read_only',
          fixed_normal : 'fixed_normal',
          fixed_readonly : 'fixed_readonly',
          undefined : 'undefined'}

class Property (iluRt.IluRecord):
    __ilu_type_name__ = 'CosPropertyService.Property'
    def __init__(self, _property_name, _property_value):
        self.property_name = _property_name;
        self.property_value = _property_value;

    def __getinitargs__(self):
      return (self.property_name, self.property_value, )

def _Input_Property(_call):
    iluRt.InputRecord(_call)
    _value = Property (None, None)
    _value.property_name = iluRt.InputString(_call, 0)
    _value.property_value = _Input_Any(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_Property(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['property_name'], 0)
    _Output_Any(_call, _value['property_value'])
    iluRt.EndRecord(_call)

def _SizeOf_Property(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['property_name'], 0)\
      + _SizeOf_Any(_call, _value['property_value'])
    iluRt.EndRecord(_call)
    return _size

def _Input_Properties(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_Property(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_Properties(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_Property(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_Properties(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_Property(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

def _Input_AnonType_1_(_call):
    _length = iluRt.InputSequence(_call, 0)
    _value = []
    for _i in range(0, _length):
        _value.append(_Input_Any(_call))
    iluRt.EndSequence(_call)
    return _value

def _Output_AnonType_1_(_call, _value):
    iluRt.OutputSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _Output_Any(_call, _value[_i])
    iluRt.EndSequence(_call)

def _SizeOf_AnonType_1_(_call, _value):
    _size = iluRt.SizeOfSequence(_call, len(_value), 0)
    for _i in range(0, len(_value)):
        _size = _size + _SizeOf_Any(_call, _value[_i])
    iluRt.EndSequence(_call)
    return _size

class anyType:
    Any_undefined = 0;
    Any_void = 1;
    Any_long = 2;
    Any_ulong = 3;
    Any_short = 4;
    Any_boolean = 5;
    Any_float = 6;
    Any_char = 7;
    Any_string = 8;
    Any_Object = 9;
    Any_PropertySet = 10;
    Any_sequenceAny = 11;
    Any_MimeObject = 12;
    Any_Properties = 13;
    __image__ = {
          Any_undefined : 'Any_undefined',
          Any_void : 'Any_void',
          Any_long : 'Any_long',
          Any_ulong : 'Any_ulong',
          Any_short : 'Any_short',
          Any_boolean : 'Any_boolean',
          Any_float : 'Any_float',
          Any_char : 'Any_char',
          Any_string : 'Any_string',
          Any_Object : 'Any_Object',
          Any_PropertySet : 'Any_PropertySet',
          Any_sequenceAny : 'Any_sequenceAny',
          Any_MimeObject : 'Any_MimeObject',
          Any_Properties : 'Any_Properties'}

class TMimeObject (iluRt.IluRecord):
    __ilu_type_name__ = 'CosPropertyService.TMimeObject'
    def __init__(self, _aContent_Type, _aBody):
        self.aContent_Type = _aContent_Type;
        self.aBody = _aBody;

    def __getinitargs__(self):
      return (self.aContent_Type, self.aBody, )

def _Input_TMimeObject(_call):
    iluRt.InputRecord(_call)
    _value = TMimeObject (None, None)
    _value.aContent_Type = iluRt.InputString(_call, 0)
    _value.aBody = _Input_Any(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_TMimeObject(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['aContent_Type'], 0)
    _Output_Any(_call, _value['aBody'])
    iluRt.EndRecord(_call)

def _SizeOf_TMimeObject(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['aContent_Type'], 0)\
      + _SizeOf_Any(_call, _value['aBody'])
    iluRt.EndRecord(_call)
    return _size

def _Input_Any(_call):
    _d = iluRt.InputUnion(_call, 4)
    if _d == 0:
	_value = (_d, iluRt.InputShortInteger(_call))
    elif _d == 1:
	_value = (_d, iluRt.InputShortInteger(_call))
    elif _d == 2:
	_value = (_d, iluRt.InputInteger(_call))
    elif _d == 3:
	_value = (_d, iluRt.InputCardinal(_call))
    elif _d == 4:
	_value = (_d, iluRt.InputShortInteger(_call))
    elif _d == 5:
	_value = (_d, iluRt.InputBoolean(_call))
    elif _d == 6:
	_value = (_d, iluRt.InputShortReal(_call))
    elif _d == 7:
	_value = (_d, iluRt.InputByte(_call))
    elif _d == 8:
	_value = (_d, iluRt.InputString(_call, 0))
    elif _d == 9:
	_value = (_d, _Input_TObject(_call))
    elif _d == 10:
	_value = (_d, iluRt.InputObjectID(_call, iluRt.FALSE, PropertySet))
    elif _d == 11:
	_value = (_d, _Input_AnonType_1_(_call))
    elif _d == 12:
	_value = (_d, _Input_TMimeObject(_call))
    elif _d == 13:
	_value = (_d, _Input_Properties(_call))
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _value

def _Output_Any(_call, _value):
    _d = _value[0]
    iluRt.OutputUnion(_call, _d, 4)
    if _d == 0:
	iluRt.OutputShortInteger(_call, _value[1])
    elif _d == 1:
	iluRt.OutputShortInteger(_call, _value[1])
    elif _d == 2:
	iluRt.OutputInteger(_call, _value[1])
    elif _d == 3:
	iluRt.OutputCardinal(_call, _value[1])
    elif _d == 4:
	iluRt.OutputShortInteger(_call, _value[1])
    elif _d == 5:
	iluRt.OutputBoolean(_call, _value[1])
    elif _d == 6:
	iluRt.OutputShortReal(_call, _value[1])
    elif _d == 7:
	iluRt.OutputByte(_call, _value[1])
    elif _d == 8:
	iluRt.OutputString(_call, _value[1], 0)
    elif _d == 9:
	_Output_TObject(_call, _value[1])
    elif _d == 10:
	iluRt.OutputObjectID(_call, _value[1], iluRt.FALSE, PropertySet)
    elif _d == 11:
	_Output_AnonType_1_(_call, _value[1])
    elif _d == 12:
	_Output_TMimeObject(_call, _value[1])
    elif _d == 13:
	_Output_Properties(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)

def _SizeOf_Any(_call, _value):
    _d = _value[0]
    _size = iluRt.SizeOfUnion(_call, _d, 4)
    if _d == 0:
	_size = _size + iluRt.SizeOfShortInteger(_call, _value[1])
    elif _d == 1:
	_size = _size + iluRt.SizeOfShortInteger(_call, _value[1])
    elif _d == 2:
	_size = _size + iluRt.SizeOfInteger(_call, _value[1])
    elif _d == 3:
	_size = _size + iluRt.SizeOfCardinal(_call, _value[1])
    elif _d == 4:
	_size = _size + iluRt.SizeOfShortInteger(_call, _value[1])
    elif _d == 5:
	_size = _size + iluRt.SizeOfBoolean(_call, _value[1])
    elif _d == 6:
	_size = _size + iluRt.SizeOfShortReal(_call, _value[1])
    elif _d == 7:
	_size = _size + iluRt.SizeOfByte(_call, _value[1])
    elif _d == 8:
	_size = _size + iluRt.SizeOfString(_call, _value[1], 0)
    elif _d == 9:
	_size = _size + _SizeOf_TObject(_call, _value[1])
    elif _d == 10:
	_size = _size + iluRt.SizeOfObjectID(_call, _value[1], iluRt.FALSE, PropertySet)
    elif _d == 11:
	_size = _size + _SizeOf_AnonType_1_(_call, _value[1])
    elif _d == 12:
	_size = _size + _SizeOf_TMimeObject(_call, _value[1])
    elif _d == 13:
	_size = _size + _SizeOf_Properties(_call, _value[1])
    else:
	raise TypeError
    iluRt.EndUnion(_call)
    return _size

class TDate (iluRt.IluRecord):
    __ilu_type_name__ = 'CosPropertyService.TDate'
    def __init__(self, _aRawDate, _aStart, _aEnd):
        self.aRawDate = _aRawDate;
        self.aStart = _aStart;
        self.aEnd = _aEnd;

    def __getinitargs__(self):
      return (self.aRawDate, self.aStart, self.aEnd, )

def _Input_TDate(_call):
    iluRt.InputRecord(_call)
    _value = TDate (None, None, None)
    _value.aRawDate = iluRt.InputString(_call, 0)
    _value.aStart = iluRt.InputInteger(_call)
    _value.aEnd = iluRt.InputInteger(_call)
    iluRt.EndRecord(_call)
    return _value

def _Output_TDate(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['aRawDate'], 0)
    iluRt.OutputInteger(_call, _value['aStart'])
    iluRt.OutputInteger(_call, _value['aEnd'])
    iluRt.EndRecord(_call)

def _SizeOf_TDate(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['aRawDate'], 0)\
      + iluRt.SizeOfInteger(_call, _value['aStart'])\
      + iluRt.SizeOfInteger(_call, _value['aEnd'])
    iluRt.EndRecord(_call)
    return _size

class TObject (iluRt.IluRecord):
    __ilu_type_name__ = 'CosPropertyService.TObject'
    def __init__(self, _aSBH, _aType):
        self.aSBH = _aSBH;
        self.aType = _aType;

    def __getinitargs__(self):
      return (self.aSBH, self.aType, )

def _Input_TObject(_call):
    iluRt.InputRecord(_call)
    _value = TObject (None, None)
    _value.aSBH = iluRt.InputString(_call, 0)
    _value.aType = iluRt.InputString(_call, 0)
    iluRt.EndRecord(_call)
    return _value

def _Output_TObject(_call, _value):
    iluRt.OutputRecord(_call)
    iluRt.OutputString(_call, _value['aSBH'], 0)
    iluRt.OutputString(_call, _value['aType'], 0)
    iluRt.EndRecord(_call)

def _SizeOf_TObject(_call, _value):
    _size = iluRt.SizeOfRecord(_call)\
      + iluRt.SizeOfString(_call, _value['aSBH'], 0)\
      + iluRt.SizeOfString(_call, _value['aType'], 0)
    iluRt.EndRecord(_call)
    return _size

def _CatchException(_call, _IluClass, _ecode):
    _value = None
    _name = iluRt.ExceptionName(_call, _IluClass, _ecode)
    if _name == ConstraintNotSupported:
	_name = ConstraintNotSupported
    elif _name == InvalidPropertyName:
	_name = InvalidPropertyName
    elif _name == ConflictingProperty:
	_name = ConflictingProperty
    elif _name == PropertyNotFound:
	_name = PropertyNotFound
    elif _name == UnsupportedTypeCode:
	_name = UnsupportedTypeCode
    elif _name == UnsupportedProperty:
	_name = UnsupportedProperty
    elif _name == UnsupportedMode:
	_name = UnsupportedMode
    elif _name == FixedProperty:
	_name = FixedProperty
    elif _name == ReadOnlyProperty:
	_name = ReadOnlyProperty
    elif _name == MultipleExceptions:
	_name = MultipleExceptions
	_value = _Input_R_MultipleExceptions(_call)
    raise _name, _value