Changeset 11 for ProtocolBuffers/UProtocolBuffers.pas

Timestamp:

Oct 20, 2009, 11:06:34 AM (15 years ago)

Author:

george

Message:

• Modified: Definition tree is now separated from data. This was needed for implementation of repeated fields.

File:

• ProtocolBuffers/UProtocolBuffers.pas (modified) (20 diffs)

ProtocolBuffers/UProtocolBuffers.pas

@@ -1 @@
-// http://code.google.com/intl/cs/apis/protocolbuffers/docs/overview.html
+// Specification: http://code.google.com/intl/cs/apis/protocolbuffers/docs/overview.html
 unit UProtocolBuffers;
 
@@ -7 +7 @@
 
 uses
-  Classes, SysUtils;
+  Classes, SysUtils, Dialogs;
 
 type
   TPBItemMode = (imRequired, imOptional, imRepeated);
-  TPBItemType = (itVariant, it64bit, itLengthDelimited, itStartGroup,
-    itEndGroup, it32bit);
+  TPBWireType = (wtVariant, wt64bit, wtLengthDelimited, wtStartGroup,
+    wtEndGroup, wt32bit);
+  TPBItemType = (itInteger, itString, itMessage, itFloat, itDouble, itBlock);
 
   TPBEnumeration = class
   end;
 
-  { TPBItem }
-  TPBItem = class
+  { TPBDefinition }
+  TPBDefinition = class
+  private
+    function GetWireType: TPBWireType;
+  public
     Name: string;
     Tag: Integer;
     ItemType: TPBItemType;
     ItemMode: TPBItemMode;
+    Items: TList; // TList<TPBDefinition>
+    DefaultString: string;
+    DefaultInteger: Integer;
+    constructor Create;
+    destructor Destroy; override;
+    function SearchItemByTag(Tag: Integer): Integer;
+    property WireType: TPBWireType read GetWireType;
+  end;
+
+  { TPBItemHead }
+  TPBItemHead = record
+    Tag: Integer;
+    WireType: TPBWireType;
+  end;
+
+  { TPBItem }
+  TPBItem = class
     procedure SaveVariantToStream(Stream: TStream; Value: Integer);
     function LoadVariantFromStream(Stream: TStream): Integer;
     procedure SaveLengthDelimitedToStream(Stream: TStream; Block: TStream);
     procedure LoadLengthDelimitedFromStream(Stream: TStream; Block: TStream);
-    procedure SaveHeadToStream(Stream: TStream);
-    procedure LoadHeadFromStream(Stream: TStream);
-    procedure SaveToStream(Stream: TStream); virtual;
-    procedure LoadFromStream(Stream: TStream); virtual;
+    procedure SaveHeadToStream(Stream: TStream; Definition: TPBDefinition);
+    function LoadHeadFromStream(Stream: TStream; Definition: TPBDefinition): TPBItemHead;
+    procedure SaveToStream(Stream: TStream; Definition: TPBDefinition); virtual;
+    procedure LoadFromStream(Stream: TStream; Definition: TPBDefinition); virtual;
+    procedure Clear(Definition: TPBDefinition); virtual;
+    procedure Assign(Source: TPBItem); virtual;
   end;
 
@@ -38 +61 @@
   TPBStringItem = class(TPBItem)
     Value: string;
-    procedure SaveToStream(Stream: TStream); override;
-    procedure LoadFromStream(Stream: TStream); override;
+    procedure SaveToStream(Stream: TStream; Definition: TPBDefinition); override;
+    procedure LoadFromStream(Stream: TStream; Definition: TPBDefinition); override;
     constructor Create;
+    procedure Assign(Source: TPBItem); override;
   end;
 
@@ -46 +70 @@
   TPBIntegerItem = class(TPBItem)
     Value: Integer;
-    procedure SaveToStream(Stream: TStream); override;
-    procedure LoadFromStream(Stream: TStream); override;
+    procedure SaveToStream(Stream: TStream; Definition: TPBDefinition); override;
+    procedure LoadFromStream(Stream: TStream; Definition: TPBDefinition); override;
     constructor Create;
+    procedure Assign(Source: TPBItem); override;
   end;
 
@@ -54 +79 @@
   TPBMessageItem = class(TPBItem)
     GenerateHead: Boolean;
-    Items: TList; // TList<TPBItem>;
-    function SearchItemByTag(Tag: Integer): TPBItem;
-    procedure SaveToStream(Stream: TStream); override;
-    procedure LoadFromStream(Stream: TStream); override;
+    Items: TList; // TList<TList<TPBItem>>;
+    procedure Clear(Definition: TPBDefinition); override;
+    procedure SaveToStream(Stream: TStream; Definition: TPBDefinition); override;
+    procedure LoadFromStream(Stream: TStream; Definition: TPBDefinition); override;
     constructor Create;
     destructor Destroy; override;
+    procedure Assign(Source: TPBItem); override;
+  end;
+
+  { TPBRepeatedItem }
+
+  TPBRepeatedItem = class(TPBItem)
+    Items: TList;
+    procedure Clear(Definition: TPBDefinition); override;
+    procedure SaveToStream(Stream: TStream; Definition: TPBDefinition); override;
+    procedure LoadFromStream(Stream: TStream; Definition: TPBDefinition); override;
+    constructor Create;
+    destructor Destroy; override;
+    procedure Assign(Source: TPBItem); override;
   end;
 
   { TProtocolBuffer }
   TProtocolBuffer = class
+    Definition: TPBDefinition;
     BaseMessage: TPBMessageItem;
     procedure LoadFromStream(Stream: TStream);
@@ -82 +121 @@
 begin
   BaseMessage.GenerateHead := False;
-  BaseMessage.LoadFromStream(Stream);
+  BaseMessage.LoadFromStream(Stream, Definition);
 end;
 
@@ -88 +127 @@
 begin
   BaseMessage.GenerateHead := False;
-  BaseMessage.SaveToStream(Stream);
+  BaseMessage.SaveToStream(Stream, Definition);
 end;
 
@@ -99 +138 @@
 begin
   BaseMessage := TPBMessageItem.Create;
+  Definition := TPBDefinition.Create;
+  Definition.ItemType := itMessage;
 end;
 
 destructor TProtocolBuffer.Destroy;
 begin
-  if Assigned(BaseMessage) then BaseMessage.Free;
+  Definition.Destroy;
+  BaseMessage.Free;
   inherited Destroy;
 end;
@@ -109 +151 @@
 { TPBMessageItem }
 
-function TPBMessageItem.SearchItemByTag(Tag: Integer): TPBItem;
-var
-  I: Integer;
-begin
-  I := 0;
-  while (I < Items.Count) and (TPBItem(Items[I]).Tag <> Tag) do Inc(I);
-  if I < Items.Count then Result := Items[I]
-    else Result := nil;
-end;
-
-procedure TPBMessageItem.SaveToStream(Stream: TStream);
-var
-  I: Integer;
+procedure TPBMessageItem.Clear(Definition: TPBDefinition);
+var
+  I: Integer;
+  Q: Integer;
+begin
+  for I := 0 to Items.Count - 1 do
+    TPBItem(Items[I]).Clear(Definition);
+  Items.Clear;
+  Items.Count := Definition.Items.Count;
+  for I := 0 to Items.Count - 1 do begin
+    if TPBDefinition(Definition.Items[I]).ItemMode = imRepeated then
+      Items[I] := TPBRepeatedItem.Create
+    else
+    if TPBDefinition(Definition.Items[I]).ItemType = itInteger then begin
+      Items[I] := TPBIntegerItem.Create;
+      TPBIntegerItem(Items[I]).Value := TPBDefinition(Definition.Items[I]).DefaultInteger;
+    end else
+    if TPBDefinition(Definition.Items[I]).ItemType = itString then begin
+      Items[I] := TPBStringItem.Create;
+      TPBStringItem(Items[I]).Value := TPBDefinition(Definition.Items[I]).DefaultString;
+    end else
+    if TPBDefinition(Definition.Items[I]).ItemType = itMessage then begin
+      Items[I] := TPBMessageItem.Create;
+      TPBMessageItem(Items[I]).Clear(Definition.Items[I]);
+    end;
+  end;
+end;
+
+procedure TPBMessageItem.SaveToStream(Stream: TStream; Definition: TPBDefinition);
+var
+  I: Integer;
+  Q: Integer;
   TempStream: TMemoryStream;
 begin
@@ -127 +188 @@
   // Generate message content to temporary stream
   TempStream := TMemoryStream.Create;
-  for I := 0 to Items.Count - 1 do
-    TPBItem(Items[I]).SaveToStream(TempStream);
-  // if head is used than write lenght-delimited head type with block byte length
+  if Items.Count <> Definition.Items.Count then
+    raise Exception.Create('Definition and value items count mismatch.');
+  for I := 0 to Definition.Items.Count - 1 do
+    TPBItem(Items[I]).SaveToStream(TempStream, Definition.Items[I]);
+
+  // If head is used than write lenght-delimited head type with block byte length
   if GenerateHead then begin
-    SaveHeadToStream(Stream);
+    SaveHeadToStream(Stream, Definition);
     SaveVariantToStream(Stream, TempStream.Size);
   end;
@@ -139 +203 @@
 end;
 
-procedure TPBMessageItem.LoadFromStream(Stream: TStream);
+procedure TPBMessageItem.LoadFromStream(Stream: TStream; Definition: TPBDefinition);
 var
   I: Integer;
   TempItem: TPBItem;
-  SearchItem: TPBItem;
+  ItemIndex: Integer;
   EndIndex: Integer;
   TempStream: TMemoryStream;
+  ItemHead: TPBItemHead;
+  NewItem: TPBItem;
 begin
   inherited;
@@ -156 +222 @@
 
   TempItem := TPBItem.Create;
+  Clear(Definition);
   while Stream.Position < EndIndex do begin
-    TempItem.LoadHeadFromStream(Stream);
-    SearchItem := SearchItemByTag(TempItem.Tag);
-    if Assigned(SearchItem) then begin
-      if SearchItem.ItemType <> TempItem.ItemType then
-        raise Exception.Create('Bad type for item "' + SearchItem.Name +
-          '" with tag ' + IntToStr(SearchItem.Tag));
-      if SearchItem is TPBIntegerItem then
-        TPBIntegerItem(SearchItem).LoadFromStream(Stream)
-      else if SearchItem is TPBStringItem then
-        TPBStringItem(SearchItem).LoadFromStream(Stream)
-      else if SearchItem is TPBMessageItem then
-        TPBMessageItem(SearchItem).LoadFromStream(Stream);
+    ItemHead := TempItem.LoadHeadFromStream(Stream, Definition);
+    ItemIndex := Definition.SearchItemByTag(ItemHead.Tag);
+    if ItemIndex <> -1 then
+      with TPBDefinition(Definition.Items[ItemIndex]) do begin
+        if WireType <> ItemHead.WireType then
+          raise Exception.Create('Bad type for item "' + TPBDefinition(Definition.Items[ItemIndex]).Name +
+            '" with tag ' + IntToStr(ItemHead.Tag));
+        if ItemType = itInteger then begin
+          NewItem := TPBIntegerItem.Create;
+          TPBIntegerItem(NewItem).LoadFromStream(Stream, Definition.Items[ItemIndex]);
+        end else
+        if TPBDefinition(Definition.Items[ItemIndex]).ItemType = itString then begin
+          NewItem := TPBStringItem.Create;
+          TPBStringItem(NewItem).LoadFromStream(Stream, Definition.Items[ItemIndex])
+        end else
+        if TPBDefinition(Definition.Items[ItemIndex]).ItemType = itMessage then begin
+          NewItem := TPBMessageItem.Create;
+          TPBMessageItem(NewItem).LoadFromStream(Stream, Definition.Items[ItemIndex]);
+        end;
+
+        if ItemMode = imRepeated then begin
+          TPBRepeatedItem(Items[ItemIndex]).Items.Add(NewItem);
+        end else begin
+          TPBItem(Self.Items[ItemIndex]).Assign(NewItem);
+          NewItem.Free;
+        end;
     end else begin
-      if TempItem.ItemType = itVariant then
+      // Skip item data
+      if ItemHead.WireType = wtVariant then
         TempItem.LoadVariantFromStream(Stream)
-      else if TempItem.ItemType = itLengthDelimited then
+      else if ItemHead.WireType = wtLengthDelimited then
         TempItem.LoadLengthDelimitedFromStream(Stream, TempStream);
     end;
@@ -181 +263 @@
 constructor TPBMessageItem.Create;
 begin
-  ItemType := itLengthDelimited;
   Items := TList.Create;
   GenerateHead := True;
@@ -194 +275 @@
   Items.Free;
   inherited Destroy;
+end;
+
+procedure TPBMessageItem.Assign(Source: TPBItem);
+var
+  I: Integer;
+begin
+  if Source is TPBMessageItem then begin
+    GenerateHead := TPBMessageItem(Source).GenerateHead;
+    for I := 0 to Items.Count - 1 do
+      TPBItem(Items[I]).Assign(TPBMessageItem(Source).Items[I]);
+  end;
 end;
 
@@ -215 +307 @@
 end;
 
-procedure TPBItem.SaveHeadToStream(Stream: TStream);
+procedure TPBItem.SaveHeadToStream(Stream: TStream; Definition: TPBDefinition);
 var
   ByteIndex: Byte;
@@ -221 +313 @@
 begin
   with TMemoryStreamEx(Stream) do begin
-    Data := ((Tag and $f) shl 3) or (Integer(ItemType) and $7);
+    Data := ((Definition.Tag and $f) shl 3) or (Integer(Definition.WireType) and $7);
     ByteIndex := 0;
-    while Tag > (1 shl (ByteIndex * 7 + 4)) do begin
+    while Definition.Tag > (1 shl (ByteIndex * 7 + 4)) do begin
       WriteByte(Data or $80);
-      Data := (Tag shr (ByteIndex * 7 + 4)) and $7f;
+      Data := (Definition.Tag shr (ByteIndex * 7 + 4)) and $7f;
       Inc(ByteIndex);
     end;
@@ -232 +324 @@
 end;
 
-procedure TPBItem.LoadHeadFromStream(Stream: TStream);
+function TPBItem.LoadHeadFromStream(Stream: TStream; Definition: TPBDefinition): TPBItemHead;
 var
   Data: Byte;
@@ -238 +330 @@
 begin
   Data := TMemoryStreamEx(Stream).ReadByte;
-  ItemType := TPBItemType(Data and 3);
-  Tag := (Data shr 3) and $f;
+  Result.WireType := TPBWireType(Data and 3);
+  Result.Tag := (Data shr 3) and $f;
   ByteIndex := 0;
   while Data > $7f do begin
     Data := TMemoryStreamEx(Stream).ReadByte;
-    Tag := Tag or ((Data and $7f) shl (ByteIndex * 7 + 4));
+    Result.Tag := Result.Tag or ((Data and $7f) shl (ByteIndex * 7 + 4));
     Inc(ByteIndex);
   end;
 end;
 
-procedure TPBItem.SaveToStream(Stream: TStream);
-begin
-
-end;
-
-procedure TPBItem.LoadFromStream(Stream: TStream);
+procedure TPBItem.SaveToStream(Stream: TStream; Definition: TPBDefinition);
+begin
+
+end;
+
+procedure TPBItem.LoadFromStream(Stream: TStream; Definition: TPBDefinition);
+begin
+
+end;
+
+procedure TPBItem.Clear(Definition: TPBDefinition);
+begin
+
+end;
+
+procedure TPBItem.Assign(Source: TPBItem);
 begin
 
@@ -291 +393 @@
 { TPBIntegerItem }
 
-procedure TPBIntegerItem.SaveToStream(Stream: TStream);
-begin
-  inherited;
-  SaveHeadToStream(Stream);
+procedure TPBIntegerItem.SaveToStream(Stream: TStream; Definition: TPBDefinition);
+begin
+  inherited;
+  SaveHeadToStream(Stream, Definition);
   SaveVariantToStream(Stream, Value);
 end;
 
-procedure TPBIntegerItem.LoadFromStream(Stream: TStream);
+procedure TPBIntegerItem.LoadFromStream(Stream: TStream; Definition: TPBDefinition);
 begin
   inherited;
@@ -306 +408 @@
 constructor TPBIntegerItem.Create;
 begin
-  ItemType := itVariant;
+end;
+
+procedure TPBIntegerItem.Assign(Source: TPBItem);
+begin
+  if Source is TPBIntegerItem then
+    Value := TPBIntegerItem(Source).Value;
 end;
 
 { TPBStringItem }
 
-procedure TPBStringItem.SaveToStream(Stream: TStream);
-begin
-  inherited;
-  SaveHeadToStream(Stream);
+procedure TPBStringItem.SaveToStream(Stream: TStream; Definition: TPBDefinition);
+begin
+  inherited;
+  SaveHeadToStream(Stream, Definition);
   SaveVariantToStream(Stream, Length(Value));
-  TMemoryStreamEx(Stream).Write(Value[1], Length(Value));
-end;
-
-procedure TPBStringItem.LoadFromStream(Stream: TStream);
+  if Length(Value) > 0 then
+    TMemoryStreamEx(Stream).Write(Value[1], Length(Value));
+end;
+
+procedure TPBStringItem.LoadFromStream(Stream: TStream; Definition: TPBDefinition);
 begin
   inherited;
   SetLength(Value, LoadVariantFromStream(Stream));
-  TMemoryStreamEx(Stream).Read(Value[1], Length(Value));
+  if Length(Value) > 0 then
+    TMemoryStreamEx(Stream).Read(Value[1], Length(Value));
 end;
 
 constructor TPBStringItem.Create;
 begin
-  ItemType := itLengthDelimited;
+end;
+
+procedure TPBStringItem.Assign(Source: TPBItem);
+begin
+  if Source is TPBStringItem then
+    Value := TPBStringItem(Source).Value;
+  inherited Assign(Source);
+end;
+
+{ TPBDefinition }
+
+function TPBDefinition.SearchItemByTag(Tag: Integer): Integer;
+var
+  I: Integer;
+begin
+  I := 0;
+  while (I < Items.Count) and (TPBDefinition(Items[I]).Tag <> Tag) do Inc(I);
+  if I < Items.Count then Result := I
+    else Result := -1;
+end;
+
+function TPBDefinition.GetWireType: TPBWireType;
+begin
+  case ItemType of
+    itInteger: Result := wtVariant;
+    itFloat: Result := wt64bit;
+    itDouble: Result := wt32bit;
+    itString: Result := wtLengthDelimited;
+    itMessage: Result := wtLengthDelimited;
+  end;
+end;
+
+constructor TPBDefinition.Create;
+begin
+  Items := TList.Create;
+end;
+
+destructor TPBDefinition.Destroy;
+var
+  I: Integer;
+begin
+  for I := 0 to Items.Count - 1 do
+    TPBDefinition(Items[I]).Destroy;
+  Items.Free;
+  inherited Destroy;
+end;
+
+{ TPBRepeatedItem }
+
+procedure TPBRepeatedItem.Clear(Definition: TPBDefinition);
+var
+  I: Integer;
+begin
+  for I := 0 to Items.Count - 1 do
+    TPBItem(Items[I]).Free;
+  inherited;
+end;
+
+procedure TPBRepeatedItem.SaveToStream(Stream: TStream;
+  Definition: TPBDefinition);
+var
+  I: Integer;
+begin
+  for I := 0 to Items.Count - 1 do begin
+    TPBItem(Items[I]).SaveToStream(Stream, Definition);
+  end;
+end;
+
+procedure TPBRepeatedItem.LoadFromStream(Stream: TStream;
+  Definition: TPBDefinition);
+begin
+  inherited LoadFromStream(Stream, Definition);
+end;
+
+constructor TPBRepeatedItem.Create;
+begin
+  Items := TList.Create;
+end;
+
+destructor TPBRepeatedItem.Destroy;
+var
+  I: Integer;
+begin
+  for I := 0 to Items.Count - 1 do
+    TPBItem(Items[I]).Free;
+  Items.Free;
+  inherited Destroy;
+end;
+
+procedure TPBRepeatedItem.Assign(Source: TPBItem);
+var
+  I: Integer;
+begin
+  if Source is TPBRepeatedItem then begin
+    for I := 0 to Items.Count - 1 do
+      TPBItem(Items[I]).Assign(TPBRepeatedItem(Source).Items[I]);
+  end;
+  inherited Assign(Source);
 end;