| # Licensed to the Apache Software Foundation (ASF) under one or more |
| # contributor license agreements. See the NOTICE file distributed with |
| # this work for additional information regarding copyright ownership. |
| # The ASF licenses this file to You under the Apache License, Version 2.0 |
| # (the "License"); you may not use this file except in compliance with |
| # the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| import ctypes |
| from io import BytesIO |
| |
| import pyignite.utils as ignite_utils |
| |
| READ_FORWARD = 0 |
| READ_BACKWARD = 1 |
| |
| |
| class BinaryStream: |
| def __init__(self, conn, buf=None): |
| """ |
| Initialize binary stream around buffers. |
| |
| :param buf: Buffer, optional parameter. If not passed, creates empty BytesIO. |
| :param conn: Connection instance, required. |
| """ |
| from pyignite.connection import Connection |
| |
| if not isinstance(conn, Connection): |
| raise TypeError(f"invalid parameter: expected instance of {Connection}") |
| |
| if buf and not isinstance(buf, (bytearray, bytes, memoryview)): |
| raise TypeError(f"invalid parameter: expected bytes-like object") |
| |
| self.conn = conn |
| self.stream = BytesIO(buf) if buf else BytesIO() |
| |
| @property |
| def compact_footer(self) -> bool: |
| return self.conn.client.compact_footer |
| |
| @compact_footer.setter |
| def compact_footer(self, value: bool): |
| self.conn.client.compact_footer = value |
| |
| def read(self, size): |
| buf = bytearray(size) |
| self.stream.readinto(buf) |
| return buf |
| |
| def read_ctype(self, ctype_class, position=None, direction=READ_FORWARD): |
| ctype_len = ctypes.sizeof(ctype_class) |
| |
| if position is not None and position >= 0: |
| init_position = position |
| else: |
| init_position = self.tell() |
| |
| if direction == READ_FORWARD: |
| start, end = init_position, init_position + ctype_len |
| else: |
| start, end = init_position - ctype_len, init_position |
| |
| buf = self.stream.getbuffer()[start:end] |
| return ctype_class.from_buffer_copy(buf) |
| |
| def write(self, buf): |
| return self.stream.write(buf) |
| |
| def tell(self): |
| return self.stream.tell() |
| |
| def seek(self, *args, **kwargs): |
| return self.stream.seek(*args, **kwargs) |
| |
| def getvalue(self): |
| return self.stream.getvalue() |
| |
| def getbuffer(self): |
| return self.stream.getbuffer() |
| |
| def mem_view(self, start=-1, offset=0): |
| start = start if start >= 0 else self.tell() |
| return self.stream.getbuffer()[start:start+offset] |
| |
| def hashcode(self, start, bytes_len): |
| return ignite_utils.hashcode(self.stream.getbuffer()[start:start+bytes_len]) |
| |
| def __enter__(self): |
| return self |
| |
| def __exit__(self, exc_type, exc_value, traceback): |
| try: |
| self.stream.close() |
| except BufferError: |
| pass |
| |
| def get_dataclass(self, header): |
| # get field names from outer space |
| result = self.conn.client.query_binary_type( |
| header.type_id, |
| header.schema_id |
| ) |
| if not result: |
| raise RuntimeError('Binary type is not registered') |
| return result |
| |
| def register_binary_type(self, *args, **kwargs): |
| return self.conn.client.register_binary_type(*args, **kwargs) |