source: trunk/UDevice.pas

unit UDevice;

{$mode delphi}

interface

uses
  Classes, SysUtils, URouterboard, fgl;

type
  TContext = class;
  TCommand = class;
  TDevice = class;
  TValue = class;
  TValueDef = class;

  TValueType = (vtString, vtBool, vtInteger);

  { TValue }

  TValue = class
    Def: TValueDef;
    Context: TContext;
    function GetValue: string; virtual;
    procedure SetValue(NewValue: string); virtual;
  end;

  { TValueString }

  TValueString = class(TValue)
    Value: string;
    function GetValue: string; override;
    procedure SetValue(NewValue: string); override;
  end;

  { TValueBool }

  TValueBool = class(TValue)
    Value: Boolean;
    function GetValue: string; override;
    procedure SetValue(NewValue: string); override;
  end;

  { TValueInteger }

  TValueInteger = class(TValue)
    Value: Integer;
    function GetValue: string; override;
    procedure SetValue(NewValue: string); override;
  end;

  TGetValueEvent = function (Value: TValue): string of object;
  TSetValueEvent = procedure (Value: TValue; NewValue: string) of object;

  { TValueStringVirtual }

  TValueStringVirtual = class(TValue)
    DefaultValue: string;
    OnSetValue: TSetValueEvent;
    OnGetValue: TGetValueEvent;
    function GetValue: string; override;
    procedure SetValue(NewValue: string); override;
  end;

  TValueDefs = class;

  { TValues }

  TValues = class(TFPGObjectList<TValue>)
    Context: TContext;
    procedure Init(ValueDefs: TValueDefs);
    function AllReadOnly: Boolean;
    function AddString(Value: string): TValueString;
    function AddBool(Value: Boolean): TValueBool;
    function AddInteger(Value: Integer): TValueInteger;
  end;

  TCommandEvent = function(Sender: TObject; Command: TCommand): string of object;

  TCommand = class
    Name: string;
    Description: string;
    Context: TContext;
    Execute: TCommandEvent;
    IsContext: Boolean;
  end;

  { TCommands }

  TCommands = class(TFPGObjectList<TCommand>)
    Context: TContext;
    procedure SortAll;
    function AddNew(Name, Description: string): TCommand;
    function SearchByName(Name: string): TCommand;
  end;

  TValueDef = class
    Name: string;
    ReadOnly: Boolean;
    //Context: TContext;
    ValueType: TValueType;
  end;

  TValueDefString = class(TValueDef)
    DefaultValue: string;
  end;

  TValueDefInteger = class(TValueDef)
    DefaultValue: Integer;
  end;

  TValueDefBool = class(TValueDef)
    DefaultValue: Boolean;
  end;

  { TValueDefs }

  TValueDefs = class(TFPGObjectList<TValueDef>)
    function AddNew(Name: string; ValueType: TValueType): TValueDef;
    function AddString(Name: string; DefaultValue: string; ReadOnly: Boolean = False): TValueDef;
    function AddBool(Name: string; DefaultValue: Boolean; ReadOnly: Boolean = False): TValueDef;
    function AddInteger(Name: string; DefaultValue: Integer; ReadOnly: Boolean = False): TValueDef;
    function AllReadOnly: Boolean;
    function SearchByName(Name: string): TValueDef;
  end;

  { TContextItem }

  TContextItem = class
    Values: TValues;
    constructor Create;
    destructor Destroy; override;
  end;

  { TContextItems }

  TContextItems = class(TFPGObjectList<TContextItem>)
    function AddNew(ValueDefs: TValueDefs): TContextItem;
  end;

  TContexts = class;
  TContextList = class;
  TContextFields = class;

  { TContext }

  TContext = class
  private
    function CommandGoUp(Sender: TObject; Command: TCommand): string;
    function CommandGoDown(Sender: TObject; Command: TCommand): string;
    function CommandExport(Sender: TObject; Command: TCommand): string; virtual;
  public
    Device: TDevice;
    Name: string;
    Description: string;
    Childs: TContexts;
    Parent: TContext;
    function GetCommands: TCommands; virtual;
    function GetCommandsStartingWith(Text: string): TCommands;
    function GetPath: string;
    constructor Create; virtual;
    destructor Destroy; override;
  end;

  TContextClass = class of TContext;

  { TContextList }

  TContextList = class(TContext)
  private
    procedure ParseParams(Sender: TObject; Item: TContextItem);
  public
    ValueDefs: TValueDefs;
    Items: TContextItems;
    function CommandPrint(Sender: TObject; Command: TCommand): string;
    function CommandExport(Sender: TObject; Command: TCommand): string; override;
    function CommandSet(Sender: TObject; Command: TCommand): string;
    function CommandGet(Sender: TObject; Command: TCommand): string;
    function CommandAdd(Sender: TObject; Command: TCommand): string;
    function CommandRemove(Sender: TObject; Command: TCommand): string;
    function GetCommands: TCommands; override;
    constructor Create; override;
    destructor Destroy; override;
  end;

  { TContextFields }

  TContextFields = class(TContext)
    ValueDefs: TValueDefs;
    Values: TValues;
    function CommandPrint(Sender: TObject; Command: TCommand): string;
    function CommandExport(Sender: TObject; Command: TCommand): string; override;
    function CommandSet(Sender: TObject; Command: TCommand): string;
    function CommandGet(Sender: TObject; Command: TCommand): string;
    function GetCommands: TCommands; override;
    constructor Create; override;
    destructor Destroy; override;
  end;

  { TContexts }

  TContexts = class(TFPGObjectList<TContext>)
    Context: TContext;
    function AddNew(Name, Description: string): TContext;
    function AddCustom(Name, Description: string; ContextClass: TContextClass): TContext;
    function AddList(Name, Description: string): TContextList;
    function AddFields(Name, Description: string): TContextFields;
    function SearchByName(Name: string): TContext;
  end;

  { TDevice }

  TDevice = class
    Routerboard: TRouterboard;
    Identity: string;
    RootContext: TContext;
    function GetVariable(Value: TValue): string;
    constructor Create; virtual;
    destructor Destroy; override;
  end;


implementation

uses
  UTerminal;

{ TContextItem }

constructor TContextItem.Create;
begin
  Values := TValues.Create;
end;

destructor TContextItem.Destroy;
begin
  FreeAndNil(Values);
  inherited Destroy;
end;

{ TValueDefs }

function TValueDefs.AddNew(Name: string; ValueType: TValueType): TValueDef;
begin
  if ValueType = vtInteger then Result := AddInteger(Name, 0)
  else if ValueType = vtString then Result := AddString(Name, '')
  else if ValueType = vtBool then Result := AddBool(Name, False);
end;

function TValueDefs.AddString(Name: string; DefaultValue: string;
  ReadOnly: Boolean): TValueDef;
begin
  Result := TValueDefString.Create;
  Result.ValueType := vtString;
  Result.Name := Name;
  Result.ReadOnly := ReadOnly;
  TValueDefString(Result).DefaultValue := DefaultValue;
  Add(Result);
end;

function TValueDefs.AddBool(Name: string; DefaultValue: Boolean;
  ReadOnly: Boolean): TValueDef;
begin
  Result := TValueDefBool.Create;
  Result.ValueType := vtBool;
  Result.Name := Name;
  Result.ReadOnly := ReadOnly;
  TValueDefBool(Result).DefaultValue := DefaultValue;
  Add(Result);
end;

function TValueDefs.AddInteger(Name: string; DefaultValue: Integer;
  ReadOnly: Boolean): TValueDef;
begin
  Result := TValueDefInteger.Create;
  Result.ValueType := vtInteger;
  Result.Name := Name;
  Result.ReadOnly := ReadOnly;
  TValueDefInteger(Result).DefaultValue := DefaultValue;
  Add(Result);
end;

function TValueDefs.AllReadOnly: Boolean;
var
  I: Integer;
begin
  Result := True;
  for I := 0 to Count - 1 do
    if not Items[I].ReadOnly then begin
      Result := False;
      Break;
    end;
end;

function TValueDefs.SearchByName(Name: string): TValueDef;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (Items[I].Name <> Name) do Inc(I);
  if I < Count then Result := Items[I]
    else Result := nil;
end;

{ TContextFields }

function TContextFields.CommandPrint(Sender: TObject; Command: TCommand
  ): string;
var
  I: Integer;
  Context: TContextFields;
begin
  Context := TContextFields(Command.Context);
  Result := '';
  for I := 0 to Context.ValueDefs.Count - 1 do begin
    Result := Result + Context.ValueDefs[I].Name + ': ' +
      Context.Values[I].GetValue;
    if I < Context.ValueDefs.Count - 1 then
      Result := Result + LineEnding;
  end;
end;

function TContextFields.CommandExport(Sender: TObject; Command: TCommand
  ): string;
var
  I: Integer;
  Values: string;
  Context: TContextFields;
begin
  Result := inherited;
  if Result <> '' then Result := Result + LineEnding;
  Context := TContextFields(Command.Context);
  if Context.ValueDefs.Count > 0 then begin
    Values := '';
    for I := 0 to Context.ValueDefs.Count - 1 do
      Values := Values + Context.ValueDefs[I].Name + '=' +
        Context.Values[I].GetValue + ' ';
    if Values <> '' then
      Result := Result + Command.Context.GetPath + LineEnding +
        'set ' + Values;
  end;
end;

function TContextFields.CommandSet(Sender: TObject; Command: TCommand): string;
var
  ParamName: string;
  ParamValue: string;
  ValueDef: TValueDef;
  Index: Integer;
begin
  Result := '';
  if not (Sender is TTerminal) then Exit;

  Index := Pos('=', TTerminal(Sender).CommandLine);
  if Index > 0 then begin
    ParamName := Copy(TTerminal(Sender).CommandLine, 1, Index - 1);
    ParamValue := Copy(TTerminal(Sender).CommandLine, Index + 1, Length(TTerminal(Sender).CommandLine));
    ValueDef := TContextFields(Command.Context).ValueDefs.SearchByName(ParamName);
    if Assigned(ValueDef) then begin
      Values[ValueDefs.IndexOf(ValueDef)].SetValue(ParamValue);
    end;
  end else TTerminal(Sender).Write('Wrong parameter');
end;

function TContextFields.CommandGet(Sender: TObject; Command: TCommand): string;
begin

end;

function TContextFields.GetCommands: TCommands;
begin
  Result := inherited;
  if ValueDefs.Count > 0 then begin
    if not ValueDefs.AllReadOnly then begin
      with Result.AddNew('set', 'Change item properties') do
        Execute := CommandSet;
      Result.AddNew('edit', '');
    end;
    Result.AddNew('get', 'Gets value of item''s property');
    with Result.AddNew('print', 'Print values of item properties') do
      Execute := CommandPrint;
  end;
end;

constructor TContextFields.Create;
begin
  inherited;
  ValueDefs := TValueDefs.Create();
  Values := TValues.Create;
  Values.Context := Self;
end;

destructor TContextFields.Destroy;
begin
  FreeAndNil(Values);
  FreeAndNil(ValueDefs);
  inherited;
end;

{ TContextList }

procedure TContextList.ParseParams(Sender: TObject; Item: TContextItem);
var
  Index: Integer;
  Terminal: TTerminal;
  Param: string;
  ParamName: string;
  ParamValue: string;
  ValueDef: TValueDef;
begin
  Terminal := TTerminal(Sender);
  while True do begin
    Index := Pos(' ', Terminal.CommandLine);
    if Index > 0 then begin
      Param := Copy(Terminal.CommandLine, 1, Index - 1);
      Terminal.CommandLine := Trim(Copy(Terminal.CommandLine, Index + 1, MaxInt));
    end else begin
      Param := TTerminal(Sender).CommandLine;
      Terminal.CommandLine := '';
    end;
    if Param <> '' then begin
      Index := Pos('=', Param);
      if Index > 0 then begin
        ParamName := Copy(Param, 1, Index - 1);
        ParamValue := Copy(Param, Index + 1, Length(Param));
        ValueDef := ValueDefs.SearchByName(ParamName);
        if Assigned(ValueDef) then begin
          Item.Values[ValueDefs.IndexOf(ValueDef)].SetValue(ParamValue);
        end else begin
          TTerminal(Sender).Write('Unknown parameter ' + ParamName);
          Break;
        end;
      end else begin
        TTerminal(Sender).Write('Parameter without value');
        Break;
      end;
    end else Break;
  end;
end;

function TContextList.CommandPrint(Sender: TObject; Command: TCommand): string;
var
  I: Integer;
  J: Integer;
  Values: string;
  Context: TContextList;
begin
  Result := '';
  Context := TContextList(Command.Context);
  if Context.Items.Count > 0 then begin
    for J := 0 to Context.Items.Count - 1 do begin
      Values := '';
      for I := 0 to Context.ValueDefs.Count - 1 do
        Values := Values + Context.ValueDefs[I].Name + '=' +
          Context.Items[J].Values[I].GetValue + ' ';
      if Values <> '' then
        Result := Result + IntToStr(J) + ' ' + Values;
      if J < Context.Items.Count - 1 then
        Result := Result + LineEnding;
    end;
  end;
end;

function TContextList.CommandExport(Sender: TObject; Command: TCommand): string;
var
  I: Integer;
  J: Integer;
  Values: string;
  Lines: string;
  Context: TContextList;
begin
  Result := inherited;
  if Result <> '' then Result := Result + LineEnding;
  Context := TContextList(Command.Context);
  if Context.Items.Count > 0 then begin
    Lines := '';
    for J := 0 to Context.Items.Count - 1 do begin
      Values := '';
      for I := 0 to Context.ValueDefs.Count - 1 do
        Values := Values + Context.ValueDefs[I].Name + '=' +
          Context.Items[J].Values[I].GetValue + ' ';
      if Values <> '' then
        Lines := Lines + 'add ' + Values;
      if J < Context.Items.Count - 1 then
        Lines := Lines + LineEnding;
    end;
    if Lines <> '' then
      Result := Result + Command.Context.GetPath + LineEnding +
        Lines;
  end;
end;

function TContextList.CommandSet(Sender: TObject; Command: TCommand): string;
var
  Index: Integer;
  Context: TContextList;
  ItemIndex: Integer;
  Item: TContextItem;
begin
  Result := '';
  if not (Sender is TTerminal) then Exit;

  Context := TContextList(Command.Context);

  Index := Pos(' ', TTerminal(Sender).CommandLine);
  if Index >= 0 then begin
    ItemIndex := StrToInt(Copy(TTerminal(Sender).CommandLine, 1, Index - 1));
    TTerminal(Sender).CommandLine := Trim(Copy(TTerminal(Sender).CommandLine, Index + 1, MaxInt));
    if (ItemIndex > 0) and (ItemIndex < Context.Items.Count) then begin
      Item := Context.Items[ItemIndex];
      ParseParams(Sender, Item);
    end;
  end else TTerminal(Sender).Write('no such item');
end;

function TContextList.CommandGet(Sender: TObject; Command: TCommand): string;
begin

end;

function TContextList.CommandAdd(Sender: TObject; Command: TCommand): string;
var
  NewItem: TContextItem;
  Context: TContextList;
begin
  Result := '';
  if not (Sender is TTerminal) then Exit;

  Context := TContextList(Command.Context);
  NewItem := TContextItem.Create;
  NewItem.Values.Init(ValueDefs);
  ParseParams(Sender, NewItem);
  Context.Items.Add(NewItem);
end;

function TContextList.CommandRemove(Sender: TObject; Command: TCommand): string;
var
  Context: TContextList;
  Index: Integer;
begin
  Result := '';
  if not (Sender is TTerminal) then Exit;
  Context := TContextList(Command.Context);
  Index := StrToInt(TTerminal(Sender).CommandLine);
  if (Index >= 0) and (Index < Context.Items.Count) then begin
    Context.Items.Delete(Index);
  end else TTerminal(Sender).Write('no such item');
end;

function TContextList.GetCommands: TCommands;
begin
  Result := inherited;
  if ValueDefs.Count > 0 then begin
    if not ValueDefs.AllReadOnly then begin
      with Result.AddNew('add', 'Create a new item') do
        Execute := CommandAdd;
      with Result.AddNew('set', 'Change item properties') do
        Execute := CommandSet;
      Result.AddNew('edit', '');
      Result.AddNew('remove', 'Remove items');
    end;
    Result.AddNew('get', 'Gets value of item''s property');
    with Result.AddNew('print', 'Print values of item properties') do
      Execute := CommandPrint;
  end;
end;

constructor TContextList.Create;
begin
  inherited;
  ValueDefs := TValueDefs.Create();
  Items := TContextItems.Create;
end;

destructor TContextList.Destroy;
begin
  FreeAndNil(Items);
  FreeAndNil(ValueDefs);
  inherited;
end;

{ TContextItems }

function TContextItems.AddNew(ValueDefs: TValueDefs): TContextItem;
begin
  Result := TContextItem.Create;
  Result.Values.Init(ValueDefs);
  Add(Result);
end;

{ TValueStringVirtual }

function TValueStringVirtual.GetValue: string;
begin
  if Assigned(OnGetValue) then
    Result := OnGetValue(Self);
end;

procedure TValueStringVirtual.SetValue(NewValue: string);
begin
  if Assigned(OnSetValue) then
    OnSetValue(Self, NewValue);
end;

{ TContexts }

function TContexts.SearchByName(Name: string): TContext;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (Items[I].Name <> Name) do Inc(I);
  if I < Count then Result := Items[I]
    else Result := nil;
end;

{ TValueBool }

function TValueBool.GetValue: string;
begin
  Result := BoolToStr(Value);
end;

procedure TValueBool.SetValue(NewValue: string);
begin
  Value := StrToBool(NewValue);
end;

{ TValueString }

function TValueString.GetValue: string;
begin
  Result := Value;
end;

procedure TValueString.SetValue(NewValue: string);
begin
  Value := NewValue;
end;

{ TValue }

function TValue.GetValue: string;
begin
  Result := '';
end;

procedure TValue.SetValue(NewValue: string);
begin
end;

{ TValueInteger }

function TValueInteger.GetValue: string;
begin
  Result := IntToStr(Value);
end;

procedure TValueInteger.SetValue(NewValue: string);
var
  Multiply: Integer;
begin
  Multiply := 1;
  if NewValue[Length(NewValue)] = 'k' then begin
    Multiply := 1000;
    Delete(NewValue, Length(NewValue), 1);
  end else
  if NewValue[Length(NewValue)] = 'M' then begin
    Multiply := 1000000;
    Delete(NewValue, Length(NewValue), 1);
  end;
  Value := StrToInt(NewValue) * Multiply;
end;

{ TValues }

procedure TValues.Init(ValueDefs: TValueDefs);
var
  I: Integer;
begin
  Clear;
  for I := 0 to ValueDefs.Count - 1 do begin
    if ValueDefs[I].ValueType = vtInteger then
      AddInteger(TValueDefInteger(ValueDefs[I]).DefaultValue)
    else if ValueDefs[I].ValueType = vtString then
      AddString(TValueDefString(ValueDefs[I]).DefaultValue)
    else if ValueDefs[I].ValueType = vtBool then
      AddBool(TValueDefBool(ValueDefs[I]).DefaultValue);
  end;
end;

function TValues.AllReadOnly: Boolean;
begin

end;

function TValues.AddString(Value: string): TValueString;
begin
  Result := TValueString.Create;
  Result.Context := Context;
  Result.Value := Value;
  Self.Add(Result);
end;

function TValues.AddBool(Value: Boolean): TValueBool;
begin
  Result := TValueBool.Create;
  Result.Context := Context;
  Result.Value := Value;
  Self.Add(Result);
end;

function TValues.AddInteger(Value: Integer): TValueInteger;
begin
  Result := TValueInteger.Create;
  Result.Context := Context;
  Self.Add(Result);
end;

{ TCommands }

function SortByName(const Item1, Item2: TCommand): Integer;
begin
  if Item1.Name > Item2.Name then Result := 1
  else if Item1.Name < Item2.Name then Result := -1
  else Result := 0;
end;

procedure TCommands.SortAll;
begin
  Sort(SortByName);
end;

function TCommands.AddNew(Name, Description: string): TCommand;
begin
  Result := TCommand.Create;
  Result.Context := Context;
  Result.Name := Name;
  Result.Description := Description;
  Result.Context := Context;
  Self.Add(Result);
end;

function TCommands.SearchByName(Name: string): TCommand;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (Items[I].Name <> Name) do Inc(I);
  if I < Count then Result := Items[I]
    else Result := nil;
end;

{ TContext }

function TContext.CommandGoUp(Sender: TObject; Command: TCommand): string;
begin
  Result := '';
  if Sender is TTerminal then
  if Assigned(TTerminal(Sender).Context.Parent) then
    TTerminal(Sender).Context := TTerminal(Sender).Context.Parent;
end;

function TContext.CommandGoDown(Sender: TObject; Command: TCommand): string;
var
  NewContext: TContext;
begin
  Result := '';
  if Sender is TTerminal then begin
    NewContext := TTerminal(Sender).Context.Childs.SearchByName(Command.Name);
    if Assigned(NewContext) then
      TTerminal(Sender).Context := NewContext;
  end;
end;

function TContext.CommandExport(Sender: TObject; Command: TCommand): string;
var
  I: Integer;
  SubCommand: TCommand;
  Output: string;
begin
  Result := '';
  SubCommand := TCommand.Create;
  for I := 0 to Command.Context.Childs.Count - 1 do begin
    SubCommand.Context := Command.Context.Childs[I];
    Output := Command.Context.Childs[I].CommandExport(Sender, SubCommand);
    if Output <> '' then begin
      if Result <> '' then
        Result := Result + LineEnding;
      Result := Result + Output;
    end;
  end;
  SubCommand.Free;
end;

function TContext.GetCommands: TCommands;
var
  ParentName: string;
  I: Integer;
begin
  Result := TCommands.Create;
  Result.Context := Self;
  if Assigned(Parent) then begin
    if Parent.Name <> '' then ParentName := Parent.Name
      else ParentName := 'root';
    with Result.AddNew('..', 'go up to ' + ParentName) do begin
      Execute := CommandGoUp;
      IsContext := True;
    end;
  end;
  for I := 0 to Childs.Count - 1 do begin
    with Result.AddNew(Childs[I].Name, Childs[I].Description) do begin
      Execute := CommandGoDown;
      IsContext := True;
    end;
  end;
  with Result.AddNew('export', 'Print or save an export script that can be used to restore configuration') do
    Execute := CommandExport;
end;

function TContext.GetCommandsStartingWith(Text: string): TCommands;
var
  I: Integer;
begin
  Result := GetCommands;
  for I := Result.Count - 1 downto 0 do
    if Copy(Result[I].Name, 1, Length(Text)) <> Text then
      Result.Delete(I);
end;

function TContext.GetPath: string;
var
  ParentPath: string;
begin
  Result := Name;
  if Assigned(Parent) then begin
    ParentPath := Parent.GetPath;
    if ParentPath <> '' then Result := ParentPath + ' ' + Result;
  end;
  if (Length(Result) > 0) and (Result[1] <> '/') then Result := '/' + Result;
end;

function TContexts.AddNew(Name, Description: string): TContext;
begin
  Result := TContext.Create;
  Result.Name := Name;
  Result.Description := Description;
  Result.Parent := Context;
  Add(Result);
end;

function TContexts.AddCustom(Name, Description: string;
  ContextClass: TContextClass): TContext;
begin
  Result := ContextClass.Create;
  Result.Name := Name;
  Result.Description := Description;
  Result.Parent := Context;
  Add(Result);
end;

function TContexts.AddList(Name, Description: string): TContextList;
begin
  Result := TContextList.Create;
  Result.Name := Name;
  Result.Description := Description;
  Result.Parent := Context;
  Add(Result);
end;

function TContexts.AddFields(Name, Description: string): TContextFields;
begin
  Result := TContextFields.Create;
  Result.Name := Name;
  Result.Description := Description;
  Result.Parent := Context;
  Add(Result);
end;

constructor TContext.Create;
begin
  Childs := TContexts.Create;
  Childs.Context := Self;
  Parent := nil;
end;

destructor TContext.Destroy;
begin
  FreeAndNil(Childs);
  inherited Destroy;
end;

{ TDevice }

function TDevice.GetVariable(Value: TValue): string;
begin
  if (Value.Context.GetPath = '/system identity') and (Value.Def.Name = 'name') then
    Result := Identity
  else if (Value.Context.GetPath = '/system routerboard') and (Value.Def.Name = 'model') then
    Result := Routerboard.Model
  else Result := '';
end;

constructor TDevice.Create;
begin
  Routerboard := TRouterboard.Create;
  RootContext := TContext.Create;
  RootContext.Device := Self;
end;

destructor TDevice.Destroy;
begin
  FreeAndNil(Routerboard);
  FreeAndNil(RootContext);
  inherited Destroy;
end;

end.