Exemplo n.º 1
0
        // 非公開メソッド

        private ulong[][] _createItemBufferMap(PropBinaryBuilder binBuilder, PropSectionCollection sections)
        {
            var itemBufferMap   = new ulong[sections.Count][];
            var currentPosition = 0uL;
            var ns = new NullStream();

            for (var i = 0; i < sections.Count; i++)
            {
                var section = sections[i];
                itemBufferMap[i] = new ulong[section.Items.Count];
                for (var j = 0; j < section.Items.Count; j++)
                {
                    var item = section.Items[j];
                    ns.Seek(0, SeekOrigin.Begin);

                    // Reference アルゴリズム未実装
                    var bufferMode = PropItemBufferMode.Buffered;
                    if (item.IsNull)
                    {
                        bufferMode = PropItemBufferMode.Null;
                    }
                    binBuilder.WriteItemBuffer(ns, item, bufferMode);

                    itemBufferMap[i][j] = currentPosition;
                    currentPosition    += (ulong)ns.Position;
                }
            }

            return(itemBufferMap);
        }
Exemplo n.º 2
0
        public void Test204()
        {
            // UTF-8 でビルダ・ローダを初期化
            var encoding   = Encoding.UTF8;
            var binBuilder = new PropBinaryBuilder(encoding);
            var binLoader  = new PropBinaryLoader(encoding);

            // アイテムの定義
            var propItemName  = "DEBUG_ITEM";
            var propItemType  = PropType.DateTime;
            var propItemValue = new DateTime(1970, 1, 1, 12, 0, 0, 500);
            var propItem      = new PropItem(propItemName, propItemType, propItemValue);

            // アイテム バッファの生成
            var ms = new MemoryStream();

            binBuilder.WriteItemBuffer(ms, propItem, PropItemBufferMode.Buffered);
            ms.Seek(0, SeekOrigin.Begin);

            // 処理実行
            try
            {
                using (var br = new BinaryReader(ms))
                {
                    // アイテム バッファ テーブルから読み取ったと想定するアイテム
                    var loadedItemFromBufferTable = new PropItem(propItemName, PropType.Buffer, null);

                    // フル ロード
                    var loadedItem = binLoader.LoadItemBuffer(br, loadedItemFromBufferTable, false);

                    // アイテム名が正しいことの確認
                    this.TestContext.WriteLine("Name> expected: {0}, actual: {1}", propItemName, loadedItem.Name);
                    Assert.AreEqual(propItemName, loadedItem.Name);

                    // タイプが正しいことの確認
                    this.TestContext.WriteLine("Type> expected: {0}, actual: {1}", propItemType, loadedItem.Type);
                    Assert.AreEqual(propItemType, loadedItem.Type);

                    // 値の内容の確認
                    this.TestContext.WriteLine("Value> expected: {0}, actual: {1}", propItemValue, loadedItem.Value);
                    Assert.AreEqual(propItemValue, loadedItem.Value);
                }
            }
            catch (Exception ex)
            {
                Assert.Fail($"予期せぬエラー: {ex}");
            }
        }
Exemplo n.º 3
0
        // 公開メソッド

        public void Write(Props props)
        {
            if (this._isDisposed)
            {
                throw new ObjectDisposedException(nameof(PropWriter));
            }

            using (var bw = new BinaryWriter(this._stream, this._encoding, true))
            {
                // アイテム バッファの空書き込みを実行し、アイテム バッファのマップを作成する
                var itemBufferMap = this._createItemBufferMap(_binBuilder, props.Sections);

#if DEBUG
                Console.WriteLine("== ITEM BUFFER MAPPING ==");
                for (var i = 0; i < props.Sections.Count; i++)
                {
                    var sect = props.Sections[i];
                    Console.WriteLine("[{0}]", sect.Name);
                    for (var j = 0; j < sect.Items.Count; j++)
                    {
                        var item      = sect.Items[j];
                        var itemName  = item.Name;
                        var bufferPos = itemBufferMap[i][j];
                        Console.WriteLine("{0}={1}", itemName, bufferPos);
                    }
                }
#endif

                // アイテム バッファ テーブルを作成する
                var itemBufferTableBuffer = new byte[props.Sections.Count][];
                var itemBufferTableMap    = new ulong[props.Sections.Count];
                var currentPosition       = 0uL;
                for (var i = 0; i < props.Sections.Count; i++)
                {
                    itemBufferTableBuffer[i] = _binBuilder.CreateItemBufferTable(props.Sections[i].Items, itemBufferMap[i]);
                    itemBufferTableMap[i]    = currentPosition;
                    currentPosition         += (ulong)itemBufferTableBuffer[i].Length; //itemBufferTableMap[i];
                }

                // セクション テーブルを作成し、書き込む
                bw.Write(_binBuilder.CreateSectionTable(props.Sections, itemBufferTableMap));

                // アイテム バッファ テーブルを書き込む
                for (var i = 0; i < itemBufferTableBuffer.Length; i++)
                {
                    bw.Write(itemBufferTableBuffer[i]);
                }

                // バイナリライタを Flush してからアイテム バッファを書き込む
                bw.Flush();
                for (var i = 0; i < props.Sections.Count; i++)
                {
                    var section = props.Sections[i];
                    for (var j = 0; j < section.Items.Count; j++)
                    {
                        var item = section.Items[j];

                        // Reference アルゴリズム未実装
                        var bufferMode = PropItemBufferMode.Buffered;
                        if (item.IsNull)
                        {
                            bufferMode = PropItemBufferMode.Null;
                        }
                        _binBuilder.WriteItemBuffer(this._stream, section.Items[j], bufferMode);
                    }
                }
            }

            this._stream.Flush();
        }