Курсовой проект групп 3341 и 3382 / DMCore / ModelProperties

unit ModelProperties;

interface

  uses
    SerializableObject,
    Classes,
    SysUtils;

  type
    TModelProperty = class(TDMSerializableObject)
    public
      name: string;
      value: string;
      constructor Create(const name, value: string); overload;
      constructor Create(const istream: TStream); overload;
      procedure serializeObject( ostream : TStream ); override;
      procedure deserializeObject( istream : TStream ); override;
    end;
    
    TModelProperties = class(TDMSerializableObject)
    private
      properties: array of TModelProperty;
      count: integer;
      capacity: integer;
      procedure checkCapacity(size: integer);
      procedure checkIndex(index: integer);
      function get_ModelProperty(i: integer): TModelProperty;
      procedure set_ModelPropery(i: integer; const Value: TModelProperty);
      function get_Size: integer;
    public
      constructor Create;
      property ModelProperty[i: integer] : TModelProperty
        read get_ModelProperty
        write set_ModelPropery;
      property Size: integer read get_Size;
      function ByName(const name: string): string;
      procedure Clear;
      procedure Add(const name, value: string); overload;
      procedure Add(modelProperty: TModelProperty); overload;
      function toString: string;
      function toStrings: TStrings;
      {From TDMSerializableObject}
      procedure serializeObject( ostream : TStream ); override;
      procedure deserializeObject( istream : TStream ); override;
      destructor Destroy; override;
    end;

implementation

{ TModelProperties }

  procedure TModelProperties.Add(const name, value: string);
  begin
    Add(TModelProperty.Create(name, value));
  end;

  procedure TModelProperties.Add(modelProperty: TModelProperty);
  begin
    checkCapacity(count + 1);
    properties[count] := modelProperty;
    inc(count);
  end;

  function TModelProperties.ByName(const name: string): string;
  var
    i: Integer;
  begin
    for i := 0 to count - 1 do
    begin
      if properties[i].name = name then
      begin
        Result := properties[i].value;
        Exit;
      end;
    end;
  end;

  procedure TModelProperties.checkCapacity(size: integer);
  begin
    if size > capacity then
    begin
      if size - capacity < 5 then
        capacity := capacity + 5
      else
        capacity := size;
      SetLength(properties, capacity);
    end;
  end;

  procedure TModelProperties.checkIndex(index: integer);
  begin
    if index > count then
      raise Exception.Create('Выход за границы массива свойств');
  end;

  procedure TModelProperties.Clear;
  var
    i: Integer;
  begin
    for i := 0 to count - 1 do FreeandNil(properties[i]);
    count := 0;
  end;

  constructor TModelProperties.Create;
  begin
    capacity := 5;
    count := 0;
    SetLength(properties, capacity);
  end;

  procedure TModelProperties.deserializeObject(istream: TStream);
  var
    i: Integer;
  begin
    inherited;
    Clear;
    deserializeInteger(istream, count);
    checkCapacity(count);
    for i := 0 to count - 1 do Add(TModelProperty.Create(istream));
  end;

  destructor TModelProperties.Destroy;
  begin
    Clear;
  end;

  function TModelProperties.get_ModelProperty(i: integer): TModelProperty;
  begin
    checkIndex(i);
    Result := properties[i];
  end;

  function TModelProperties.get_Size: integer;
  begin
    Result := Count;
  end;

  procedure TModelProperties.serializeObject(ostream: TStream);
  var
    i: Integer;
  begin
    inherited;
    serializeInteger(ostream, count);
    for i := 0 to count - 1 do properties[i].serializeObject(ostream);
  end;

  procedure TModelProperties.set_ModelPropery(i: integer; const Value: TModelProperty);
  begin
    checkIndex(i);
    properties[i] := Value;
  end;

  function TModelProperties.toString: string;
  var
    i: Integer;
  begin
    Result := '';
    if count > 0 then
    begin
      for i := 1 to count - 1 do
        Result := Result + ModelProperty[i].name + ' = '
                  + ModelProperty[i].value + #13;
      SetLength(Result, Length(Result) - 1);
    end;
  end;

  function TModelProperties.toStrings: TStrings;
  var
    i: Integer;
    curResult : TStrings;
  begin
    curResult.Clear;
    if count > 0 then
    begin
      for i := 1 to count - 1 do
        curResult.Add(ModelProperty[i].name + ' = '
                      + ModelProperty[i].value);
    end;
    result := curResult;
  end;

{ TModelProperty }

  constructor TModelProperty.Create(const name, value: string);
  begin
    Self.name := name;
    Self.value := value;
  end;

  constructor TModelProperty.Create(const istream: TStream);
  begin
    deserializeObject(istream);
  end;

  procedure TModelProperty.deserializeObject(istream: TStream);
  begin
    inherited;
    deserializeString(istream, name);
    deserializeString(istream, value);
  end;

  procedure TModelProperty.serializeObject(ostream: TStream);
  begin
    inherited;
    serializeString(ostream, name);
    serializeString(ostream, value);
  end;

end.