home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / fnb101.zip / Lib / site-packages / Fnorb / orb / OctetStream.py < prev    next >
Text File  |  1999-06-28  |  13KB  |  431 lines
  1. #!/usr/bin/env python
  2. #############################################################################
  3. # Copyright (C) DSTC Pty Ltd (ACN 052 372 577) 1997, 1998, 1999
  4. # All Rights Reserved.
  5. #
  6. # The software contained on this media is the property of the DSTC Pty
  7. # Ltd.  Use of this software is strictly in accordance with the
  8. # license agreement in the accompanying LICENSE.HTML file.  If your
  9. # distribution of this software does not contain a LICENSE.HTML file
  10. # then you have no rights to use this software in any manner and
  11. # should contact DSTC at the address below to determine an appropriate
  12. # licensing arrangement.
  13. # 
  14. #      DSTC Pty Ltd
  15. #      Level 7, GP South
  16. #      Staff House Road
  17. #      University of Queensland
  18. #      St Lucia, 4072
  19. #      Australia
  20. #      Tel: +61 7 3365 4310
  21. #      Fax: +61 7 3365 4311
  22. #      Email: enquiries@dstc.edu.au
  23. # 
  24. # This software is being provided "AS IS" without warranty of any
  25. # kind.  In no event shall DSTC Pty Ltd be liable for damage of any
  26. # kind arising out of or in connection with the use or performance of
  27. # this software.
  28. #
  29. # Project:      Fnorb
  30. # File:         $Source: /units/arch/src/Fnorb/orb/RCS/OctetStream.py,v $
  31. # Version:      @(#)$RCSfile: OctetStream.py,v $ $Revision: 1.16 $
  32. #
  33. #############################################################################
  34. """ Classes for CORBA octet streams, encapsulations and GIOP messages. """
  35.  
  36.  
  37. # Standard/built-in modules.
  38. import new
  39.  
  40. # Fnorb modules.
  41. import CORBA, GIOP, Util
  42.  
  43. # Fnorb extension modules.
  44. import cdr
  45.  
  46. # Fnorb parser modules.
  47. from Fnorb.parser import Stack
  48.  
  49.  
  50. class OctetStream:
  51.     """ CORBA octet streams. """
  52.  
  53.     # The initial size of a new stream.
  54.     INITIAL_SIZE = 512
  55.  
  56.     def __init__(self, data=None):
  57.     """ Constructor.
  58.  
  59.     'data' is the contents of the octet stream.
  60.  
  61.     """
  62.     # If no data is specified then we initially allocate a fixed size
  63.     # string and then grow it (ie. get a bigger, better, brighter, wider,
  64.     # faster string) as required.
  65.     if data is None:
  66.         self._data = '\0' * OctetStream.INITIAL_SIZE
  67.         self._len = 0
  68.  
  69.     # If data *is* specified then we use that!
  70.     else:
  71.         self._data = data
  72.         self._len = len(data)
  73.  
  74.     return
  75.  
  76.     def __del__(self):
  77.     
  78.     del self._data
  79.     return
  80.  
  81.     def __len__(self):
  82.     """ Return the number of octets in the stream.
  83.  
  84.     This is the number of octets actually marshalled in the stream - not
  85.     the internal buffer size!
  86.  
  87.     """
  88.     return self._len
  89.  
  90.     def marshal(self, format, value, offset, byte_order):
  91.     """ Marshal a value onto the octet stream.
  92.  
  93.     'format'     identifies the type of the data to be marshalled.
  94.     'value'      is the data to be marshalled!
  95.     'offset'     is the offset in the stream to marshal the data into.
  96.     'byte_order' is the byte ordering to use when marshalling the data.
  97.  
  98.     The return value is the offset in the stream after marshalling the
  99.     data.
  100.  
  101.     """
  102.     # Calculate the space required to marshal the data onto the octet
  103.     # stream.  If the value won't fit into the string that is currently
  104.     # allocated then we create a new, larger one.
  105.     new_offset = cdr.count(format,
  106.                    self._data, # Not modified by this call.
  107.                    offset,
  108.                    byte_order,
  109.                    value)
  110.  
  111.     # If a new string is required, then make it plenty big enough!
  112.     if new_offset > len(self._data):
  113.         # For now we'll make the new string twice as big as required.
  114.         new_len = new_offset * 2
  115.         self._data = self._data + ('\0' * (new_len - len(self._data)))
  116.  
  117.     # Now marshal the data onto the octet stream.
  118.     new_offset = cdr.marshal(format,
  119.                  self._data,
  120.                  offset,
  121.                  byte_order,
  122.                  value)
  123.  
  124.     # Have we increased the *actual* length of the data in the octet
  125.     # stream?
  126.     if new_offset > self._len:
  127.         self._len = new_offset
  128.  
  129.     return new_offset
  130.  
  131.     def unmarshal(self, format, offset, byte_order):
  132.     """ Unmarshal a value from the octet stream.
  133.  
  134.     'format'     identifies the type of the data to be unmarshalled.
  135.     'offset'     is the offset in the stream to unmarshal the data from.
  136.     'byte_order' is the byte ordering to use when unmarshalling the data.
  137.     
  138.     The return value is a tuple (NewOffset, Value) where 'NewOffset' is the
  139.     offset after unmarshalling the value, and 'Value' (surprise, surprise)
  140.     is the value that was unmarshalled.
  141.  
  142.     """
  143.     return cdr.unmarshal(format, self._data, offset, byte_order)
  144.  
  145.     def data(self):
  146.     """ Return the contents of the octet stream. """
  147.  
  148.     return self._data[:self._len]
  149.  
  150.     def cursor(self, offset=0, byte_order=Util.HOST_BYTE_ORDER):
  151.     """ Return a cursor suitable for iterating over me! """
  152.  
  153.     return OctetStreamCursor(self, offset, byte_order)
  154.  
  155.  
  156. class OctetStreamCursor:
  157.     """ A class to allow iteration over an OctetStream. """
  158.  
  159. ##    def __init__(self, stream, offset, byte_order=Util.HOST_BYTE_ORDER):
  160.     def __init__(self, stream, offset, byte_order, stack=None):
  161.     """ Constructor.
  162.  
  163.     'stream'     is the octet stream to iterate over.
  164.     'offset'     is the starting position within the octet stream.
  165.     'byte_order' is the byte ordering to use when marshalling/unmarshalling
  166.                  data.
  167.  
  168.     """
  169.     self._stream = stream
  170.     self._offset = offset
  171.     self._byte_order = byte_order
  172.  
  173.     # Container stack for marshalling/unmarshalling recursive types.
  174.     #
  175.     # In the case of an encapsulation cursor, the stack is inherited from
  176.     # the cursor that created it.
  177.     if stack is not None:
  178.         self._stack = stack
  179.  
  180.     else:
  181.         self._stack = Stack.Stack()
  182.  
  183.     return
  184.  
  185.     def stream(self):
  186.     """ Return the octet stream that we are iterating over. """
  187.  
  188.     return self._stream
  189.  
  190.     def offset(self):
  191.     """ Return the current offset in the octet stream. """
  192.  
  193.     return self._offset
  194.  
  195.     def set_offset(self, offset):
  196.     """ Set the offeset in the octet stream. """
  197.  
  198.     self._offset = offset
  199.     return
  200.  
  201.     def byte_order(self):
  202.     """ Return the byte ordering of the cursor. """
  203.  
  204.     return self._byte_order
  205.  
  206.     def marshal(self, format, value):
  207.     """ Marshal a value onto the octet stream.
  208.  
  209.     'format' identifies the type of the data to be marshalled.
  210.     'value'  is the data to be marshalled!
  211.  
  212.     """
  213.     self._offset = self._stream.marshal(format,
  214.                         value,
  215.                         self._offset,
  216.                         self._byte_order)
  217.     return
  218.  
  219.     def unmarshal(self, format):
  220.     """ Unmarshal a value from the octet stream.
  221.  
  222.     'format' identifies the type of the data to be unmarshalled.
  223.  
  224.     The return value is the value that was unmarshalled.
  225.  
  226.     """
  227.     (self._offset, value) = self._stream.unmarshal(format,
  228.                                self._offset,
  229.                                self._byte_order)
  230.     return value
  231.  
  232.     # fixme: How does this work with regard to calculating padding?
  233.     #
  234.     # answer: I think it works 'cos no item within an encapsulation requires
  235.     # a byte boundary of anything more than a multiple of four, therefore, by
  236.     # the time we have aligned the length of the encapsulation then we have
  237.     # forced the necessary alignment.
  238.     def encapsulation_cursor(self):
  239.     """ Return a new cursor at the start of an encapsulation. """
  240.  
  241.     # Skip over the length of the encapsulation.
  242.     (offset, length) = self._stream.unmarshal('L',
  243.                           self._offset,
  244.                           self._byte_order)
  245.  
  246.     # Get the byte order of the encapsulation.
  247.     (offset, byte_order) = self._stream.unmarshal('b',
  248.                               offset,
  249.                               self._byte_order)
  250.  
  251.     # Create a new cursor with the specified byte order (the cursor also
  252.     # inherits the stack for marshalling/unmarshalling recursive types).
  253.     return OctetStreamCursor(self._stream, offset, byte_order, self._stack)
  254.  
  255.     def stack(self):
  256.     """ Return the stack of containers.
  257.  
  258.     This is used to marshal and unmarshal recursive types.
  259.  
  260.     """
  261.     return self._stack
  262.  
  263.  
  264. class Encapsulation(OctetStream):
  265.     """ CORBA encapsulations. """
  266.  
  267.     def __init__(self, data=None, byte_order=Util.HOST_BYTE_ORDER):
  268.     """ Constructor.
  269.  
  270.     'data'       is the contents of the octet stream.
  271.     'byte_order' is the byte order of the octet stream!
  272.  
  273.     """
  274.     # The byte order of the octet stream.
  275.     self._byte_order = byte_order
  276.  
  277.     # If no data is specified then we initially allocate a fixed size
  278.     # string and then grow it (ie. get a bigger, better, brighter, wider,
  279.     # faster string) as required.
  280.     if data is None:
  281.         self._data = "\0" * OctetStream.INITIAL_SIZE
  282.         self._len = 0
  283.  
  284.         # Marshal the byte order onto the first octet in the stream.
  285.         offset = self.marshal('b', self._byte_order, 0, self._byte_order)
  286.  
  287.     # If data *is* specified then we use that!
  288.     else:
  289.         self._data = data
  290.         self._len = len(data)
  291.  
  292.         # Get the byte order of the encapsulation (held in the first
  293.         # octet).
  294.         (offset, self._byte_order) = self.unmarshal('b',0,self._byte_order)
  295.  
  296.     return
  297.  
  298.     def cursor(self, offset=1):
  299.     """ Return a cursor suitable for iterating over me! """
  300.  
  301.     return OctetStreamCursor(self, offset, self._byte_order)
  302.  
  303.  
  304. class GIOPMessage(OctetStream):
  305.     """ GIOP messages. """
  306.  
  307.     # Current version of GIOP.
  308.     __GIOP_VERSION = GIOP.Version(Util.GIOP_VERSION_MAJOR,
  309.                   Util.GIOP_VERSION_MINOR)
  310.  
  311.     def __init__(self, data=None, byte_order=Util.HOST_BYTE_ORDER, type=None):
  312.     """ Constructor.
  313.  
  314.     'data'       is the contents of the octet stream.
  315.     'byte_order' is the byte order of the octet stream!
  316.     'type'       is the type of GIOP message ;^)
  317.  
  318.     """
  319.     # The byte order of the octet stream.
  320.     self._byte_order = byte_order
  321.  
  322.     # If no data is specified then we initially allocate a fixed size
  323.     # string and then grow it (ie. get a bigger, better, brighter, wider,
  324.     # faster string) as required.
  325.     if data is None:
  326.         self._data = "\0" * OctetStream.INITIAL_SIZE
  327.         self._len = 0
  328.  
  329.         # Marshal a GIOP header onto the stream.
  330.         self._header = self._marshal_header(type)
  331.  
  332.     # If data *is* specified then we use that!
  333.     else:
  334.         self._data = data
  335.         self._len = len(data)
  336.  
  337.         # Get the byte order of the message (held in the sixth octet!).
  338.         (offset, self._byte_order) = self.unmarshal('b',6,self._byte_order)
  339.  
  340.         # Unmarshal the GIOP header from the stream.
  341.         self._header = self._unmarshal_header()
  342.  
  343.     return
  344.  
  345.     def header(self):
  346.     """ Return the GIOP message header. """
  347.     
  348.     return self._header
  349.  
  350.     def data(self):
  351.     """ Return the contents of the octet stream. """
  352.  
  353.     # Fixup the length in the GIOP header.
  354.     cdr.marshal('L', self._data, 8, self._byte_order, self._len - 12)
  355.  
  356.     return OctetStream.data(self)
  357.  
  358.     def cursor(self, offset=12):
  359.     """ Return a cursor suitable for iterating over me! """
  360.  
  361.     return OctetStreamCursor(self, offset, self._byte_order)
  362.  
  363.     #########################################################################
  364.     # Internal methods.
  365.     #########################################################################
  366.  
  367.     def _marshal_header(self, message_type):
  368.     """ Marshal a GIOP header onto the start of the stream.
  369.  
  370.     'message_type' is the type of GIOP message ;^)
  371.  
  372.     """
  373.     # Create a GIOP header (the size of the message is fixed up when
  374.     # the 'data' method is called!).
  375.     header = GIOP.MessageHeader(Util.MAGIC,
  376.                     GIOPMessage.__GIOP_VERSION,
  377.                     self._byte_order,
  378.                     message_type.value(),
  379.                     0) # Size
  380.  
  381.     tc = CORBA.typecode('IDL:omg.org/GIOP/MessageHeader:1.0')
  382.     tc._fnorb_marshal_value(self.cursor(0), header)
  383.  
  384.     return header
  385.  
  386.     def _unmarshal_header(self):
  387.     """ Unmarshal a GIOP header from the start of the stream. """
  388.  
  389.     # Unmarshal the header from the start of the stream.
  390.     tc = CORBA.typecode('IDL:omg.org/GIOP/MessageHeader:1.0')
  391.     return tc._fnorb_unmarshal_value(self.cursor(0))
  392.  
  393. #############################################################################
  394.  
  395. # Testing.
  396. if __name__ == '__main__':
  397.  
  398.     for stream in [OctetStream(), Encapsulation()]:
  399.     # Marshal some 'stuff' onto the stream...
  400.     cursor = stream.cursor(12)
  401.     cursor.marshal('b', 123)
  402.     cursor.marshal('c', 'X')
  403.     cursor.marshal('o', 125)
  404.     cursor.marshal('h', 126)
  405.     cursor.marshal('H', 127)
  406.     cursor.marshal('l', 128)
  407.     cursor.marshal('L', 129)
  408.     cursor.marshal('n', -9223372036854775808L)
  409.     cursor.marshal('N', 9223372036854775808L)
  410.     cursor.marshal('f', 130.456)
  411.     cursor.marshal('d', 131.456)
  412.     cursor.marshal('s', 'Hello World!')
  413.     cursor.marshal('O', 'Hello World!')
  414.     # ... and make sure it unmarshals correctly ;^)
  415.     cursor = stream.cursor(12)
  416.     print cursor.unmarshal('b')
  417.     print cursor.unmarshal('c')
  418.     print cursor.unmarshal('o')
  419.     print cursor.unmarshal('h')
  420.     print cursor.unmarshal('H')
  421.     print cursor.unmarshal('l')
  422.     print cursor.unmarshal('L')
  423.     print cursor.unmarshal('n')
  424.     print cursor.unmarshal('N')
  425.     print cursor.unmarshal('f')
  426.     print cursor.unmarshal('d')
  427.     print cursor.unmarshal('s')
  428.     print cursor.unmarshal('O')
  429.  
  430. #############################################################################
  431.