def serialize(self):
"""
serialize the message to display. DON't forget to call the serialize
method of command.
"""
return Command.serialize(self) + tokenizeValue("message",
self._message)
def serialize(self):
"""
serialize the data needed by the command to undo/redo the created link
"""
# serialize the data common to all commands
serialShape = Command.serialize(self)
# get the pyutId of the source OglObject of the link
srcId = self._link.getSourceShape().getPyutObject().getId()
# get the pyutId of the destination OglObject of the link
dstId = self._link.getDestinationShape().getPyutObject().getId()
# get the model start position of the link
srcPos = self._link.GetSource().GetModel().GetPosition()
# get the model end position of the link
dstPos = self._link.GetDestination().GetModel().GetPosition()
# get the type of the link (see OglLinkFactory)
linkType = getLinkType(self._link)
# get the pyutId of the link
linkId = self._link.getPyutObject().getId()
# serialize required data needed to undo/redo the link
serialShape += tokenizeValue("srcId", repr(srcId))
serialShape += tokenizeValue("dstId", repr(dstId))
serialShape += tokenizeValue("srcPos", repr(srcPos))
serialShape += tokenizeValue("dstPos", repr(dstPos))
serialShape += tokenizeValue("linkType", repr(linkType))
serialShape += tokenizeValue("linkId", repr(linkId))
return serialShape
def serialize(self) -> str:
serializedShape: str = super().serialize()
#
# serialize the class and module of the ogl and pyut shape to get the
# constructors for the deserialization
#
oglShapeModule: str = self._shape.__module__
oglShapeClass: str = self._shape.__class__.__name__
pyutShapeModule: str = self._shape.pyutObject.__module__
pyutShapeClass: str = self._shape.pyutObject.__class__.__name__
serializedShape += tokenizeValue("oglShapeModule", oglShapeModule)
serializedShape += tokenizeValue("oglShapeClass", oglShapeClass)
serializedShape += tokenizeValue("pyutShapeModule", pyutShapeModule)
serializedShape += tokenizeValue("pyutShapeClass", pyutShapeClass)
pyutObj = self._shape.pyutObject
shapeId: int = pyutObj.getId()
serializedShape += tokenizeValue("shapeId", repr(shapeId))
shapeName: str = pyutObj.getName()
serializedShape += tokenizeValue("shapeName", shapeName)
methodInformation: str = MethodInformation.serialize(
pyutClassCommon=pyutObj)
serializedShape += methodInformation
return serializedShape
def serialize(self) -> str:
serialShape: str = super().serialize()
#
# serialize the class and module of the ogl and pyut shape to get the
# constructors for the deserialization
oglShapeModule: str = self._shape.__module__
oglShapeClass: str = self._shape.__class__.__name__
pyutShapeModule: str = self._shape.getPyutObject().__module__
pyutShapeClass: str = self._shape.getPyutObject().__class__.__name__
serialShape += tokenizeValue("oglShapeModule", oglShapeModule)
serialShape += tokenizeValue("oglShapeClass", oglShapeClass)
serialShape += tokenizeValue("pyutShapeModule", pyutShapeModule)
serialShape += tokenizeValue("pyutShapeClass", pyutShapeClass)
# This is interesting:
# serialize the shape's model size and position and NOT the Ogl(view)'s
# ones because a zoom could be performed in between.
#
# TODO using the following causes 'Invalid or prematurely-freed autorelease pool 0x7fed3d8f3218.'
# boo hoo; no typing for me
# from org.pyut.miniogl.RectangleShapeModel import RectangleShapeModel
# model: RectangleShapeModel = self._shape.GetModel()
model = self._shape.GetModel()
pos: Tuple[int, int] = model.GetPosition()
size: Tuple[int, int] = model.GetSize()
serialShape += tokenizeValue("position", repr(pos))
serialShape += tokenizeValue("size", repr(size))
#
# serialize the graphical links (Ogl) attached to the shape
# and put it in the common data of the group. We have to do
# so because the link can be rebuilt only after the
# shape is rebuilt and so the command for link deletion
# must be placed after this one.
#
from org.pyut.history.commands.DelOglLinkCommand import DelOglLinkCommand
for link in self._shape.getLinks():
if not link.IsSelected():
cmd: DelOglLinkCommand = DelOglLinkCommand(link)
self.getGroup().addCommand(cmd)
# serialize data to initialize the associated pyutObject
pyutObj = self._shape.getPyutObject()
shapeId: int = pyutObj.getId()
shapeName: str = pyutObj.getName()
serialShape += tokenizeValue("shapeId", repr(shapeId))
serialShape += tokenizeValue("shapeName", shapeName)
return serialShape
def serialize(self) -> str:
"""
Serialize the module name and class name; All command must call
this method in their implementation
Notes: Use `makeValuatedToken()` from HistoryUtils for each value
you want to serialize
Then you can use the `getTokenValue()` to get
back the string representation of this value for the deserialization.
Returns: String representation of the command in view to store it
in a file. This method must be full implemented in all
subclasses.
`return Command.serialize + (MyCommand's serialized information)`
"""
moduleId: str = tokenizeValue(COMMAND_MODULE_ID, str(self.__module__))
classId: str = tokenizeValue(COMMAND_CLASS_ID,
str(self.__class__.__name__))
return f'{moduleId}{classId}'
def serialize(cls, pyutClassCommon: PyutClassCommon) -> str:
serializedInfo: str = ''
methods = []
for method in pyutClassCommon.methods:
methodName: str = method.getName()
methodVisibility: str = method.getVisibility().__str__()
methodReturns: str = method.getReturns().__str__()
params = []
for param in method.getParams():
paramName: str = param.getName()
paramType: str = param.getType().__str__()
paramDefaultValue: str = param.getDefaultValue()
params.append((paramName, paramType, paramDefaultValue))
modifiers = []
for modifier in method.getModifiers():
modifierName = modifier.getName()
modifiers.append(modifierName)
methodProfile: Tuple[str, str, str, str,
str] = (methodName, methodVisibility,
methodReturns, repr(params),
repr(modifiers))
methods.append(methodProfile)
classDescription: str = pyutClassCommon.description
serializedInfo += tokenizeValue("classDescription", classDescription)
serializedInfo += tokenizeValue("methods", repr(methods))
return serializedInfo
def serialize(self):
"""
Serialize the data needed by the destroyed OglLinkedObject.
Returns: A string representation of the data needed by the command.
"""
# serialize the common data common
serializedShape: str = DeleteOglObjectCommand.serialize(self)
fileName: str = self._shape.getPyutObject().getFilename()
serializedShape += tokenizeValue("fileName", fileName)
return serializedShape
def serialize(self):
"""
Transform all the commands belonging to the group into strings in
view to store them in a file.
@return a string representing the command.
"""
# add the beginning information of the group
serializedGroup = (tokenize(GROUP_BEGIN_ID) + tokenizeValue(GROUP_COMMENT_ID, self._comment))
# add the beginning information and setup information of
# each command. After that add the ending information of
# for each command.
for command in self._commands:
serializedGroup += (tokenize(COMMAND_BEGIN_ID) + command.serialize() + tokenize(COMMAND_END_ID))
# add the ending information of the group
serializedGroup += tokenize(GROUP_END_ID)
return serializedGroup
def serialize(self):
serialLink = Command.serialize(self)
self._srcPosition = self._shape.GetSource().GetModel().GetPosition()
self._destPosition = self._shape.GetDestination().GetModel(
).GetPosition()
self._linkType = getLinkType(self._shape)
self._linkSrcId = self._shape.getSourceShape().getPyutObject().getId()
self._linkDestId = self._shape.getDestinationShape().getPyutObject(
).getId()
self._linkId = self._shape.getPyutObject().getId()
serialLink += tokenizeValue("srcPosition", repr(self._srcPosition))
serialLink += tokenizeValue("destPosition", repr(self._destPosition))
serialLink += tokenizeValue("linkType", repr(self._linkType))
serialLink += tokenizeValue("linkSrcId", repr(self._linkSrcId))
serialLink += tokenizeValue("linkDestId", repr(self._linkDestId))
serialLink += tokenizeValue("linkId", repr(self._linkId))
return serialLink
def serialize(self) -> str:
"""
Serialize an OglClass
Returns: A string representation of the data needed by the command.
"""
# serialize the data common to all OglObjects
serialShape = DeleteOglLinkedObjectCommand.serialize(self)
pyutClass: PyutClass = self._shape.getPyutObject()
classDescription = pyutClass.description
if pyutClass.getStereotype() is not None:
classStereotypeName = pyutClass.getStereotype().getName()
else:
classStereotypeName = ""
classShowStereotype = repr(pyutClass.getShowStereotype())
classShowMethods = repr(pyutClass.showMethods)
classShowFields = repr(pyutClass.showFields)
fields = []
for field in pyutClass.fields:
fieldName = field.getName()
fieldType = field.getType().__str__()
fieldDefaultValue = field.getDefaultValue()
fieldVisibility = field.getVisibility().__str__()
fields.append(
(fieldName, fieldType, fieldDefaultValue, fieldVisibility))
methods = []
for method in pyutClass.methods:
methodName = method.getName()
methodVisibility = method.getVisibility().__str__()
methodReturns = method.getReturns().__str__()
params = []
for param in method.getParams():
paramName = param.getName()
paramType = param.getType().__str__()
paramDefaultValue = param.getDefaultValue()
params.append((paramName, paramType, paramDefaultValue))
modifiers = []
for modifier in method.getModifiers():
modifierName = modifier.getName()
modifiers.append(modifierName)
methodProfile = (methodName, methodVisibility, methodReturns,
repr(params), repr(modifiers))
methods.append(methodProfile)
serialShape += tokenizeValue("classDescription", classDescription)
serialShape += tokenizeValue("classStereotypeName",
classStereotypeName)
serialShape += tokenizeValue("classShowStereotype",
classShowStereotype)
serialShape += tokenizeValue("classShowMethods", classShowMethods)
serialShape += tokenizeValue("classShowFields", classShowFields)
serialShape += tokenizeValue("fields", repr(fields))
serialShape += tokenizeValue("methods", repr(methods))
return serialShape