patterns.pas

delphi框架

//begin
//  cmd := TCommand.Create(self.iCommandText, self.iParamRecord,
//    self.iParamObject,
//    self.ParamStr, self.iOwner, self.iFreeParam);
//
//  //because the cloned object need iParamRecord and iParamObject not be released
//  //but you must make sure the new cloned Tcommand instance will be disposed
//  self.iFreeParam := false;
//
//  if assigned(iCmdList) then
//  begin
//    for i := 0 to self.iCmdList.Count - 1 do
//    begin
//      cmd.add(TCommand(iCmdList.Items[i]).clone);
//    end;
//  end;
//  result := cmd;
//end;

//End of TCommand---------------------------------------------------------------

// TController

constructor TController.Create;
begin
  inherited;
end;

destructor TController.Destroy;
begin
  pointer(self.iHeadquarters) := nil;
  pointer(iNext) := nil;
  inherited;
end;

//all child class should override this function and has its own doCommand

procedure TController.DoCommand(ACommand: TCommand; const args: TObject = nil);
begin
  //do nothing
end;

procedure TController.DoCommand(ACommand: string; const args: string = '');
begin
  //do nothing
end;

procedure TController.DoCommand(ACommand: string; const args: TObject = nil);
begin
  //do nothing
end;

procedure TController.DoCommand(ACommand: string; const args: pointer = nil);
begin
  //do nothing
end;

procedure TController.DoCommand(ACommand: string);
begin
  //do nothing
end;

function TController.getID: integer;
begin
  result := self._CID;
end;

procedure TController.setID(CID: integer);
begin
  self._CID := CID;
end;

class function TController.NewController: TController;
begin
  result := TController.Create;
end;

procedure TController.setNext(ANext: TController);
begin
  self.iNext := ANext;
end;

procedure TController.SetHeadquarters(AHeadquarters: TController);
begin
  iHeadquarters := AHeadquarters;
end;

function TController.getHeadquarters: TController;
begin
  result := iHeadquarters;
end;

procedure TController.SendCommand(ACommand: string; args: string);
begin
  self.SendCommand(TCommand.Create(ACommand, nil, nil, args));
end;

procedure TController.SendCommand(ACommand: string; args: TObject);
begin
  //don't realease the args when this command released
  self.SendCommand(TCommand.Create(ACommand, nil, args, '', nil, false));
end;

procedure TController.SendCommand(ACommand: string; args: pointer);
begin
  //don't release the args when this command released
  self.SendCommand(TCommand.Create(ACommand, args, nil, '', nil, false));
end;

procedure TController.SendCommand(ACommand: string);
begin
  self.SendCommand(TCommand.Create(ACommand));
end;

procedure TController.SendCommand(ACommand: TCommand; const args: TObject =
  nil);
begin
  if not assigned(ACommand) then
    exit;
  //  Debug('ID=' + intToStr(self.getID) + ' CMD=' + ACommand.getCommandTxt);
  if (ACommand.getDirection = sdGoToHeader) then
  begin
    if (not assigned(self.iHeadquarters)) or
      //I am the header
    (self.getID = self.iHeadquarters.getID) then
      ACommand.setDirection(sdGotoNext)
    else
    begin
      self.iHeadquarters.SendCommand(ACommand, args);
      exit;
    end;
  end;

  //call do command of each controller
  self.DoCommand(ACommand, args);
  self.DoCommand(ACommand.getCommandTxt, ACommand.getParamString);
  self.DoCommand(ACommand.getCommandTxt, ACommand.getParamRecord);
  self.DoCommand(ACommand.getCommandTxt, ACommand.getParamObject);

  if assigned(self.iNext) then
    iNext.SendCommand(acommand, args)
  else
  begin
    if ACommand.getAutoRelease then
    begin
      //ACommand := nil; //and interfaced object can release like this
      freeAndNil(ACommand);
      if args <> nil then
      begin
        args.free;
      end;
    end;
  end;
end;

function TController.getNext: TController;
begin
  result := self.iNext;
end;

//TControlCenter ---------------------------------------------------------------

constructor TControlCenter.Create;
begin
  self.iControllerList := TInterfaceList.Create;
  self.iHeadquarters := TController.Create;
  self.iHeadquarters.SetHeadquarters(self.iHeadquarters);
  iLastController := nil;
  TLogger.getInstance.writeDebug('Control Center initialized!');
  iIDCounter := 0;
  self._CID := -1;
  inherited;
end;

procedure TControlCenter.ClearList;
var
  i: integer;
begin
  for i := 0 to iControllerList.Count - 1 do
  begin
    iControllerList.Items[i] := nil //this will release the object!!!
  end;
  iControllerList.Clear;
end;

destructor TControlCenter.Destroy;
begin
  ClearList;
  freeAndNil(iControllerList);
  freeAndNil(self.iHeadquarters);
  inherited;
end;

procedure TControlCenter.doCommand(ACommand: TCommand; const args: TObject =
  nil);
begin
  //  self.SendCommand(command, args);
end;

procedure TControlCenter.run(const cmd: TCommand = nil);
begin
  Application.Initialize;
  if cmd = nil then
    self.SendCommand(TCommand.Create(CMD_SYSTEM_START))
  else
    self.SendCommand(cmd);
  Application.Run;
end;

procedure TControlCenter.UnRegController(AController: TController);
begin
  self.iControllerList.Remove(AController);
end;

procedure TControlCenter.RegController(AController: TController);
begin
  if application.Terminated or (not assigned(AController)) then
    exit;

  iControllerList.Add(AController);

  inc(self.iIDCounter);
  AController.setID(self.iIDCounter);

  //the first one
  if iControllerList.Count = 1 then
  begin
    self.getHeadquarters.setNext(AController);
  end
  else
  begin
    iLastController.setNext(AController);

  end;
  //不能把Control Center 做为 SetHeadquarters，否则在程序释放的时候会出错
  AController.SetHeadquarters(self.iHeadquarters);
  iLastController := AController;
end;

procedure TControlCenter.writeDebug(info: string);
begin
  TLogger.getInstance.writeDebug(info);
end;

procedure TControlCenter.writeError(info: string);
begin
  TLogger.getInstance.writeError(info);
end;

procedure TControlCenter.turnOnDebugInfo(turnon: boolean);
begin
  TLogger.getInstance.debug := turnon
end;

//test use only
//

constructor TObservable.Create;
begin
  inherited;
  iObservers := TClassList.Create;
  icurrentObject := nil;
end;

destructor TObservable.destroy;
begin
  freeAndNil(iObservers);
  inherited;
end;

procedure TObservable.setCurrentObject(o: TObject);
begin
  self.currentObject := o;
end;

procedure TObservable.RegObserver(observer: IObserver);
begin
  if iObservers = nil then
    iObservers := TClassList.Create;
  iObservers.Add(TClass(observer));
end;

procedure TObservable.Notify(const o: TObject = nil);
var
  i: integer;
  observer: IObserver;
begin
  if iObservers = nil then
    exit;
  if o = nil then
    exit;
  self.setCurrentObject(o);

  for i := 0 to iObservers.Count - 1 do
  begin
    observer := IObserver(iObservers.Items[i]);
    observer.UpdateView(o);
  end;
end;

initialization
  begin
    ControlCenter := TControlCenter.Create;
  end;

finalization
  begin
    freeAndNil(ControlCenter);
  end;

end.