generic_app.cpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2002 by J.M.McGuiness, coder@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "core/exception.hpp"
#include "core/temp_file.hpp"
#include "core/cmd_line_processing.hpp"
#include "core/generic_app.hpp"
 
#include <ios>
#include <iostream>
 
using namespace libjmmcg;
 
JMMCG_REVISION_CONSTANT(LIBJMMCG_VERSION_NUMBER)
 
struct SomeParams {
   unsigned long l;
   tstring s;
};
 
class Processor : public ConfigFile<SomeParams,crt_exception<ppd::platform_api,ppd::heavyweight_threading> > {
public:
   inline Processor(SomeParams &p)
   : ConfigFile<SomeParams,crt_exception<ppd::platform_api,ppd::heavyweight_threading> >(p) {
   }
   inline ~Processor(void) {
   }
 
   Processor(const Processor &)=delete;
   void operator=(const Processor &)=delete;
 
private:
   inline bool ProcessParam(const unsigned long recognised_param,const tchar * const * const argc,unsigned long &i,tostream &o) {
      switch (recognised_param) {
      case 0:
         o<<_T("Got arg:")<<params[recognised_param].param<<std::endl;
         prog_opts.l=2;
         return true;
      case 1:
         o<<_T("Got arg:")<<params[recognised_param].param<<std::endl;
         prog_opts.s=_T("fdafad");
         return true;
      default:;
      }
      return false;
   }
 
   inline bool PostProcessConfigFileItems(const xmlpp::NodeSet &data_items,tostream &) {
      JMMCG_TRACE(_T("Number of items to process: ")+tostring(data_items.size()));
      return false;
   }
};
 
class TestApp : public AppBase<SomeParams,Processor::exception_t> {
public:
   inline TestApp(SomeParams &sp,const logger_ptr_type &l)
   : AppBase<SomeParams,Processor::exception_t>(sp,l) {
   }
   inline ~TestApp(void) {
   }
 
   inline exit_codes __fastcall Process(tostream &o) {
      temp_file<tfstream,ppd::platform_api,ppd::heavyweight_threading> t;
//    chk_dynamic_cast<temp_file<tfstream>,TestApp & >::test(t);
//    CHK_DYNAMIC_CAST(temp_file<tfstream>,TestApp &,t);
//    throw exception(_T("testing testing 1,2,3..."), info::FUNCTION(TestApp::Process, info::function::argument(_T("argv"), 1)), __REV_INFO__);
      return exit_success;
   }
 
private:
   // I don't allow copying or assignment.
   inline TestApp(const TestApp &) noexcept(true);
   inline TestApp &operator=(const TestApp &) noexcept(true);
};
 
const CmdLineParamsData::ParamType CmdLineParamsData::params[]={
   CmdLineParamsData::ParamType(_T("--param1"),_T("Help for param1.")),
   CmdLineParamsData::ParamType(_T("--param2"),_T("Help for param2."))
};
const tchar * const CmdLineParamsData::authors[]={
   _T("J.M.McGuiness.")
};
const tchar CmdLineParamsData::version[]=_T("0.1");
const tchar CmdLineParamsData::copyright[]=_T("2003. This is free software; see the source for copying conditions.");
const tchar CmdLineParamsData::warranty[]=_T("There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.");
const tchar CmdLineParamsData::contact_details[]=_T("http://www.hussar.me.uk");
const tchar CmdLineParamsData::help_text[]=_T("My test app.");
 
int main(const unsigned int argv, const tchar * const * const argc) {
   try {
      SomeParams sp;
      TestApp::logger_ptr_type logger;
      {
         std::auto_ptr<Processor> cmd_line(new Processor(sp));
         if (!cmd_line->ProcessParams(argv,argc,std::cout)) {
            return exit_parameter_error;
         }
         logger=cmd_line->Log();
      }
      TestApp app(sp,logger);
      return app.Process(std::cerr);
   } catch (const exception<ppd::platform_api,ppd::heavyweight_threading> &ex) {
      std::cerr<<ex;
      return ex.code();
   } catch (const std::exception &ex) {
      std::cerr<<_T("STL (or derived) exception caught, details:\n")<<ex.what()<<std::endl;
      std::cerr<<_T("Other details, not necessarily related to the STL exception caught.\n");
      std::cerr<<crt_exception<ppd::platform_api,ppd::heavyweight_threading>::dump_crt_errno()<<std::endl;
      return exit_codes::exit_stl_exception;
   } catch (...) {
      std::cerr<<_T("Unknown exception caught...\n");
      std::cerr<<_T("Other details, not necessarily related to the exception caught.\n");
      std::cerr<<crt_exception<ppd::platform_api,ppd::heavyweight_threading>::dump_crt_errno()<<std::endl;
      return exit_codes::exit_unknown_exception;
   }
   return exit_codes::exit_unknown_failure;
}