Esempio n. 1
0
        /// <summary>
        /// Initializes a new instance of the <see cref="SerializedObjectReader"/> class based on the specified input stream, output stream and configuration.
        /// </summary>
        /// <param name="input">The input stream.</param>
        /// <param name="output">The output stream.</param>
        /// <param name="configuration">The configuration parameters to use for the reader.</param>
        /// <param name="label">The memory allocator label to use.</param>
        /// <param name="leaveInputOpen">True to leave the input stream open after the reader object is disposed; otherwise, false.</param>
        /// <param name="leaveOutputOpen">True to leave the output stream open after the reader object is disposed; otherwise, false.</param>
        /// <exception cref="ArgumentException">The configuration is invalid.</exception>
        public SerializedObjectReader(Stream input, PackedBinaryStream output, SerializedObjectReaderConfiguration configuration, Allocator label = SerializationConfiguration.DefaultAllocatorLabel, bool leaveInputOpen = true, bool leaveOutputOpen = true)
        {
            if (configuration.BlockBufferSize < 16)
            {
                throw new ArgumentException("BlockBufferSize < 16");
            }

            if (configuration.TokenBufferSize < 16)
            {
                throw new ArgumentException("TokenBufferSize < 16");
            }

            m_LeaveOutputOpen = leaveOutputOpen;

            m_StreamBlockReader = configuration.UseReadAsync
                ? (IUnsafeStreamBlockReader) new AsyncBlockReader(input, configuration.BlockBufferSize, leaveInputOpen)
                : (IUnsafeStreamBlockReader) new SyncBlockReader(input, configuration.BlockBufferSize, leaveInputOpen);

            m_Tokenizer    = new JsonTokenizer(configuration.TokenBufferSize, configuration.ValidationType, label);
            m_Parser       = new NodeParser(m_Tokenizer, configuration.NodeBufferSize, label);
            m_BinaryStream = output;
            m_BinaryWriter = new PackedBinaryWriter(m_BinaryStream, m_Tokenizer, label);
            m_InitialBlock = default;
            m_CurrentBlock = default;
        }
 internal Enumerator(PackedBinaryStream stream, Handle start)
 {
     m_Stream  = stream;
     m_Start   = start;
     m_Current = new Handle {
         Index = -1, Version = -1
     };
 }
        public PackedBinaryWriter(PackedBinaryStream stream, JsonTokenizer tokenizer, Allocator label)
        {
            m_Label = label;
            m_Data  = (Data *)UnsafeUtility.Malloc(sizeof(Data), UnsafeUtility.AlignOf <Data>(), label);
            UnsafeUtility.MemClear(m_Data, sizeof(Data));

            m_Stream    = stream;
            m_Tokenizer = tokenizer;
            m_Data->InputTokenNextIndex   = 0;
            m_Data->InputTokenParentIndex = -1;
        }
Esempio n. 4
0
        internal SerializedObjectReader(UnsafeBuffer <char> buffer, PackedBinaryStream output, SerializedObjectReaderConfiguration configuration, Allocator label = SerializationConfiguration.DefaultAllocatorLabel)
        {
            if (configuration.TokenBufferSize < 16)
            {
                throw new ArgumentException("TokenBufferSize < 16");
            }

            if (IsEmpty(buffer))
            {
                throw new ArgumentException("Input stream is null or empty.");
            }

            m_LeaveOutputOpen   = false;
            m_StreamBlockReader = null;
            m_Tokenizer         = new JsonTokenizer(configuration.TokenBufferSize, configuration.ValidationType, label);
            m_Parser            = new NodeParser(m_Tokenizer, configuration.NodeBufferSize, label);
            m_BinaryStream      = output;
            m_BinaryWriter      = new PackedBinaryWriter(m_BinaryStream, m_Tokenizer, label);
            m_Block             = buffer;
        }
Esempio n. 5
0
 public UnsafePackedBinaryStream(PackedBinaryStream stream)
 {
     m_PackedBinaryStream = stream;
     m_Tokens             = m_PackedBinaryStream.GetUnsafeData()->Tokens;
     m_Buffer             = m_PackedBinaryStream.GetUnsafeData()->Buffer;
 }
Esempio n. 6
0
 internal SerializedPrimitiveView(PackedBinaryStream stream, Handle handle)
 {
     m_Stream = stream;
     m_Handle = handle;
 }
 internal SerializedStringView(PackedBinaryStream stream, Handle handle)
 {
     m_Stream = stream;
     m_Handle = handle;
 }
Esempio n. 8
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SerializedObjectReader"/> class based on the specified input stream and output stream.
 /// </summary>
 /// <param name="input">The input stream.</param>
 /// <param name="output">The output stream.</param>
 /// <param name="label">The memory allocator label to use.</param>
 /// <param name="leaveInputOpen">True to leave the input stream open after the reader object is disposed; otherwise, false.</param>
 /// <param name="leaveOutputOpen">True to leave the output stream open after the reader object is disposed; otherwise, false.</param>
 public SerializedObjectReader(Stream input, PackedBinaryStream output, Allocator label = SerializationConfiguration.DefaultAllocatorLabel, bool leaveInputOpen = true, bool leaveOutputOpen = true)
     : this(input, output, SerializedObjectReaderConfiguration.Default, label, leaveInputOpen, leaveOutputOpen)
 {
 }
Esempio n. 9
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SerializedObjectReader"/> class with the specified path, output stream and configuration.
 /// </summary>
 /// <param name="path">A relative or absolute file path.</param>
 /// <param name="output">The output stream.</param>
 /// <param name="configuration">The configuration parameters to use for the reader.</param>
 /// <param name="label">The memory allocator label to use.</param>
 /// <param name="leaveOutputOpen">True to leave the output stream open after the reader object is disposed; otherwise, false.</param>
 public SerializedObjectReader(string path, PackedBinaryStream output, SerializedObjectReaderConfiguration configuration, Allocator label = SerializationConfiguration.DefaultAllocatorLabel, bool leaveOutputOpen = true)
     : this(OpenFileStreamWithConfiguration(path, configuration), output, configuration, label, false, leaveOutputOpen)
 {
 }
Esempio n. 10
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SerializedObjectReader"/> class based on the specified input buffer, output stream and configuration.
 /// </summary>
 /// <param name="buffer">The pointer to the input buffer.</param>
 /// <param name="length">The input buffer length.</param>
 /// <param name="output">The output stream.</param>
 /// <param name="configuration">The configuration parameters to use for the reader.</param>
 /// <param name="label">The memory allocator label to use.</param>
 public unsafe SerializedObjectReader(char *buffer, int length, PackedBinaryStream output, SerializedObjectReaderConfiguration configuration, Allocator label = SerializationConfiguration.DefaultAllocatorLabel)
     : this(new UnsafeBuffer <char>(buffer, length), output, configuration, label)
 {
 }