以前出过李维老师的一本书,<<面向对象实践指南c#版>>,我先后使用c++,java语言改写了一遍,这里列出c++改写的主要的类:

======================================================================

TPFMTask:

class TPFMTask{
   protected:
      TPFMSchedule *pFSchedule;
   TPFMConfig *pFConfig;
   vector<void *> FHandlers;
   virtual vector<void *> CreateHandlersFromConfig(TPFMConfig aConfig);
   void ApplyHandlersToTargets(TPFMConfig aConfig, vector<void *> _FHandlers);
   void BroadCastHandlers(TCandidate aCandidate,vector<void *> _FHandlers);
   public:
   TPFMTask();
   virtual bool Execute(TPFMSchedule aSchedule, TPFMConfig aConfig);
};

#include "TPFMTask.h"

TPFMTask::TPFMTask()
{
 pFSchedule=NULL;
 pFConfig=NULL;
 FHandlers.clear();
}

/*虚函数:动态绑定*/
vector<void *> TPFMTask::CreateHandlersFromConfig(TPFMConfig aConfig)
{
    vector<void *> handlerList;
 handlerList.clear();
 /*这是最简单的一种,可能会有多个<handler>的子标签*/
 TPFMHandler *pTPFMHandler=TPFMHandlerFactory::GetTPFMHandler(aConfig.GetHandler());
    handlerList.push_back(pTPFMHandler);
 pTPFMHandler=TPFMHandlerFactory::GetTPFMHandler(aConfig.GetDestination());
 handlerList.push_back(pTPFMHandler);
 return handlerList;
}

void TPFMTask::BroadCastHandlers(TCandidate aCandidate,vector<void *> _FHandlers)
{
 vector<byte> baTarget;
 baTarget.clear();
 vector<void *>::iterator iter=_FHandlers.begin();
 while(iter!=_FHandlers.end()){
  TPFMHandler *pTPFMHandler=(TPFMHandler*)(*iter);
        pTPFMHandler->Perform(aCandidate,baTarget);
 }
}

void TPFMTask::ApplyHandlersToTargets(TPFMConfig aConfig, vector<void *> _FHandlers)
{
    //应该使用TFinder,但这里做了简化
 TFileFinder *pFileFinder=NULL;
 pFileFinder=new TFileFinder(aConfig);
    TFileFinderEnumerator *pFileFinderEnumerator=pFileFinder->GetEnumerator();
 while(pFileFinderEnumerator->MoveNext()){
       TCandidate candidateTmp=pFileFinderEnumerator->Current();
       BroadCastHandlers(candidateTmp,_FHandlers);
 }
 delete pFileFinderEnumerator;
 delete pFileFinder;
}

/*虚函数:动态绑定*/
bool TPFMTask::Execute(TPFMSchedule aSchedule, TPFMConfig aConfig)
{
 if (FHandlers.size()>0){
  FHandlers.clear();
 }
 if (aSchedule.GetExt()!=""){
  pFSchedule=&aSchedule;
 }
    pFConfig=&aConfig;
 return true;
}

=======================================================================

TPFMManager:

class TPFMManager
{
   private:
   TPFMConfigManager *pTPFMConfigManager;
   TPFMScheduleManager *pTPFMScheduleManager;
   void CreateProcessors();
   int GetConfigCount();
   int GetScheduleCount();
   protected:
   XMLNode rootNode;
   string configurationFile;
   string scheduleFile;
   virtual bool ProcessConfiguration();
   void CreateXmlNode(string sXMLFile);
   void LoadPFMFile(string sFileName);
   public:
      vector<TPFMManager *> processorList;
   int configNodeSeq;
   int scheduleNodeSeq;
      void RegisterProcessor(TPFMManager *pTPFMManager,TPFMManager *pTPFMManagerOther);
   bool ProcessConfigurations();
   int ConfigCount();
   int ScheduleCount();
   TPFMConfig getConfig(int index);
   TPFMSchedule getSchedule(int index);
   virtual void * GetNextInstance(){return NULL;};
   bool Perform(TPFMManager *pCaller, string sFileName, vector<void *> &collector);
   TPFMManager(){};
   TPFMManager(string sConfigFile, string sScheduleFile);
   TPFMConfig GetConfigFromSchedule(TPFMSchedule aSchedule);
   vector<void *> FindScheduledObjects(string dt);
};

class TPFMConfigManager: public TPFMManager
{
   private:
      vector<void *> configs;
   TPFMConfig GetItem(int index);
   int GetConfigCount();
   TPFMConfig *GetNextConfig();
   TPFMManager *pBaseTPFMManager;
   protected:
   bool ProcessConfiguration();
   public:
   TPFMConfigManager(string _configFile,TPFMManager *pTPFMManager);
   TPFMConfig operator[](int index);
   int Count();
   void * GetNextInstance();
   vector<void *> GetConfigs();
};

class TPFMScheduleManager: TPFMManager
{
   private:
      vector<void *> schedules;
   TPFMSchedule GetItem(int index);
   int GetScheduleCount();
   TPFMSchedule *GetNextSchedule();
   TPFMManager *pBaseTPFMManager;
   protected:
   bool ProcessConfiguration();
   public:
   TPFMScheduleManager(string _scheduleFile,TPFMManager *pTPFMManager);
   TPFMSchedule operator[](int index);
   int Count();
   void * GetNextInstance();
   vector<void *> GetSchedules();
};

#include "TPFMManager.h"

TPFMManager::TPFMManager(string sConfigFile, string sScheduleFile)
{
    if (sConfigFile != "")
  configurationFile= sConfigFile;
 if (sScheduleFile != "")
  scheduleFile= sScheduleFile;
}

void TPFMManager::CreateProcessors()
{
 if (pTPFMConfigManager==NULL){
  pTPFMConfigManager= new TPFMConfigManager(configurationFile,this);
 }
 if (pTPFMScheduleManager==NULL){
  pTPFMScheduleManager= new TPFMScheduleManager(scheduleFile,this);
 }
}

bool TPFMManager::ProcessConfigurations()
{
 pTPFMConfigManager=NULL;
 pTPFMScheduleManager=NULL;
 CreateProcessors();   
 return ProcessConfiguration();
}

int TPFMManager::GetConfigCount()
{
 return pTPFMConfigManager->Count();
}

int TPFMManager::GetScheduleCount()
{
 return pTPFMScheduleManager->Count();
}

int TPFMManager::ScheduleCount()
{
 return GetScheduleCount();
}

bool TPFMManager::ProcessConfiguration()
{
 bool bResult = false;
 vector<TPFMManager *>::iterator iter=processorList.begin();
 while(iter!=processorList.end()){
          TPFMManager *pManager=*iter;
    bResult = (pManager->ProcessConfiguration())|| bResult;
    iter++;
 }
 return bResult;
}

void TPFMManager::RegisterProcessor(TPFMManager *pTPFMManager,TPFMManager *pTPFMManagerOther)
{
 if (count(pTPFMManagerOther->processorList.begin(),pTPFMManagerOther->processorList.end(),pTPFMManager)==0){
     pTPFMManagerOther->processorList.push_back(pTPFMManager);
 }
}

void TPFMManager::CreateXmlNode(string sXMLFile)
{
 string lineBuf="",xmlBuf="";
 ifstream initFile(sXMLFile.c_str(),ios::in );
 bool fitstLine=true;
 while (getline(initFile,lineBuf,'/n')) {
  if (fitstLine==true){
   fitstLine=false;
   continue;
  }
  xmlBuf.append(trim(lineBuf));
 }
    rootNode = XMLNode::parseString((const char*)xmlBuf.c_str(),"Targets");
 if (rootNode.isEmpty()){
  rootNode = XMLNode::parseString((const char*)xmlBuf.c_str(),"Schedules");
 }
}

void TPFMManager::LoadPFMFile(string sFileName)
{
    CreateXmlNode(sFileName);
}

int TPFMManager::ConfigCount()
{
 return GetConfigCount();
}

TPFMConfig TPFMManager::getConfig(int index)
{
    return (*pTPFMConfigManager)[index];
}

TPFMSchedule TPFMManager::getSchedule(int index)
{
    return (*pTPFMScheduleManager)[index];
}

bool TPFMManager::Perform(TPFMManager *pCaller, string sFileName, vector<void *> &collector)
{
    LoadPFMFile(sFileName);
 collector.clear();
 while (true){
  void *p=pCaller->GetNextInstance();
     if (p!=NULL){
   collector.push_back(p);
  }else{
   break;
  }
 }
    return true;
}

TPFMConfig TPFMManager::GetConfigFromSchedule(TPFMSchedule aSchedule)
{
 vector<void *> vecConfigs=pTPFMConfigManager->GetConfigs();
 vector<void *>::iterator iter=vecConfigs.begin();
 while(iter!=vecConfigs.end()){
  TPFMConfig *pTPFMConfig=(TPFMConfig *)*iter;
  if (pTPFMConfig->GetExt()==aSchedule.GetExt()){
   return *pTPFMConfig;
  }
  iter++;
 }
}

TPFMConfig TPFMConfigManager::GetItem(int index)
{
 if (index<GetConfigCount()){
  return *((TPFMConfig *)configs[index]);
 }
}

vector<void *> TPFMConfigManager::GetConfigs()
{
 return configs;
}

int TPFMConfigManager::GetConfigCount()
{
    return configs.size();
}

TPFMConfig * TPFMConfigManager::GetNextConfig()
{
 string ext = "";
 string location = "";
    string subDirectory = "";
 string unit = "";
 string remove = "";
 string handler = "";
 string destination = "";
 string dir = "";
 string connectionSting = "";
 XMLNode typeXMLNode=rootNode.getChildNode(pBaseTPFMManager->configNodeSeq);
 if (!typeXMLNode.isEmpty()){
  XMLNode tempNode=typeXMLNode.getChildNode("EXT");
  if (tempNode.getText()!=NULL){
   ext=string(tempNode.getText());
  }
  tempNode=typeXMLNode.getChildNode("LOCATION");
  if (tempNode.getText()!=NULL){
   location=string(tempNode.getText());
  }
  tempNode=typeXMLNode.getChildNode("SUBDIRECTORY");
  if (tempNode.getText()!=NULL){
   subDirectory=string(tempNode.getText());
  }
  tempNode=typeXMLNode.getChildNode("UNIT");
  if (tempNode.getText()!=NULL){
   unit=string(tempNode.getText());
  }
  tempNode=typeXMLNode.getChildNode("REMOVE");
  if (tempNode.getText()!=NULL){
   remove=string(tempNode.getText());
  }
  tempNode=typeXMLNode.getChildNode("HANDLER");
  if (tempNode.getText()!=NULL){
   handler=string(tempNode.getText());
  }
  tempNode=typeXMLNode.getChildNode("DESTINATION");
  if (tempNode.getText()!=NULL){
   destination=string(tempNode.getText());
  }
  tempNode=typeXMLNode.getChildNode("DIR");
  if (tempNode.getText()!=NULL){
   dir=string(tempNode.getText());
  }
  tempNode=typeXMLNode.getChildNode("CONNECTIONSTRING");
  if (tempNode.getText()!=NULL){
   connectionSting=string(tempNode.getText());
  }
  TPFMConfig *pTPFMConfig=new TPFMConfig(ext,location,subDirectory,unit,remove,
   handler,destination,dir,connectionSting);
  pBaseTPFMManager->configNodeSeq++;
  return pTPFMConfig;
 }else{
  return NULL;
 }
}

bool TPFMConfigManager::ProcessConfiguration()
{
    return Perform(this, configurationFile, configs);
}

TPFMConfig TPFMConfigManager::operator[](int index)
{
 return GetItem(index);
}

TPFMConfigManager::TPFMConfigManager(string _configFile,TPFMManager *pTPFMManager)
{
 if (_configFile!= ""){
  configurationFile =_configFile;
 }
 configs.clear();
 pBaseTPFMManager=pTPFMManager;
 pBaseTPFMManager->configNodeSeq=0;
 RegisterProcessor(this,pBaseTPFMManager);
}

int TPFMConfigManager::Count()
{
 return GetConfigCount();
}

void * TPFMConfigManager::GetNextInstance()
{
 return GetNextConfig();
}

TPFMSchedule TPFMScheduleManager::GetItem(int index)
{
 if (index<GetScheduleCount()){
  return *((TPFMSchedule *)schedules[index]);
 }
}

vector<void *> TPFMScheduleManager::GetSchedules()
{
 return schedules;
}

int TPFMScheduleManager::GetScheduleCount()
{
    return schedules.size();
}

TPFMSchedule * TPFMScheduleManager::GetNextSchedule()
{
 string ext = "";
    string time="";
 string interval="";
 XMLNode schedulesXMLNode=rootNode.getChildNode(pBaseTPFMManager->scheduleNodeSeq);
 if (!schedulesXMLNode.isEmpty()){
  XMLNode tempNode=schedulesXMLNode.getChildNode("Ext");
  if (tempNode.getText()!=NULL){
   ext=string(tempNode.getText());
  }
        tempNode=schedulesXMLNode.getChildNode("Time");
  if (tempNode.getText()!=NULL){
   time=string(tempNode.getText());
  }
  tempNode=schedulesXMLNode.getChildNode("Interval");
  if (tempNode.getText()!=NULL){
   interval=string(tempNode.getText());
  }
  TPFMSchedule *pTPFMSchedule=new TPFMSchedule(ext,time,interval);
  pBaseTPFMManager->scheduleNodeSeq++;
  return pTPFMSchedule;
 }else{
  return NULL;
 }
}

bool TPFMScheduleManager::ProcessConfiguration()
{
    return Perform(this, scheduleFile,schedules);
}

TPFMSchedule TPFMScheduleManager::operator[](int index)
{
 return GetItem(index);
}

TPFMScheduleManager::TPFMScheduleManager(string _scheduleFile,TPFMManager *pTPFMManager)
{
 if (_scheduleFile!= ""){
  scheduleFile =_scheduleFile;
 }
 schedules.clear();
 pBaseTPFMManager=pTPFMManager;
 pBaseTPFMManager->scheduleNodeSeq=0;
 RegisterProcessor(this,pBaseTPFMManager);
}

int TPFMScheduleManager::Count()
{
 return GetScheduleCount();
}

void * TPFMScheduleManager::GetNextInstance()
{
 return GetNextSchedule();
}

vector<void *> TPFMManager::FindScheduledObjects(string dt)
{
   vector<void *> scheduleList;
   scheduleList.clear();
   for (int i= 0;i<ScheduleCount();i++){
  TPFMSchedule schedule=getSchedule(i);
  /*没有判断时间间隔,简化为直接处理*/
        scheduleList.push_back((TPFMSchedule*)(&schedule));
   }
   return scheduleList;
}

=======================================================================

TPFMHandlerFactory:

class TPFMHandlerFactory{
   private:
   static TPFMHandlerMap *handlerMap;
   static TPFMHandler* RegisterHandler(string handlerName);
   static Mutex handlerMapMutex;
   public:
   TPFMHandlerFactory(){};
      static TPFMHandler * GetTPFMHandler(string handlerName);
   static void DestoryHandler();
};

#include "TPFMHandlerFactory.h"

TPFMHandlerMap* TPFMHandlerFactory::handlerMap = NULL; //map初始化
Mutex TPFMHandlerFactory::handlerMapMutex;

TPFMHandler* TPFMHandlerFactory::RegisterHandler(string handlerName)
{
   TPFMHandler *pHandler=NULL;
   if (handlerName=="TPFMFileHandler"){
    pHandler=new TPFMFileHandler();
   }else if (handlerName=="TPFMZipHandler"){
    pHandler=new TPFMZipHandler();
   }else if (handlerName=="TPFMUnZipHandler"){
    pHandler=new TPFMUnZipHandler();
   }
   (*handlerMap)[handlerName]=pHandler;
   return pHandler;
}

TPFMHandler * TPFMHandlerFactory::GetTPFMHandler(string handlerName)
{
   TPFMHandler *pHandler=NULL;
   ScopedLock lock(handlerMapMutex);
   if (handlerMap==NULL){
    handlerMap=new map<string,TPFMHandler*>;
   }
   TPFMHandlerMap::iterator it=handlerMap->find(handlerName);
   if (it==handlerMap->end()){
    pHandler=RegisterHandler(handlerName);
    return pHandler;
   }else{
    return (*handlerMap)[handlerName];
   }
}

void TPFMHandlerFactory::DestoryHandler()
{
 TPFMHandlerMap::iterator itDel=handlerMap->begin();
 while(itDel!=handlerMap->end()){
  delete itDel->second;
  itDel++;
 }
 delete handlerMap;
}

==================================================================

TPFMCoordinator:

class TPFMCoordinator{
   private:
      TPFMManager *pFpfmManager;
      TPFMTaskDispatcher *pTPFMTaskDispatcher;
   void DoSetups();
   public:
      TPFMCoordinator(string dirOne,string dirTwo);
   void DoSpecifiedTask(TPFMConfig aConfig);
   void DoScheduledTask(string dt);
      TPFMManager * GetTPFMManager();
};

#include "TPFMCoordinator.h"

TPFMCoordinator::TPFMCoordinator(string dirOne,string dirTwo)
{
   pFpfmManager=NULL;
   pFpfmManager=new TPFMManager(dirOne,dirTwo);
   pTPFMTaskDispatcher=NULL;
   pTPFMTaskDispatcher=new TPFMTaskDispatcher();
   DoSetups();
}

void TPFMCoordinator::DoSetups()
{
   pFpfmManager->ProcessConfigurations();
}

TPFMManager* TPFMCoordinator::GetTPFMManager()
{
 return pFpfmManager;
}

void TPFMCoordinator::DoSpecifiedTask(TPFMConfig aConfig)
{
   pTPFMTaskDispatcher->DoSpecifiedTask(*pFpfmManager,aConfig);
}

void TPFMCoordinator::DoScheduledTask(string dt)
{
 vector<void *> scheduledList;
 scheduledList.clear();
 scheduledList=pFpfmManager->FindScheduledObjects(dt);
 pTPFMTaskDispatcher->DoScheduledTask(*pFpfmManager,scheduledList);
}

==================================================================

TFileFinderEnumerator:

class TFileFinderEnumerator{
   private:
      int index;
   TFileFinder *pFileFinder;
   public:
   TFileFinderEnumerator(TFileFinder *_pFileFinder);
   bool MoveNext();
   TCandidate GetCurrent();
   TCandidate Current();
   void Reset();
};

#include "TFileFinderEnumerator.h"

TFileFinderEnumerator::TFileFinderEnumerator(TFileFinder *_pFileFinder)
{
   pFileFinder=_pFileFinder;
   index=-1;
}

bool TFileFinderEnumerator::MoveNext()
{
 bool bResult=index<pFileFinder->GetCount();
 if (bResult==true){
  index++;
 }
 return bResult;
}

TCandidate TFileFinderEnumerator::GetCurrent()
{
 return (*pFileFinder)[index];
}

TCandidate TFileFinderEnumerator::Current()
{
 return GetCurrent();
}

void TFileFinderEnumerator::Reset()
{
 index=-1;
}

c++改写李维面向对象实践指南相关推荐

  1. 读《道法自然-面向对象实践指南》

    读了几个段落,觉得这是一本很用心也写的很好的书,值得我好好看,也顺便把一些写得好的地方记录下来. 第四章 模式:变化之美VS永恒之道 p70:很多人讨厌需求的变化,他们一旦把设计或者编码做完,就求神拜 ...

  2. 阿里智能运维实践｜阿里巴巴DevOps实践指南

    编者按:本文源自阿里云云效团队出品的<阿里巴巴DevOps实践指南>前往:https://developer.aliyun.com/topic/devops,下载完整版电子书,了解阿里十年 ...

  3. 《javascript面向对象编程指南》读书笔记

    <javascript面向对象编程指南>读书笔记 <javascript面向对象编程指南>读书笔记 第一章 面向对象的JavaScript 第二章 基本数据类型与流程控制 变量 ...

  4. 阿里巴巴DevOps实践指南 | 为什么DevOps的必然趋势是BizDevOps？

    简介:从精益思想出发,我们可以看到DevOps的必然发展方向,那就是向业务侧延伸.业务是产品开发和运维的源头,完整的价值流必须从源头开始.这不是预测,而是正在发生的事实 编者按:本文源自阿里云云效团队 ...

  5. 现货！《PHP7实践指南：o2o网站与App后台开发》京东天猫有售

    终于发售了,啥也不想说了,喜欢的或需要的就点击 链接 进去购买吧. 另外此书将作为 2017 PHP全球开发者大会 现场活动用书 天猫购书 包邮 PHP7实践指南:O2O网站与App后台开发 数据库设 ...

  6. 《App架构师实践指南》：移动开发的进阶指南

    文章主要内容: 什么是 app 架构师 这本书主要内容 读完感受 什么是 App 架构师 成为"架构师"是许多程序员的梦想,当然也包括我,在工作的几年里,我见过很多架构师,他们在设 ...

  7. 深度学习「CV」学习实践指南！

    ↑↑↑关注后"星标"Datawhale 每日干货 & 每月组队学习,不错过 Datawhale干货 作者:黄星源.樊亮.陈桦.斯国一 深度学习的发展不仅突破了许多视觉难题, ...

  8. 阿里巴巴DevOps实践指南 | 数字化转型下，DevOps的根本目标是什么？

    简介:数字化转型是信息技术与产业的结合.需要转型的不仅仅是各个传统的产业,也包含信息产业本身,如互联网公司.DevOps 是数字化转型的重要组成部分,DevOps 的体系和实践也必须服务于数字化转型的 ...

  9. 重磅发布！阿里云云效《阿里巴巴DevOps实践指南》

    简介:6月23日,在2021阿里巴巴研发效能峰会上,由阿里云云效团队20位专家共同撰写的<阿里巴巴DevOps实践指南>(以下简称指南)正式对外发布.本指南是阿里云云效团队对过去十年阿里巴 ...

最新文章

  1. python实现全景图片拼接
  2. 前牙正常覆盖是多少_个性化舌侧矫治器的前牙转矩控制技巧——赵志河教授
  3. 基于verilog流水灯设计
  4. 笔记整理——linux程序设计
  5. 微型计算机中的奔四指的是,2015云南省计算机等级考试二级理论考试试题及答案...
  6. GNU make manual 翻译( 一百五十五)
  7. Django中的视图(view)
  8. GDAL源码剖析（八）之编译GEOS和PROJ4库
  9. 单机按钮来图片轮播_原生js如何实现轮播图效果？
  10. Java语言中的泛型
  11. 半导体、芯片、集成电路、无尘车间具体释义及区别
  12. 软件设计师中级-数据库系统
  13. 信道、频段带宽等术语简介
  14. hihocoder 网易游戏2016实习生招聘在线笔试 解题报告
  15. win10电池图标不能调亮度_win10电池图标下面的亮度调节用不了
  16. 微信小程序Canvas画图片，合成图片，微信头像合成,变更国庆头像，头像增加背景
  17. PyQt5 与 PySide2 所有事件大集合,一段代码包括键盘、鼠标和窗口所有事件
  18. 感悟《疯狂的程序员》
  19. 解决RTL8723BE网卡Linux上WIFI信号信号差的问题
  20. 仿微信九宫格群聊view

热门文章

  1. parasoft Jtest 使用教程：生成、执行和扩展Junit测试用例
  2. android 修改系统权限 WRITE_SETTINGS
  3. java 正则 小数_java用正则表达式判断是否是小数的方法
  4. linux vncviewer使用教程,vnc viewer 远程桌面，11步实现vnc viewer 远程桌面连接Linux
  5. java计算机毕业设计影楼网站源码+数据库+系统+lw文档+部署
  6. 破坏入侵计算机信息系统犯罪,计算机信息系统破坏罪与计算机非法入侵罪区别...
  7. 4.6实践，路由器wds设置
  8. 95、基于51单片机智能闹钟万年历 农历阳历温度电子时钟闹钟定时语音播报系统
  9. airplay_AirPlay即将应用于智能电视。 这是如何运作的
  10. JavaScript流程控制