开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ncbiargs.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：61k
源码类别：

生物技术

开发平台：

C/C++

ncbiargs.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbiargs.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:08:48  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.48
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbiargs.cpp,v 1000.1 2004/06/01 19:08:48 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Authors:  Denis Vakatov, Anton Butanayev
  36.  *
  37.  * File Description:
  38.  *   Command-line arguments' processing:
  39.  *      descriptions  -- CArgDescriptions,  CArgDesc
  40.  *      parsed values -- CArgs,             CArgValue
  41.  *      exceptions    -- CArgException, ARG_THROW()
  42.  *      constraints   -- CArgAllow;  CArgAllow_{Strings,Integers,Doubles}
  43.  *
  44.  */
  46. #include <ncbi_pch.hpp>
  47. #include <corelib/ncbiargs.hpp>
  48. #include <corelib/ncbienv.hpp>
  49. #include <algorithm>
  51. BEGIN_NCBI_SCOPE
  54. /////////////////////////////////////////////////////////////////////////////
  55. /////////////////////////////////////////////////////////////////////////////
  56. //  Include the private header
  57. //
  59. #define NCBIARGS__CPP
  60. #include "ncbiargs_p.hpp"
  64. /////////////////////////////////////////////////////////////////////////////
  65. /////////////////////////////////////////////////////////////////////////////
  66. //  Constants
  67. //
  69. static const string s_AutoHelp("h");
  70. static const string s_ExtraName("....");
  75. /////////////////////////////////////////////////////////////////////////////
  77. string s_ArgExptMsg(const string& name, const string& what, const string& attr)
  78. {
  79.     return string("Argument "") + (name.empty() ? s_ExtraName : name) +
  80.         "". " + what + ":  `" + attr + "'";
  81. }
  84. /////////////////////////////////////////////////////////////////////////////
  85. /////////////////////////////////////////////////////////////////////////////
  86. //  CArg_***::   classes representing various types of argument value
  87. //
  88. //    CArgValue
  89. //
  90. //       CArg_NoValue     : CArgValue
  91. //
  92. //       CArg_String      : CArgValue
  93. //          CArg_Integer     : CArg_String
  94. //          CArg_Double      : CArg_String
  95. //          CArg_Boolean     : CArg_String
  96. //          CArg_InputFile   : CArg_String
  97. //          CArg_OutputFile  : CArg_String
  98. //    
  101. ///////////////////////////////////////////////////////
  102. //  CArgValue::
  104. CArgValue::CArgValue(const string& name)
  105.     : m_Name(name)
  106. {
  107.     if ( !CArgDescriptions::VerifyName(m_Name, true) ) {
  108.         NCBI_THROW(CArgException,eInvalidArg,
  109.             "Invalid argument name: " + m_Name);
  110.     }
  111. }
  114. CArgValue::~CArgValue(void)
  115. {
  116.     return;
  117. }
  121. ///////////////////////////////////////////////////////
  122. //  Overload the comparison operator -- to handle "CRef<CArgValue>" elements
  123. //  in "CArgs::m_Args" stored as "set< CRef<CArgValue> >"
  124. //
  126. inline bool operator< (const CRef<CArgValue>& x, const CRef<CArgValue>& y)
  127. {
  128.     return x->GetName() < y->GetName();
  129. }
  133. ///////////////////////////////////////////////////////
  134. //  CArg_NoValue::
  136. inline CArg_NoValue::CArg_NoValue(const string& name)
  137.     : CArgValue(name)
  138. {
  139.     return;
  140. }
  143. bool CArg_NoValue::HasValue(void) const
  144. {
  145.     return false;
  146. }
  149. #define THROW_CArg_NoValue 
  150.     NCBI_THROW(CArgException,eNoValue, s_ArgExptMsg(GetName(), 
  151.         "Optional argument must have a default value", "NULL"));
  153. const string& CArg_NoValue::AsString    (void) const { THROW_CArg_NoValue; }
  154. int           CArg_NoValue::AsInteger   (void) const { THROW_CArg_NoValue; }
  155. double        CArg_NoValue::AsDouble    (void) const { THROW_CArg_NoValue; }
  156. bool          CArg_NoValue::AsBoolean   (void) const { THROW_CArg_NoValue; }
  157. CNcbiIstream& CArg_NoValue::AsInputFile (void) const { THROW_CArg_NoValue; }
  158. CNcbiOstream& CArg_NoValue::AsOutputFile(void) const { THROW_CArg_NoValue; }
  159. void          CArg_NoValue::CloseFile   (void) const { THROW_CArg_NoValue; }
  163. ///////////////////////////////////////////////////////
  164. //  CArg_String::
  166. inline CArg_String::CArg_String(const string& name, const string& value)
  167.     : CArgValue(name),
  168.       m_String(value)
  169. {
  170.     return;
  171. }
  174. bool CArg_String::HasValue(void) const
  175. {
  176.     return true;
  177. }
  180. const string& CArg_String::AsString(void) const
  181. {
  182.     return m_String;
  183. }
  186. int CArg_String::AsInteger(void) const
  187. { NCBI_THROW(CArgException,eWrongCast,s_ArgExptMsg(GetName(),
  188.     "Attempt to cast to a wrong (Integer) type", AsString()));}
  190. double CArg_String::AsDouble(void) const
  191. { NCBI_THROW(CArgException,eWrongCast,s_ArgExptMsg(GetName(),
  192.     "Attempt to cast to a wrong (Double) type", AsString()));}
  194. bool CArg_String::AsBoolean(void) const
  195. { NCBI_THROW(CArgException,eWrongCast,s_ArgExptMsg(GetName(),
  196.     "Attempt to cast to a wrong (Boolean) type", AsString()));}
  198. CNcbiIstream& CArg_String::AsInputFile(void) const
  199. { NCBI_THROW(CArgException,eWrongCast,s_ArgExptMsg(GetName(),
  200.     "Attempt to cast to a wrong (InputFile) type", AsString()));}
  202. CNcbiOstream& CArg_String::AsOutputFile(void) const
  203. { NCBI_THROW(CArgException,eWrongCast,s_ArgExptMsg(GetName(),
  204.     "Attempt to cast to a wrong (OutputFile) type", AsString()));}
  206. void CArg_String::CloseFile(void) const
  207. { NCBI_THROW(CArgException,eWrongCast,s_ArgExptMsg(GetName(),
  208.     "Attempt to close an argument of non-file type", AsString()));}
  212. ///////////////////////////////////////////////////////
  213. //  CArg_Integer::
  215. inline CArg_Integer::CArg_Integer(const string& name, const string& value)
  216.     : CArg_String(name, value)
  217. {
  218.     try {
  219.         m_Integer = NStr::StringToInt(value);
  220.     } catch (CException& e) {
  221.         NCBI_RETHROW(e,CArgException,eConvert, s_ArgExptMsg(GetName(),
  222.             "Argument cannot be converted",value));
  223.     }
  225. }
  228. int CArg_Integer::AsInteger(void) const
  229. {
  230.     return m_Integer;
  231. }
  235. ///////////////////////////////////////////////////////
  236. //  CArg_Double::
  238. inline CArg_Double::CArg_Double(const string& name, const string& value)
  239.     : CArg_String(name, value)
  240. {
  241.     try {
  242.         m_Double = NStr::StringToDouble(value);
  243.     } catch (CException& e) {
  244.         NCBI_RETHROW(e,CArgException,eConvert,
  245.             s_ArgExptMsg(GetName(),"Argument cannot be converted",value));
  246.     }
  247. }
  250. double CArg_Double::AsDouble(void) const
  251. {
  252.     return m_Double;
  253. }
  257. ///////////////////////////////////////////////////////
  258. //  CArg_Boolean::
  260. inline CArg_Boolean::CArg_Boolean(const string& name, bool value)
  261.     : CArg_String(name, NStr::BoolToString(value))
  262. {
  263.     m_Boolean = value;
  264. }
  267. inline CArg_Boolean::CArg_Boolean(const string& name, const string& value)
  268.     : CArg_String(name, value)
  269. {
  270.     try {
  271.         m_Boolean = NStr::StringToBool(value);
  272.     } catch (CException& e) {
  273.         NCBI_RETHROW(e,CArgException,eConvert, s_ArgExptMsg(GetName(),
  274.             "Argument cannot be converted",value));
  275.     }
  276. }
  279. bool CArg_Boolean::AsBoolean(void) const
  280. {
  281.     return m_Boolean;
  282. }
  286. ///////////////////////////////////////////////////////
  287. //  CArg_InputFile::
  289. void CArg_InputFile::x_Open(void) const
  290. {
  291.     if ( m_InputFile )
  292.         return;
  294.     if (AsString() == "-") {
  295.         m_InputFile  = &cin;
  296.         m_DeleteFlag = false;
  297.     } else if ( !AsString().empty() ) {
  298.         m_InputFile  = new CNcbiIfstream(AsString().c_str(),
  299.                                          IOS_BASE::in | m_OpenMode);
  300.         if (!m_InputFile  ||  !*m_InputFile) {
  301.             delete m_InputFile;
  302.             m_InputFile = 0;
  303.         } else {
  304.             m_DeleteFlag = true;
  305.         }
  306.     }
  308.     if ( !m_InputFile ) {
  309.         NCBI_THROW(CArgException,eNoFile, s_ArgExptMsg(GetName(),
  310.             "File is not accessible",AsString()));
  311.     }
  312. }
  315. CArg_InputFile::CArg_InputFile(const string& name, const string& value,
  316.                                IOS_BASE::openmode openmode,
  317.                                bool               delay_open)
  318. : CArg_String(name, value),
  319.   m_OpenMode(openmode),
  320.   m_InputFile(0),
  321.   m_DeleteFlag(true)
  322. {
  323.     if ( !delay_open )
  324.         x_Open();
  325. }
  328. CArg_InputFile::~CArg_InputFile(void)
  329. {
  330.     if (m_InputFile  &&  m_DeleteFlag)
  331.         delete m_InputFile;
  332. }
  335. CNcbiIstream& CArg_InputFile::AsInputFile(void) const
  336. {
  337.     x_Open();
  338.     return *m_InputFile;
  339. }
  342. void CArg_InputFile::CloseFile(void) const
  343. {
  344.     if ( !m_InputFile ) {
  345.         ERR_POST(Warning << s_ArgExptMsg( GetName(),
  346.             "CArg_InputFile::CloseFile: File was not opened", AsString()));
  347. /*
  348.                  CArgException(GetName(),
  349.                                "CArg_InputFile::CloseFile -- file not opened",
  350.                                AsString()).what());
  351. */
  352.         return;
  353.     }
  355.     if ( m_DeleteFlag ) {
  356.         delete m_InputFile;
  357.         m_InputFile = 0;
  358.     }
  359. }
  363. ///////////////////////////////////////////////////////
  364. //  CArg_OutputFile::
  366. void CArg_OutputFile::x_Open(void) const
  367. {
  368.     if ( m_OutputFile )
  369.         return;
  371.     if (AsString() == "-") {
  372.         m_OutputFile = &cout;
  373.         m_DeleteFlag = false;
  374.     } else if ( !AsString().empty() ) {
  375.         m_OutputFile = new CNcbiOfstream(AsString().c_str(),
  376.                                          IOS_BASE::out | m_OpenMode);
  377.         if (!m_OutputFile  ||  !*m_OutputFile) {
  378.             delete m_OutputFile;
  379.             m_OutputFile = 0;
  380.         } else {
  381.             m_DeleteFlag = true;
  382.         }
  383.     }
  385.     if ( !m_OutputFile ) {
  386.         NCBI_THROW(CArgException,eNoFile, s_ArgExptMsg(GetName(),
  387.             "File is not accessible",AsString()));
  388.     }
  389. }
  392. CArg_OutputFile::CArg_OutputFile(const string& name, const string& value,
  393.                                  IOS_BASE::openmode openmode,
  394.                                  bool               delay_open)
  395.     : CArg_String(name, value),
  396.       m_OpenMode(openmode),
  397.       m_OutputFile(0),
  398.       m_DeleteFlag(true)
  399. {
  400.     if ( !delay_open )
  401.         x_Open();
  402. }
  405. CArg_OutputFile::~CArg_OutputFile(void)
  406. {
  407.     if (m_OutputFile  &&  m_DeleteFlag)
  408.         delete m_OutputFile;
  409. }
  412. CNcbiOstream& CArg_OutputFile::AsOutputFile(void) const
  413. {
  414.     x_Open();
  415.     return *m_OutputFile;
  416. }
  419. void CArg_OutputFile::CloseFile(void) const
  420. {
  421.     if ( !m_OutputFile ) {
  422.         ERR_POST(Warning << s_ArgExptMsg( GetName(),
  423.             "CArg_InputFile::CloseFile: File was not opened", AsString()));
  424.         return;
  425.     }
  427.     if ( m_DeleteFlag ) {
  428.         delete m_OutputFile;
  429.         m_OutputFile = 0;
  430.     }
  431. }
  436. /////////////////////////////////////////////////////////////////////////////
  437. /////////////////////////////////////////////////////////////////////////////
  438. //  CArgDesc***::   abstract base classes for argument descriptions
  439. //
  440. //    CArgDesc
  441. //
  442. //    CArgDescMandatory  : CArgDesc
  443. //    CArgDescOptional   : virtual CArgDescMandatory
  444. //    CArgDescDefault    : virtual CArgDescOptional
  445. //
  446. //    CArgDescSynopsis
  447. //
  450. ///////////////////////////////////////////////////////
  451. //  CArgDesc::
  453. CArgDesc::CArgDesc(const string& name, const string& comment)
  454.     : m_Name(name), m_Comment(comment)
  455. {
  456.     if ( !CArgDescriptions::VerifyName(m_Name) ) {
  457.         NCBI_THROW(CArgException,eInvalidArg,
  458.             "Invalid argument name: " + m_Name);
  459.     }
  460. }
  463. CArgDesc::~CArgDesc(void)
  464. {
  465.     return;
  466. }
  469. void CArgDesc::VerifyDefault(void) const
  470. {
  471.     return;
  472. }
  475. void CArgDesc::SetConstraint(CArgAllow* constraint)
  476. {
  477.     NCBI_THROW(CArgException, eConstraint, s_ArgExptMsg(GetName(),
  478.         "No-value arguments may not be constrained",
  479.         constraint ? constraint->GetUsage() : kEmptyStr));
  480. }
  483. const CArgAllow* CArgDesc::GetConstraint(void) const
  484. {
  485.     return 0;
  486. }
  489. string CArgDesc::GetUsageConstraint(void) const
  490. {
  491.     const CArgAllow* constraint = GetConstraint();
  492.     return constraint ? constraint->GetUsage() : kEmptyStr;
  493. }
  497. ///////////////////////////////////////////////////////
  498. //  Overload the comparison operator -- to handle "AutoPtr<CArgDesc>" elements
  499. //  in "CArgs::m_Args" stored as "set< AutoPtr<CArgDesc> >"
  500. //
  502. inline bool operator< (const AutoPtr<CArgDesc>& x, const AutoPtr<CArgDesc>& y)
  503. {
  504.     return x->GetName() < y->GetName();
  505. }
  509. ///////////////////////////////////////////////////////
  510. //  CArgDescMandatory::
  512. CArgDescMandatory::CArgDescMandatory(const string&            name,
  513.                                      const string&            comment,
  514.                                      CArgDescriptions::EType  type,
  515.                                      CArgDescriptions::TFlags flags)
  516.     : CArgDesc(name, comment),
  517.       m_Type(type), m_Flags(flags)
  518. {
  519.     // verify if "flags" "type" are matching
  520.     switch ( type ) {
  521.     case CArgDescriptions::eBoolean:
  522.     case CArgDescriptions::eOutputFile:
  523.         return;
  524.     case CArgDescriptions::eInputFile:
  525.         if((flags &
  526.             ~(CArgDescriptions::fPreOpen | CArgDescriptions::fBinary)) == 0)
  527.             return;
  528.     case CArgDescriptions::k_EType_Size:
  529.         _TROUBLE;
  530.         NCBI_THROW(CArgException, eArgType, s_ArgExptMsg(GetName(),
  531.             "Invalid argument type", "k_EType_Size"));
  532.     default:
  533.         if (flags == 0)
  534.             return;
  535.     }
  537.     NCBI_THROW(CArgException, eArgType, s_ArgExptMsg(GetName(),
  538.         "Argument type/flags mismatch",
  539.         "(type=" + CArgDescriptions::GetTypeName(type) +
  540.         ", flags=" + NStr::UIntToString(flags) + ")"));
  541.         
  542. }
  545. CArgDescMandatory::~CArgDescMandatory(void)
  546. {
  547.     return;
  548. }
  551. string CArgDescMandatory::GetUsageCommentAttr(void) const
  552. {
  553.     // Print type name
  554.     string str = CArgDescriptions::GetTypeName(GetType());
  556.     // Print constraint info, if any
  557.     string constr = GetUsageConstraint();
  558.     if ( !constr.empty() ) {
  559.         str += ", ";
  560.         str += constr;
  561.     }
  562.     return str;
  563. }
  566. CArgValue* CArgDescMandatory::ProcessArgument(const string& value) const
  567. {
  568.     // Process according to the argument type
  569.     CRef<CArgValue> arg_value;
  570.     switch ( GetType() ) {
  571.     case CArgDescriptions::eString:
  572.         arg_value = new CArg_String(GetName(), value);
  573.         break;
  574.     case CArgDescriptions::eBoolean:
  575.         arg_value = new CArg_Boolean(GetName(), value);
  576.         break;
  577.     case CArgDescriptions::eInteger:
  578.         arg_value = new CArg_Integer(GetName(), value);
  579.         break;
  580.     case CArgDescriptions::eDouble:
  581.         arg_value = new CArg_Double(GetName(), value);
  582.         break;
  583.     case CArgDescriptions::eInputFile: {
  584.         bool delay_open = (GetFlags() & CArgDescriptions::fPreOpen) == 0;
  585.         IOS_BASE::openmode openmode = (IOS_BASE::openmode) 0;
  586.         if (GetFlags() & CArgDescriptions::fBinary)
  587.             openmode |= IOS_BASE::binary;
  588.         arg_value = new CArg_InputFile(GetName(), value, openmode, delay_open);
  589.         break;
  590.     }
  591.     case CArgDescriptions::eOutputFile: {
  592.         bool delay_open = (GetFlags() & CArgDescriptions::fPreOpen) == 0;
  593.         IOS_BASE::openmode openmode = (IOS_BASE::openmode) 0;
  594.         if (GetFlags() & CArgDescriptions::fBinary)
  595.             openmode |= IOS_BASE::binary;
  596.         if (GetFlags() & CArgDescriptions::fAppend)
  597.             openmode |= IOS_BASE::app;
  598.         arg_value = new CArg_OutputFile(GetName(), value, openmode,delay_open);
  599.         break;
  600.     }
  601.     case CArgDescriptions::k_EType_Size: {
  602.         _TROUBLE;
  603.         NCBI_THROW(CArgException, eArgType, s_ArgExptMsg(GetName(),
  604.             "Unknown argument type", NStr::IntToString((int)GetType())));
  605.     }
  606.     } /* switch GetType() */
  609.     // Check against additional (user-defined) constraints, if any imposed
  610.     if ( m_Constraint ) {
  611.         bool err = false;
  612.         try {
  613.             if ( !m_Constraint->Verify(value) )
  614.                 err = true;
  615.         } catch (...) {
  616.             err = true;
  617.         }
  618.         if ( err ) {
  619.             NCBI_THROW(CArgException, eConstraint, s_ArgExptMsg(GetName(),
  620.                 "Illegal value, expected " + m_Constraint->GetUsage(),value));
  621.         }
  622.     }
  624.     return arg_value.Release();
  625. }
  628. CArgValue* CArgDescMandatory::ProcessDefault(void) const
  629. {
  630.     NCBI_THROW(CArgException, eNoArg, s_ArgExptMsg(GetName(),
  631.         "Required argument missing", GetUsageCommentAttr()));
  632. }
  635. void CArgDescMandatory::SetConstraint(CArgAllow* constraint)
  636. {
  637.     m_Constraint = constraint;
  638. }
  641. const CArgAllow* CArgDescMandatory::GetConstraint(void) const
  642. {
  643.     return m_Constraint;
  644. }
  649. ///////////////////////////////////////////////////////
  650. //  CArgDescOptional::
  653. CArgDescOptional::CArgDescOptional(const string& name, const string& comment,
  654.                                    CArgDescriptions::EType  type,
  655.                                    CArgDescriptions::TFlags flags)
  656.     : CArgDescMandatory(name, comment, type, flags)
  657. {
  658.     return;
  659. }
  662. CArgDescOptional::~CArgDescOptional(void)
  663. {
  664.     return;
  665. }
  668. CArgValue* CArgDescOptional::ProcessDefault(void) const
  669. {
  670.     return new CArg_NoValue(GetName());
  671. }
  676. ///////////////////////////////////////////////////////
  677. //  CArgDescDefault::
  680. CArgDescDefault::CArgDescDefault(const string& name, const string& comment,
  681.                                  CArgDescriptions::EType  type,
  682.                                  CArgDescriptions::TFlags flags,
  683.                                  const string&            default_value)
  684.     : CArgDescMandatory(name, comment, type, flags),
  685.       CArgDescOptional(name, comment, type, flags),
  686.       m_DefaultValue(default_value)
  687. {
  688.     return;
  689. }
  692. CArgDescDefault::~CArgDescDefault(void)
  693. {
  694.     return;
  695. }
  698. CArgValue* CArgDescDefault::ProcessDefault(void) const
  699. {
  700.     return ProcessArgument(GetDefaultValue());
  701. }
  704. void CArgDescDefault::VerifyDefault(void) const
  705. {
  706.     if (GetType() == CArgDescriptions::eInputFile  ||
  707.         GetType() == CArgDescriptions::eOutputFile) {
  708.         return;
  709.     }
  711.     // Process, then immediately delete
  712.     CRef<CArgValue> arg_value(ProcessArgument(GetDefaultValue()));
  713. }
  717. ///////////////////////////////////////////////////////
  718. //  CArgDescSynopsis::
  721. CArgDescSynopsis::CArgDescSynopsis(const string& synopsis)
  722.     : m_Synopsis(synopsis)
  723. {
  724.     for (string::const_iterator it = m_Synopsis.begin();
  725.          it != m_Synopsis.end();  ++it) {
  726.         if (*it != '_'  &&  !isalnum(*it)) {
  727.             NCBI_THROW(CArgException,eSynopsis,
  728.                 "Argument synopsis must be alphanumeric: "+ m_Synopsis);
  729.         }
  730.     }
  731. }
  736. /////////////////////////////////////////////////////////////////////////////
  737. /////////////////////////////////////////////////////////////////////////////
  738. //  CArgDesc_***::   classes for argument descriptions
  739. //    CArgDesc_Flag    : CArgDesc
  740. //
  741. //    CArgDesc_Key     : virtual CArgDescMandatory
  742. //    CArgDesc_KeyOpt  : CArgDesc_Key, virtual CArgDescOptional
  743. //    CArgDesc_KeyDef  : CArgDesc_Key, CArgDescDefault
  744. //
  745. //    CArgDesc_Pos     : virtual CArgDescMandatory
  746. //    CArgDesc_PosOpt  : CArgDesc_Pos, virtual CArgDescOptional
  747. //    CArgDesc_PosDef  : CArgDesc_Pos, CArgDescDefault
  748. //
  752. ///////////////////////////////////////////////////////
  753. //  CArgDesc_Flag::
  756. CArgDesc_Flag::CArgDesc_Flag(const string& name, const string& comment,
  757.                              bool set_value)
  758.     : CArgDesc(name, comment),
  759.       m_SetValue(set_value)
  760. {
  761.     return;
  762. }
  765. CArgDesc_Flag::~CArgDesc_Flag(void)
  766. {
  767.     return;
  768. }
  771. string CArgDesc_Flag::GetUsageSynopsis(bool /*name_only*/) const
  772. {
  773.     return "-" + GetName();
  774. }
  777. string CArgDesc_Flag::GetUsageCommentAttr(void) const
  778. {
  779.     return kEmptyStr;
  780. }
  783. CArgValue* CArgDesc_Flag::ProcessArgument(const string& /*value*/) const
  784. {
  785.     if ( m_SetValue ) {
  786.         return new CArg_Boolean(GetName(), true);
  787.     } else {
  788.         return new CArg_NoValue(GetName());
  789.     }
  790. }
  793. CArgValue* CArgDesc_Flag::ProcessDefault(void) const
  794. {
  795.     if ( m_SetValue ) {
  796.         return new CArg_NoValue(GetName());
  797.     } else {
  798.         return new CArg_Boolean(GetName(), true);
  799.     }
  800. }
  804. ///////////////////////////////////////////////////////
  805. //  CArgDesc_Pos::
  808. CArgDesc_Pos::CArgDesc_Pos(const string&            name,
  809.                            const string&            comment,
  810.                            CArgDescriptions::EType  type,
  811.                            CArgDescriptions::TFlags flags)
  812.     : CArgDescMandatory(name, comment, type, flags)
  813. {
  814.     return;
  815. }
  818. CArgDesc_Pos::~CArgDesc_Pos(void)
  819. {
  820.     return;
  821. }
  824. string CArgDesc_Pos::GetUsageSynopsis(bool /*name_only*/) const
  825. {
  826.     return GetName().empty() ? s_ExtraName : GetName();
  827. }
  831. ///////////////////////////////////////////////////////
  832. //  CArgDesc_PosOpt::
  835. CArgDesc_PosOpt::CArgDesc_PosOpt(const string&            name,
  836.                                  const string&            comment,
  837.                                  CArgDescriptions::EType  type,
  838.                                  CArgDescriptions::TFlags flags)
  839.     : CArgDescMandatory (name, comment, type, flags),
  840.       CArgDescOptional  (name, comment, type, flags),
  841.       CArgDesc_Pos      (name, comment, type, flags)
  842. {
  843.     return;
  844. }
  847. CArgDesc_PosOpt::~CArgDesc_PosOpt(void)
  848. {
  849.     return;
  850. }
  854. ///////////////////////////////////////////////////////
  855. //  CArgDesc_PosDef::
  858. CArgDesc_PosDef::CArgDesc_PosDef(const string&            name,
  859.                                  const string&            comment,
  860.                                  CArgDescriptions::EType  type,
  861.                                  CArgDescriptions::TFlags flags,
  862.                                  const string&            default_value)
  863.     : CArgDescMandatory (name, comment, type, flags),
  864.       CArgDescOptional  (name, comment, type, flags),
  865.       CArgDescDefault   (name, comment, type, flags, default_value),
  866.       CArgDesc_PosOpt   (name, comment, type, flags)
  867. {
  868.     return;
  869. }
  872. CArgDesc_PosDef::~CArgDesc_PosDef(void)
  873. {
  874.     return;
  875. }
  879. ///////////////////////////////////////////////////////
  880. //  CArgDesc_Key::
  883. CArgDesc_Key::CArgDesc_Key(const string&            name,
  884.                            const string&            comment,
  885.                            CArgDescriptions::EType  type,
  886.                            CArgDescriptions::TFlags flags,
  887.                            const string&            synopsis)
  888.     : CArgDescMandatory(name, comment, type, flags),
  889.       CArgDesc_Pos     (name, comment, type, flags),
  890.       CArgDescSynopsis(synopsis)
  891. {
  892.     return;
  893. }
  896. CArgDesc_Key::~CArgDesc_Key(void)
  897. {
  898.     return;
  899. }
  902. inline string s_KeyUsageSynopsis(const string& name, const string& synopsis,
  903.                                  bool name_only)
  904. {
  905.     if ( name_only ) {
  906.         return '-' + name;
  907.     } else {
  908.         return '-' + name + ' ' + synopsis;
  909.     }
  910. }
  913. string CArgDesc_Key::GetUsageSynopsis(bool name_only) const
  914. {
  915.     return s_KeyUsageSynopsis(GetName(), GetSynopsis(), name_only);
  916. }
  920. ///////////////////////////////////////////////////////
  921. //  CArgDesc_KeyOpt::
  924. CArgDesc_KeyOpt::CArgDesc_KeyOpt(const string&            name,
  925.                                  const string&            comment,
  926.                                  CArgDescriptions::EType  type,
  927.                                  CArgDescriptions::TFlags flags,
  928.                                  const string&            synopsis)
  929.     : CArgDescMandatory(name, comment, type, flags),
  930.       CArgDescOptional (name, comment, type, flags),
  931.       CArgDesc_PosOpt  (name, comment, type, flags),
  932.       CArgDescSynopsis(synopsis)
  933. {
  934.     return;
  935. }
  938. CArgDesc_KeyOpt::~CArgDesc_KeyOpt(void)
  939. {
  940.     return;
  941. }
  944. string CArgDesc_KeyOpt::GetUsageSynopsis(bool name_only) const
  945. {
  946.     return s_KeyUsageSynopsis(GetName(), GetSynopsis(), name_only);
  947. }
  951. ///////////////////////////////////////////////////////
  952. //  CArgDesc_KeyDef::
  955. CArgDesc_KeyDef::CArgDesc_KeyDef(const string&            name,
  956.                                  const string&            comment,
  957.                                  CArgDescriptions::EType  type,
  958.                                  CArgDescriptions::TFlags flags,
  959.                                  const string&            synopsis,
  960.                                  const string&            default_value)
  961.     : CArgDescMandatory(name, comment, type, flags),
  962.       CArgDescOptional (name, comment, type, flags),
  963.       CArgDesc_PosDef  (name, comment, type, flags, default_value),
  964.       CArgDescSynopsis(synopsis)
  965. {
  966.     return;
  967. }
  970. CArgDesc_KeyDef::~CArgDesc_KeyDef(void)
  971. {
  972.     return;
  973. }
  976. string CArgDesc_KeyDef::GetUsageSynopsis(bool name_only) const
  977. {
  978.     return s_KeyUsageSynopsis(GetName(), GetSynopsis(), name_only);
  979. }
  984. /////////////////////////////////////////////////////////////////////////////
  985. /////////////////////////////////////////////////////////////////////////////
  986. //  Aux.functions to figure out various arg. features
  987. //
  988. //    s_IsPositional(arg)
  989. //    s_IsOptional(arg)
  990. //    s_IsFlag(arg)
  991. //
  993. inline bool s_IsKey(const CArgDesc& arg)
  994. {
  995.     return (dynamic_cast<const CArgDescSynopsis*> (&arg) != 0);
  996. }
  999. inline bool s_IsPositional(const CArgDesc& arg)
  1000. {
  1001.     return dynamic_cast<const CArgDesc_Pos*> (&arg) &&  !s_IsKey(arg);
  1002. }
  1005. inline bool s_IsOptional(const CArgDesc& arg)
  1006. {
  1007.     return (dynamic_cast<const CArgDescOptional*> (&arg) != 0);
  1008. }
  1011. inline bool s_IsFlag(const CArgDesc& arg)
  1012. {
  1013.     return (dynamic_cast<const CArgDesc_Flag*> (&arg) != 0);
  1014. }
  1018. /////////////////////////////////////////////////////////////////////////////
  1019. /////////////////////////////////////////////////////////////////////////////
  1020. //  CArgs::
  1021. //
  1024. CArgs::CArgs(void)
  1025. {
  1026.     m_nExtra = 0;
  1027. }
  1030. CArgs::~CArgs(void)
  1031. {
  1032.     return;
  1033. }
  1036. static string s_ComposeNameExtra(size_t idx)
  1037. {
  1038.     return '#' + NStr::UIntToString(idx);
  1039. }
  1042. CArgs::TArgsCI CArgs::x_Find(const string& name) const
  1043. {
  1044.     return m_Args.find(CRef<CArgValue> (new CArg_NoValue(name)));
  1045. }
  1048. bool CArgs::Exist(const string& name) const
  1049. {
  1050.     return (x_Find(name) != m_Args.end());
  1051. }
  1054. const CArgValue& CArgs::operator[] (const string& name) const
  1055. {
  1056.     TArgsCI arg = x_Find(name);
  1057.     if (arg == m_Args.end()) {
  1058.         // Special diagnostics for "extra" args
  1059.         if (!name.empty()  &&  name[0] == '#') {
  1060.             size_t idx;
  1061.             try {
  1062.                 idx = NStr::StringToUInt(name.c_str() + 1);
  1063.             } catch (...) {
  1064.                 idx = kMax_UInt;
  1065.             }
  1066.             if (idx == kMax_UInt) {
  1067.                 NCBI_THROW(CArgException,eInvalidArg,
  1068.                     "Argument of invalid name requested: "+ name);
  1070.             }
  1071.             if (m_nExtra == 0) {
  1072.                 NCBI_THROW(CArgException,eInvalidArg,
  1073.                     "No "extra" (unnamed positional) arguments "
  1074.                     "provided, cannot Get: "+ s_ComposeNameExtra(idx));
  1075.             }
  1076.             if (idx == 0  ||  idx >= m_nExtra) {
  1077.                 NCBI_THROW(CArgException,eInvalidArg,
  1078.                     ""Extra" (unnamed positional) arg is "
  1079.                     "out-of-range (#1..#" + NStr::UIntToString(m_nExtra)
  1080.                     + "): "+ s_ComposeNameExtra(idx));
  1081.             }
  1082.         }
  1083.         // Diagnostics for all other argument classes
  1084.         NCBI_THROW(CArgException,eInvalidArg,
  1085.             "Undescribed argument requested: "+ name);
  1086.     }
  1088.     // Found arg with name "name"
  1089.     return **arg;
  1090. }
  1093. const CArgValue& CArgs::operator[] (size_t idx) const
  1094. {
  1095.     return (*this)[s_ComposeNameExtra(idx)];
  1096. }
  1099. string& CArgs::Print(string& str) const
  1100. {
  1101.     for (TArgsCI arg = m_Args.begin();  arg != m_Args.end();  ++arg) {
  1102.         // Arg. name
  1103.         const string& arg_name = (*arg)->GetName();
  1104.         str += arg_name;
  1106.         // Arg. value, if any
  1107.         const CArgValue& arg_value = (*this)[arg_name];
  1108.         if ( arg_value ) {
  1109.             str += " = `";
  1110.             str += arg_value.AsString();
  1111.             str += "'n";
  1112.         } else {
  1113.             str += ":  <not assigned>n";
  1114.         }
  1115.     }
  1116.     return str;
  1117. }
  1120. void CArgs::Add(CArgValue* arg)
  1121. {
  1122.     // special case:  add an "extra" arg (generate virtual name for it)
  1123.     bool is_extra = false;
  1124.     if ( arg->GetName().empty() ) {
  1125.         arg->m_Name = s_ComposeNameExtra(m_nExtra + 1);
  1126.         is_extra = true;
  1127.     }
  1129.     // check-up
  1130.     _ASSERT(CArgDescriptions::VerifyName(arg->GetName(), true));
  1131.     if ( Exist(arg->GetName()) ) {
  1132.         NCBI_THROW(CArgException,eSynopsis,
  1133.             "Argument with this name is defined already: " + arg->GetName());
  1134.     }
  1136.     // add
  1137.     m_Args.insert(CRef<CArgValue>(arg));
  1139.     if ( is_extra ) {
  1140.         m_nExtra++;
  1141.     }
  1142. }
  1145. bool CArgs::IsEmpty(void) const
  1146. {
  1147.     return m_Args.empty();
  1148. }
  1152. ///////////////////////////////////////////////////////
  1153. ///////////////////////////////////////////////////////
  1154. //  CArgDescriptions::
  1155. //
  1158. CArgDescriptions::CArgDescriptions(bool auto_help)
  1159.     : m_nExtra(0),
  1160.       m_nExtraOpt(0),
  1161.       m_AutoHelp(auto_help),
  1162.       m_UsageIfNoArgs(false)
  1163. {
  1164.     SetUsageContext("NCBI_PROGRAM", kEmptyStr);
  1165.     if ( m_AutoHelp ) {
  1166.         AddFlag(s_AutoHelp,
  1167.                 "Print this USAGE message;  ignore other arguments");
  1168.     }
  1169. }
  1172. CArgDescriptions::~CArgDescriptions(void)
  1173. {
  1174.     return;
  1175. }
  1178. const string& CArgDescriptions::GetTypeName(EType type)
  1179. {
  1180.     static const string s_TypeName[k_EType_Size] = {
  1181.         "String",
  1182.         "Boolean",
  1183.         "Integer",
  1184.         "Real",
  1185.         "File_In",
  1186.         "File_Out"
  1187.     };
  1189.     if (type == k_EType_Size) {
  1190.         _TROUBLE;
  1191.         NCBI_THROW(CArgException, eArgType,
  1192.             "Invalid argument type: k_EType_Size");
  1193.     }
  1194.     return s_TypeName[(int) type];
  1195. }
  1198. void CArgDescriptions::AddKey
  1199. (const string& name,
  1200.  const string& synopsis,
  1201.  const string& comment,
  1202.  EType         type,
  1203.  TFlags        flags)
  1204. {
  1205.     auto_ptr<CArgDesc_Key> arg
  1206.         (new CArgDesc_Key(name, comment, type, flags, synopsis));
  1208.     x_AddDesc(*arg);
  1209.     arg.release();
  1210. }
  1213. void CArgDescriptions::AddOptionalKey
  1214. (const string& name,
  1215.  const string& synopsis,
  1216.  const string& comment,
  1217.  EType         type,
  1218.  TFlags        flags)
  1219. {
  1220.     auto_ptr<CArgDesc_KeyOpt> arg
  1221.         (new CArgDesc_KeyOpt(name, comment, type, flags, synopsis));
  1223.     x_AddDesc(*arg);
  1224.     arg.release();
  1225. }
  1228. void CArgDescriptions::AddDefaultKey
  1229. (const string& name,
  1230.  const string& synopsis,
  1231.  const string& comment,
  1232.  EType         type,
  1233.  const string& default_value,
  1234.  TFlags        flags)
  1235. {
  1236.     auto_ptr<CArgDesc_KeyDef> arg
  1237.         (new CArgDesc_KeyDef(name, comment, type, flags, synopsis,
  1238.                              default_value));
  1240.     x_AddDesc(*arg);
  1241.     arg.release();
  1242. }
  1245. void CArgDescriptions::AddFlag
  1246. (const string& name,
  1247.  const string& comment,
  1248.  bool          set_value)
  1249. {
  1250.     auto_ptr<CArgDesc_Flag> arg
  1251.         (new CArgDesc_Flag(name, comment, set_value));
  1253.     x_AddDesc(*arg);
  1254.     arg.release();
  1255. }
  1258. void CArgDescriptions::AddPositional
  1259. (const string& name,
  1260.  const string& comment,
  1261.  EType         type,
  1262.  TFlags        flags)
  1263. {
  1264.     auto_ptr<CArgDesc_Pos> arg
  1265.         (new CArgDesc_Pos(name, comment, type, flags));
  1267.     x_AddDesc(*arg);
  1268.     arg.release();
  1269. }
  1272. void CArgDescriptions::AddOptionalPositional
  1273. (const string& name,
  1274.  const string& comment,
  1275.  EType         type,
  1276.  TFlags        flags)
  1277. {
  1278.     auto_ptr<CArgDesc_PosOpt> arg
  1279.         (new CArgDesc_PosOpt(name, comment, type, flags));
  1281.     x_AddDesc(*arg);
  1282.     arg.release();
  1283. }
  1286. void CArgDescriptions::AddDefaultPositional
  1287. (const string& name,
  1288.  const string& comment,
  1289.  EType         type,
  1290.  const string& default_value,
  1291.  TFlags        flags)
  1292. {
  1293.     auto_ptr<CArgDesc_PosDef> arg
  1294.         (new CArgDesc_PosDef(name, comment, type, flags, default_value));
  1296.     x_AddDesc(*arg);
  1297.     arg.release();
  1298. }
  1301. void CArgDescriptions::AddExtra
  1302. (unsigned      n_mandatory,
  1303.  unsigned      n_optional,
  1304.  const string& comment,
  1305.  EType         type,
  1306.  TFlags        flags)
  1307. {
  1308.     if (!n_mandatory  &&  !n_optional) {
  1309.         NCBI_THROW(CArgException,eSynopsis,
  1310.             "Number of extra arguments cannot be zero");
  1311.     }
  1312.     if (n_mandatory > 4096) {
  1313.         NCBI_THROW(CArgException,eSynopsis,
  1314.             "Number of mandatory extra arguments is too big");
  1315.     }
  1317.     m_nExtra    = n_mandatory;
  1318.     m_nExtraOpt = n_optional;
  1320.     auto_ptr<CArgDesc_Pos> arg
  1321.         (m_nExtra ?
  1322.          new CArgDesc_Pos   (kEmptyStr, comment, type, flags) :
  1323.          new CArgDesc_PosOpt(kEmptyStr, comment, type, flags));
  1325.     x_AddDesc(*arg);
  1326.     arg.release();
  1327. }
  1330. void CArgDescriptions::SetConstraint(const string& name, CArgAllow* constraint)
  1331. {
  1332.     CRef<CArgAllow> safe_delete(constraint);
  1334.     TArgsI it = x_Find(name);
  1335.     if (it == m_Args.end()) {
  1336.         NCBI_THROW(CArgException, eConstraint, 
  1337.             "Attempt to set constraint for undescribed argument: "+ name);
  1338.     }
  1339.     (*it)->SetConstraint(constraint);
  1340. }
  1343. bool CArgDescriptions::Exist(const string& name) const
  1344. {
  1345.     return (x_Find(name) != m_Args.end());
  1346. }
  1349. void CArgDescriptions::Delete(const string& name)
  1350. {
  1351.     {{ // ...from the list of all args
  1352.         TArgsI it = x_Find(name);
  1353.         if (it == m_Args.end()) {
  1354.             NCBI_THROW(CArgException,eSynopsis,
  1355.                 "Argument description is not found");
  1356.         }
  1357.         m_Args.erase(it);
  1359.         // take special care of the extra args
  1360.         if ( name.empty() ) {
  1361.             m_nExtra = 0;
  1362.             m_nExtraOpt = 0;
  1363.             return;
  1364.         }
  1365.     }}
  1367.     {{ // ...from the list of key/flag args
  1368.         TKeyFlagArgs::iterator it =
  1369.             find(m_KeyFlagArgs.begin(), m_KeyFlagArgs.end(), name);
  1370.         if (it != m_KeyFlagArgs.end()) {
  1371.             m_KeyFlagArgs.erase(it);
  1372.             _ASSERT(find(m_KeyFlagArgs.begin(), m_KeyFlagArgs.end(), name) ==
  1373.                          m_KeyFlagArgs.end());
  1374.             _ASSERT(find(m_PosArgs.begin(), m_PosArgs.end(), name) ==
  1375.                          m_PosArgs.end());
  1376.             return;
  1377.         }
  1378.     }}
  1380.     {{ // ...from the list of positional args' positions
  1381.         TPosArgs::iterator it =
  1382.             find(m_PosArgs.begin(), m_PosArgs.end(), name);
  1383.         _ASSERT (it != m_PosArgs.end());
  1384.         m_PosArgs.erase(it);
  1385.         _ASSERT(find(m_PosArgs.begin(), m_PosArgs.end(), name) ==
  1386.                      m_PosArgs.end());
  1387.     }}
  1388. }
  1391. // Fake class to hold only a name -- to find in "m_Args"
  1392. class CArgDesc_NameOnly : public CArgDesc
  1393. {
  1394. public:
  1395.     CArgDesc_NameOnly(const string& name) :
  1396.         CArgDesc(name, kEmptyStr) {}
  1397. private:
  1398.     virtual string GetUsageSynopsis(bool/*name_only*/) const{return kEmptyStr;}
  1399.     virtual string GetUsageCommentAttr(void) const {return kEmptyStr;}
  1400.     virtual CArgValue* ProcessArgument(const string&) const {return 0;}
  1401.     virtual CArgValue* ProcessDefault(void) const {return 0;}
  1402. };
  1404. CArgDescriptions::TArgsCI CArgDescriptions::x_Find(const string& name) const
  1405. {
  1406.     return m_Args.find(AutoPtr<CArgDesc> (new CArgDesc_NameOnly(name)));
  1407. }
  1409. CArgDescriptions::TArgsI CArgDescriptions::x_Find(const string& name)
  1410. {
  1411.     return m_Args.find(AutoPtr<CArgDesc> (new CArgDesc_NameOnly(name)));
  1412. }
  1416. void CArgDescriptions::x_PreCheck(void) const
  1417. {
  1418.     // Check for the consistency of positional args
  1419.     if ( m_nExtra ) {
  1420.         for (TPosArgs::const_iterator name = m_PosArgs.begin();
  1421.              name != m_PosArgs.end();  ++name) {
  1422.             TArgsCI arg_it = x_Find(*name);
  1423.             _ASSERT(arg_it != m_Args.end());
  1424.             CArgDesc& arg = **arg_it;
  1426.             if (dynamic_cast<const CArgDesc_PosOpt*> (&arg)) {
  1427.                 NCBI_THROW(CArgException, eSynopsis,
  1428.                     "Having both optional named and required unnamed "
  1429.                     "positional arguments is prohibited");
  1430.             }
  1431.         }
  1432.     }
  1434.     // Check for the validity of default values
  1435.     for (TArgsCI it = m_Args.begin();  it != m_Args.end();  ++it) {
  1436.         CArgDesc& arg = **it;
  1438.         if (dynamic_cast<CArgDescDefault*> (&arg) == 0) {
  1439.             continue;
  1440.         }
  1442.         try {
  1443.             arg.VerifyDefault();
  1444.             continue;
  1445.         } catch (CException& e) {
  1446.             NCBI_RETHROW(e,CArgException,eConstraint,
  1447.                 "Invalid default argument value");
  1448.         } catch (exception& e) {
  1449.             NCBI_THROW(CArgException, eConstraint,
  1450.                 string("Invalid default value: ") + e.what());
  1451.         }
  1452.     }
  1453. }
  1456. CArgs* CArgDescriptions::CreateArgs(const CNcbiArguments& args) const
  1457. {
  1458.     return CreateArgs(args.Size(), args);
  1459. }
  1462. void CArgDescriptions::x_CheckAutoHelp(const string& arg) const
  1463. {
  1464.     _ASSERT(m_AutoHelp);
  1465.     if (arg.compare('-' + s_AutoHelp) == 0) {
  1466.         NCBI_THROW(CArgHelpException,eHelp,kEmptyStr);
  1467.     }
  1468. }
  1470. // (return TRUE if "arg2" was used)
  1471. bool CArgDescriptions::x_CreateArg
  1472. (const string& arg1,
  1473.  bool have_arg2, const string& arg2,
  1474.  unsigned* n_plain, CArgs& args)
  1475.     const
  1476. {
  1477.     // Argument name
  1478.     string name;
  1480.     // Check if to start processing the args as positional
  1481.     if (*n_plain == kMax_UInt) {
  1482.         // Check for the "--" delimiter
  1483.         if (arg1.compare("--") == 0) {
  1484.             *n_plain = 0;  // pos.args started
  1485.             return false;
  1486.         }
  1487.         // Check if argument has not a key/flag syntax
  1488.         if ((arg1.length() > 1)  &&  arg1[0] == '-') {
  1489.             // Extract name of flag or key
  1490.             name = arg1.substr(1);
  1491.             if ( !VerifyName(name) ) {
  1492.                 *n_plain = 0;  // pos.args started
  1493.             }
  1494.         } else {
  1495.             *n_plain = 0;  // pos.args started
  1496.         }
  1497.     }
  1499.     // Whether the value of "arg2" is used
  1500.     bool arg2_used = false;
  1502.     // Extract name of positional argument
  1503.     if (*n_plain != kMax_UInt) {
  1504.         if (*n_plain < m_PosArgs.size()) {
  1505.             name = m_PosArgs[*n_plain];  // named positional argument
  1506.         } else {
  1507.             name = kEmptyStr;  // unnamed (extra) positional argument
  1508.         }
  1509.         (*n_plain)++;
  1511.         // Check for too many positional arguments
  1512.         if (kMax_UInt - m_nExtraOpt > m_nExtra + m_PosArgs.size()  &&
  1513.             *n_plain > m_PosArgs.size() + m_nExtra + m_nExtraOpt) {
  1514.             NCBI_THROW(CArgException,eSynopsis,
  1515.                 "Too many positional arguments (" +
  1516.                 NStr::UIntToString(*n_plain) +
  1517.                 "), the offending value: "+ arg1);
  1518.         }
  1519.     }
  1521.     // Get arg. description
  1522.     TArgsCI it = x_Find(name);
  1523.     if (it == m_Args.end()) {
  1524.         if ( name.empty() ) {
  1525.             NCBI_THROW(CArgException,eInvalidArg,
  1526.                 "Unexpected extra argument, at position # " +
  1527.                 NStr::UIntToString(*n_plain));
  1528.         } else {
  1529.             NCBI_THROW(CArgException,eInvalidArg,
  1530.                 "Unknown argument: "+ name);
  1531.         }
  1532.     }
  1533.     _ASSERT(*it);
  1535.     const CArgDesc& arg = **it;
  1537.     // Get argument value
  1538.     const string* value;
  1539.     if ( s_IsKey(arg) ) {
  1540.         // <key> <value> arg  -- advance from the arg.name to the arg.value
  1541.         if ( !have_arg2 ) {
  1542.             NCBI_THROW(CArgException,eNoValue,s_ArgExptMsg(arg1,
  1543.                 "Value is missing", kEmptyStr));
  1544.         }
  1545.         value = &arg2;
  1546.         arg2_used = true;
  1547.     } else {
  1548.         value = &arg1;
  1549.     }
  1551.     // Process the "raw" argument value into "CArgValue"
  1552.     CRef<CArgValue> arg_value(arg.ProcessArgument(*value));
  1554.     // Add the argument value to "args"
  1555.     args.Add(arg_value);
  1557.     // Success (also indicate whether one or two "raw" args have been used)
  1558.     return arg2_used;
  1559. }
  1562. void CArgDescriptions::x_PostCheck(CArgs& args, unsigned n_plain) const
  1563. {
  1564.     // If explicitly specified, printout usage and exit in case there
  1565.     // was no args passed to the application
  1566.     if (m_UsageIfNoArgs  &&  args.IsEmpty()) {
  1567.         NCBI_THROW(CArgHelpException, eHelp, kEmptyStr);
  1568.     }
  1570.     // Check if all mandatory unnamed positional arguments are provided
  1571.     if (m_PosArgs.size() <= n_plain  &&  
  1572.         n_plain < m_PosArgs.size() + m_nExtra){
  1573.         NCBI_THROW(CArgException,eNoArg,
  1574.             "Too few (" + NStr::UIntToString(n_plain) +
  1575.             ") unnamed positional arguments. Must define at least " +
  1576.             NStr::UIntToString(m_nExtra));
  1577.     }
  1579.     // Compose an ordered list of args
  1580.     list<const CArgDesc*> def_args;
  1581.     ITERATE (TKeyFlagArgs, it, m_KeyFlagArgs) {
  1582.         const CArgDesc& arg = **x_Find(*it);
  1583.         def_args.push_back(&arg);
  1584.     }
  1585.     ITERATE (TPosArgs, it, m_PosArgs) {
  1586.         const CArgDesc& arg = **x_Find(*it);
  1587.         def_args.push_back(&arg);
  1588.     }
  1590.     // Set default values (if available) for the arguments not defined
  1591.     // in the command line.
  1592.     ITERATE (list<const CArgDesc*>, it, def_args) {
  1593.         const CArgDesc& arg = **it;
  1595.         // Nothing to do if defined in the command-line
  1596.         if ( args.Exist(arg.GetName()) ) {
  1597.             continue;
  1598.         }
  1600.         // Use default argument value
  1601.         CRef<CArgValue> arg_value(arg.ProcessDefault());
  1603.         // Add the value to "args"
  1604.         args.Add(arg_value);
  1605.     }
  1606. }
  1609. void CArgDescriptions::SetUsageContext
  1610. (const string& usage_name,
  1611.  const string& usage_description,
  1612.  bool          usage_sort_args,
  1613.  SIZE_TYPE     usage_width)
  1614. {
  1615.     m_UsageName        = usage_name;
  1616.     m_UsageDescription = usage_description;
  1617.     m_UsageSortArgs    = usage_sort_args;
  1619.     const SIZE_TYPE kMinUsageWidth = 30;
  1620.     if (usage_width < kMinUsageWidth) {
  1621.         usage_width = kMinUsageWidth;
  1622.         ERR_POST(Warning <<
  1623.                  "CArgDescriptions::SetUsageContext() -- usage_width=" <<
  1624.                  usage_width << " adjusted to " << kMinUsageWidth);
  1625.     }
  1626.     m_UsageWidth = usage_width;
  1627. }
  1630. bool CArgDescriptions::VerifyName(const string& name, bool extended)
  1631. {
  1632.     if ( name.empty() )
  1633.         return true;
  1635.     string::const_iterator it = name.begin();
  1636.     if (extended  &&  *it == '#') {
  1637.         for (++it;  it != name.end();  ++it) {
  1638.             if ( !isdigit(*it) ) {
  1639.                 return false;
  1640.             }
  1641.         }
  1642.     } else {
  1643.         for ( ;  it != name.end();  ++it) {
  1644.             if (!isalnum(*it)  &&  *it != '_')
  1645.                 return false;
  1646.         }
  1647.     }
  1649.     return true;
  1650. }
  1653. void CArgDescriptions::x_AddDesc(CArgDesc& arg)
  1654. {
  1655.     const string& name = arg.GetName();
  1657.     if ( Exist(name) ) {
  1658.         NCBI_THROW(CArgException,eSynopsis,
  1659.             "Argument with this name is already defined: " + name);
  1660.     }
  1662.     if (s_IsKey(arg)  ||  s_IsFlag(arg)) {
  1663.         _ASSERT(find(m_KeyFlagArgs.begin(), m_KeyFlagArgs.end(), name)
  1664.                 == m_KeyFlagArgs.end());
  1665.         m_KeyFlagArgs.push_back(name);
  1666.     } else if ( !name.empty() ) {
  1667.         _ASSERT(find(m_PosArgs.begin(), m_PosArgs.end(), name)
  1668.                 == m_PosArgs.end());
  1669.         if ( s_IsOptional(arg) ) {
  1670.             m_PosArgs.push_back(name);
  1671.         } else {
  1672.             TPosArgs::iterator it;
  1673.             for (it = m_PosArgs.begin();  it != m_PosArgs.end();  ++it) {
  1674.                 if ( s_IsOptional(**x_Find(*it)) )
  1675.                     break;
  1676.             }
  1677.             m_PosArgs.insert(it, name);
  1678.         }
  1679.     }
  1681.     m_Args.insert(&arg);
  1682. }
  1685. void CArgDescriptions::PrintUsageIfNoArgs(bool do_print)
  1686. {
  1687.     m_UsageIfNoArgs = do_print;
  1688. }
  1692. ///////////////////////////////////////////////////////
  1693. //  CArgDescriptions::PrintUsage()
  1696. static void s_PrintCommentBody(list<string>& arr, const string& s,
  1697.                                SIZE_TYPE width)
  1698. {
  1699.     NStr::Wrap(s, width, arr, NStr::fWrap_Hyphenate, "   ");
  1700. }
  1703. static void s_PrintComment(list<string>& arr, const CArgDesc& arg,
  1704.                            SIZE_TYPE width)
  1705. {
  1706.     string intro = ' ' + arg.GetUsageSynopsis(true/*name_only*/);
  1708.     // Print type (and value constraint, if any)
  1709.     string attr = arg.GetUsageCommentAttr();
  1710.     if ( !attr.empty() ) {
  1711.         intro += " <";
  1712.         intro += attr;
  1713.         intro += '>';
  1714.     }
  1716.     // Wrap intro if necessary...
  1717.     {{
  1718.         SIZE_TYPE indent = intro.find(", ");
  1719.         if (indent == NPOS  ||  indent > width / 2) {
  1720.             indent = intro.find(" <");
  1721.             if (indent == NPOS  ||  indent > width / 2) {
  1722.                 indent = 0;
  1723.             }
  1724.         }
  1725.         NStr::Wrap(intro, width, arr, NStr::fWrap_Hyphenate,
  1726.                    string(indent + 2, ' '), kEmptyStr);
  1727.     }}
  1729.     // Print description
  1730.     s_PrintCommentBody(arr, arg.GetComment(), width);
  1732.     // Print default value, if any
  1733.     const CArgDescDefault* dflt = dynamic_cast<const CArgDescDefault*> (&arg);
  1734.     if ( dflt ) {
  1735.         s_PrintCommentBody
  1736.             (arr, "Default = `" + dflt->GetDefaultValue() + ''', width);
  1737.     }
  1738. }
  1741. string& CArgDescriptions::PrintUsage(string& str) const
  1742. {
  1743.     typedef list<const CArgDesc*> TList;
  1744.     typedef TList::iterator       TListI;
  1745.     typedef TList::const_iterator TListCI;
  1747.     TList args;
  1749.     args.push_front(0);
  1750.     TListI it_pos = args.begin();
  1752.     // Keys and Flags
  1753.     if ( m_UsageSortArgs ) {
  1754.         // Alphabetically ordered,
  1755.         // mandatory keys to go first, then flags, then optional keys
  1756.         TListI& it_opt_keys = it_pos; 
  1757.         args.push_front(0);
  1758.         TListI it_flags = args.begin();
  1759.         args.push_front(0);
  1760.         TListI it_keys  = args.begin();
  1762.         for (TArgsCI it = m_Args.begin();  it != m_Args.end();  ++it) {
  1763.             const CArgDesc* arg = it->get();
  1765.             if (dynamic_cast<const CArgDesc_KeyOpt*> (arg)  ||
  1766.                 dynamic_cast<const CArgDesc_KeyDef*> (arg)) {
  1767.                 args.insert(it_opt_keys, arg);
  1768.             } else if (dynamic_cast<const CArgDesc_Key*> (arg)) {
  1769.                 args.insert(it_keys, arg);
  1770.             } else if (dynamic_cast<const CArgDesc_Flag*> (arg)) {
  1771.                 if (s_AutoHelp.compare(arg->GetName()) == 0)
  1772.                     args.push_front(arg);
  1773.                 else
  1774.                     args.insert(it_flags, arg);
  1775.             }
  1776.         }
  1777.         args.erase(it_keys);
  1778.         args.erase(it_flags);
  1779.     } else {
  1780.         // Unsorted, just the order they were described by user
  1781.         for (TKeyFlagArgs::const_iterator name = m_KeyFlagArgs.begin();
  1782.              name != m_KeyFlagArgs.end();  ++name) {
  1783.             TArgsCI it = x_Find(*name);
  1784.             _ASSERT(it != m_Args.end());
  1786.             args.insert(it_pos, it->get());
  1787.         }
  1788.     }
  1790.     // Positional
  1791.     for (TPosArgs::const_iterator name = m_PosArgs.begin();
  1792.          name != m_PosArgs.end();  ++name) {
  1793.         TArgsCI it = x_Find(*name);
  1794.         _ASSERT(it != m_Args.end());
  1795.         const CArgDesc* arg = it->get();
  1797.         // Mandatory args to go first, then go optional ones
  1798.         if (dynamic_cast<const CArgDesc_PosOpt*> (arg)) {
  1799.             args.push_back(arg);
  1800.         } else if (dynamic_cast<const CArgDesc_Pos*> (arg)) {
  1801.             args.insert(it_pos, arg);
  1802.         }
  1803.     }
  1804.     args.erase(it_pos);
  1806.     // Extra
  1807.     {{
  1808.         TArgsCI it = x_Find(kEmptyStr);
  1809.         if (it != m_Args.end()) {
  1810.             args.push_back(it->get());
  1811.         }
  1812.     }}
  1815.     // Do Printout
  1816.     TListCI      it;
  1817.     list<string> arr;
  1819.     // SYNOPSIS
  1820.     arr.push_back("USAGE");
  1821.     {{
  1822.         list<string> syn;
  1823.         syn.push_back(m_UsageName);
  1824.         for (it = args.begin();  it != args.end();  ++it) {
  1825.             if ( s_IsOptional(**it) || s_IsFlag(**it) ) {
  1826.                 syn.push_back('[' + (*it)->GetUsageSynopsis() + ']');
  1827.             } else if ( s_IsPositional(**it) ) {
  1828.                 syn.push_back('<' + (*it)->GetUsageSynopsis() + '>');
  1829.             } else {
  1830.                 syn.push_back((*it)->GetUsageSynopsis());
  1831.             }
  1832.         }
  1833.         NStr::WrapList(syn, m_UsageWidth, " ", arr, 0, "    ", "  ");
  1834.     }}
  1836.     // DESCRIPTION
  1837.     arr.push_back(kEmptyStr);
  1838.     if ( m_UsageDescription.empty() ) {
  1839.         arr.push_back("DESCRIPTION    -- none");
  1840.     } else {
  1841.         arr.push_back("DESCRIPTION");
  1842.         s_PrintCommentBody(arr, m_UsageDescription, m_UsageWidth);
  1843.     }
  1845.     // REQUIRED & OPTIONAL ARGUMENTS
  1846.     list<string> req;
  1847.     list<string> opt;
  1848.     for (it = args.begin();  it != args.end();  ++it) {
  1849.         s_PrintComment((s_IsOptional(**it) || s_IsFlag(**it)) ? opt : req,
  1850.                        **it, m_UsageWidth);
  1851.     }
  1852.     if ( !req.empty() ) {
  1853.         arr.push_back(kEmptyStr);
  1854.         arr.push_back("REQUIRED ARGUMENTS");
  1855.         arr.splice(arr.end(), req);
  1856.     }
  1857.     if ( !m_nExtra  &&  !opt.empty() ) {
  1858.         arr.push_back(kEmptyStr);
  1859.         arr.push_back("OPTIONAL ARGUMENTS");
  1860.         arr.splice(arr.end(), opt);
  1861.     }
  1863.     // # of extra arguments
  1864.     if (m_nExtra  ||  (m_nExtraOpt != 0  &&  m_nExtraOpt != kMax_UInt)) {
  1865.         string str_extra = "NOTE:  Specify ";
  1866.         if ( m_nExtra ) {
  1867.             str_extra += "at least ";
  1868.             str_extra += NStr::UIntToString(m_nExtra);
  1869.             if (m_nExtraOpt != kMax_UInt) {
  1870.                 str_extra += ", and ";
  1871.             }
  1872.         }
  1873.         if (m_nExtraOpt != kMax_UInt) {
  1874.             str_extra += "no more than ";
  1875.             str_extra += NStr::UIntToString(m_nExtra + m_nExtraOpt);
  1876.         }
  1877.         str_extra += " arguments in "...."";
  1878.         s_PrintCommentBody(arr, str_extra, m_UsageWidth);
  1879.     }
  1880.     if ( m_nExtra  &&  !opt.empty() ) {
  1881.         arr.push_back(kEmptyStr);
  1882.         arr.push_back("OPTIONAL ARGUMENTS");
  1883.         arr.splice(arr.end(), opt);
  1884.     }
  1886.     str += NStr::Join(arr, "n");
  1887.     str += "n";
  1888.     return str;
  1889. }
  1894. ///////////////////////////////////////////////////////
  1895. ///////////////////////////////////////////////////////
  1896. // CArgAllow::
  1897. //   CArgAllow_Symbols::
  1898. //   CArgAllow_String::
  1899. //   CArgAllow_Strings::
  1900. //   CArgAllow_Integers::
  1901. //   CArgAllow_Doubles::
  1902. //
  1905. ///////////////////////////////////////////////////////
  1906. //  CArgAllow::
  1907. //
  1909. CArgAllow::~CArgAllow(void)
  1910. {
  1911.     return;
  1912. }
  1916. ///////////////////////////////////////////////////////
  1917. //  s_IsSymbol() -- check if the symbol belongs to one of standard character
  1918. //                  classes from <ctype.h>, or to user-defined symbol set
  1919. //
  1921. inline bool s_IsAllowedSymbol(unsigned char                   ch,
  1922.                               CArgAllow_Symbols::ESymbolClass symbol_class,
  1923.                               const string&                   symbol_set)
  1924. {
  1925.     switch ( symbol_class ) {
  1926.     case CArgAllow_Symbols::eAlnum:   return isalnum(ch) != 0;
  1927.     case CArgAllow_Symbols::eAlpha:   return isalpha(ch) != 0;
  1928.     case CArgAllow_Symbols::eCntrl:   return iscntrl(ch) != 0;
  1929.     case CArgAllow_Symbols::eDigit:   return isdigit(ch) != 0;
  1930.     case CArgAllow_Symbols::eGraph:   return isgraph(ch) != 0;
  1931.     case CArgAllow_Symbols::eLower:   return islower(ch) != 0;
  1932.     case CArgAllow_Symbols::ePrint:   return isprint(ch) != 0;
  1933.     case CArgAllow_Symbols::ePunct:   return ispunct(ch) != 0;
  1934.     case CArgAllow_Symbols::eSpace:   return isspace(ch) != 0;
  1935.     case CArgAllow_Symbols::eUpper:   return isupper(ch) != 0;
  1936.     case CArgAllow_Symbols::eXdigit:  return isxdigit(ch) != 0;
  1937.     case CArgAllow_Symbols::eUser:
  1938.         return symbol_set.find_first_of(ch) != NPOS;
  1939.     }
  1940.     _TROUBLE;  return false;
  1941. }
  1944. static string s_GetUsageSymbol(CArgAllow_Symbols::ESymbolClass symbol_class,
  1945.                                const string&                   symbol_set)
  1946. {
  1947.     switch ( symbol_class ) {
  1948.     case CArgAllow_Symbols::eAlnum:   return "alphanumeric";
  1949.     case CArgAllow_Symbols::eAlpha:   return "alphabetic";
  1950.     case CArgAllow_Symbols::eCntrl:   return "control symbol";
  1951.     case CArgAllow_Symbols::eDigit:   return "decimal";
  1952.     case CArgAllow_Symbols::eGraph:   return "graphical symbol";
  1953.     case CArgAllow_Symbols::eLower:   return "lower case";
  1954.     case CArgAllow_Symbols::ePrint:   return "printable";
  1955.     case CArgAllow_Symbols::ePunct:   return "punctuation";
  1956.     case CArgAllow_Symbols::eSpace:   return "space";
  1957.     case CArgAllow_Symbols::eUpper:   return "upper case";
  1958.     case CArgAllow_Symbols::eXdigit:  return "hexadecimal";
  1959.     case CArgAllow_Symbols::eUser:
  1960.         return "'" + NStr::PrintableString(symbol_set) + "'";
  1961.     }
  1962.     _TROUBLE;  return kEmptyStr;
  1963. }
  1967. ///////////////////////////////////////////////////////
  1968. //  CArgAllow_Symbols::
  1969. //
  1971. CArgAllow_Symbols::CArgAllow_Symbols(ESymbolClass symbol_class)
  1972.     : CArgAllow(),
  1973.       m_SymbolClass(symbol_class)
  1974. {
  1975.     return;
  1976. }
  1979. CArgAllow_Symbols::CArgAllow_Symbols(const string& symbol_set)
  1980.     : CArgAllow(),
  1981.       m_SymbolClass(eUser), m_SymbolSet(symbol_set)
  1982. {
  1983.     return;
  1984. }
  1987. bool CArgAllow_Symbols::Verify(const string& value) const
  1988. {
  1989.     if (value.length() != 1)
  1990.         return false;
  1992.     return s_IsAllowedSymbol(value[0], m_SymbolClass, m_SymbolSet);
  1993. }
  1996. string CArgAllow_Symbols::GetUsage(void) const
  1997. {
  1998.     return "one symbol: " + s_GetUsageSymbol(m_SymbolClass, m_SymbolSet);
  1999. }
  2002. CArgAllow_Symbols::~CArgAllow_Symbols(void)
  2003. {
  2004.     return;
  2005. }
  2009. ///////////////////////////////////////////////////////
  2010. //  CArgAllow_String::
  2011. //
  2013. CArgAllow_String::CArgAllow_String(ESymbolClass symbol_class)
  2014.     : CArgAllow_Symbols(symbol_class)
  2015. {
  2016.     return;
  2017. }
  2020. CArgAllow_String::CArgAllow_String(const string& symbol_set)
  2021.     : CArgAllow_Symbols(symbol_set)
  2022. {
  2023.     return;
  2024. }
  2027. bool CArgAllow_String::Verify(const string& value) const
  2028. {
  2029.     for (string::const_iterator it = value.begin();  it != value.end(); ++it) {
  2030.         if ( !s_IsAllowedSymbol(*it, m_SymbolClass, m_SymbolSet) )
  2031.             return false;
  2032.     }
  2033.     return true;
  2034. }
  2037. string CArgAllow_String::GetUsage(void) const
  2038. {
  2039.     return "to contain only symbols: " +
  2040.         s_GetUsageSymbol(m_SymbolClass, m_SymbolSet);
  2041. }
  2045. ///////////////////////////////////////////////////////
  2046. //  CArgAllow_Strings::
  2047. //
  2049. CArgAllow_Strings::CArgAllow_Strings(void)
  2050.     : CArgAllow()
  2051. {
  2052.     return;
  2053. }
  2056. CArgAllow_Strings* CArgAllow_Strings::Allow(const string& value)
  2057. {
  2058.     m_Strings.insert(value);
  2059.     return this;
  2060. }
  2063. bool CArgAllow_Strings::Verify(const string& value) const
  2064. {
  2065.     return (m_Strings.find(value) != m_Strings.end());
  2066. }
  2069. string CArgAllow_Strings::GetUsage(void) const
  2070. {
  2071.     if ( m_Strings.empty() ) {
  2072.         return "ERROR:  Constraint with no values allowed(?!)";
  2073.     }
  2075.     string str;
  2076.     set<string>::const_iterator it = m_Strings.begin();
  2077.     for (;;) {
  2078.         str += "`";
  2079.         str += *it;
  2081.         ++it;
  2082.         if (it == m_Strings.end()) {
  2083.             str += "'";
  2084.             break;
  2085.         }
  2086.         str += "', ";
  2087.     }
  2088.     return str;
  2089. }
  2092. CArgAllow_Strings::~CArgAllow_Strings(void)
  2093. {
  2094.     return;
  2095. }
  2099. ///////////////////////////////////////////////////////
  2100. //  CArgAllow_Integers::
  2101. //
  2103. CArgAllow_Integers::CArgAllow_Integers(int x_min, int x_max)
  2104.     : CArgAllow()
  2105. {
  2106.     if (x_min <= x_max) {
  2107.         m_Min = x_min;
  2108.         m_Max = x_max;
  2109.     } else {
  2110.         m_Min = x_max;
  2111.         m_Max = x_min;
  2112.     }
  2113. }
  2116. bool CArgAllow_Integers::Verify(const string& value) const
  2117. {
  2118.     int val = NStr::StringToInt(value);
  2119.     return (m_Min <= val  &&  val <= m_Max);
  2120. }
  2123. string CArgAllow_Integers::GetUsage(void) const
  2124. {
  2125.     return NStr::IntToString(m_Min) + ".." + NStr::IntToString(m_Max);
  2126. }
  2130. ///////////////////////////////////////////////////////
  2131. //  CArgAllow_Doubles::
  2132. //
  2134. CArgAllow_Doubles::CArgAllow_Doubles(double x_min, double x_max)
  2135.     : CArgAllow()
  2136. {
  2137.     if (x_min <= x_max) {
  2138.         m_Min = x_min;
  2139.         m_Max = x_max;
  2140.     } else {
  2141.         m_Min = x_max;
  2142.         m_Max = x_min;
  2143.     }
  2144. }
  2147. bool CArgAllow_Doubles::Verify(const string& value) const
  2148. {
  2149.     double val = NStr::StringToDouble(value);
  2150.     return (m_Min <= val  &&  val <= m_Max);
  2151. }
  2154. string CArgAllow_Doubles::GetUsage(void) const
  2155. {
  2156.     return NStr::DoubleToString(m_Min) + ".." + NStr::DoubleToString(m_Max);
  2157. }
  2160. END_NCBI_SCOPE
  2163. /*
  2164.  * ===========================================================================
  2165.  * $Log: ncbiargs.cpp,v $
  2166.  * Revision 1000.1  2004/06/01 19:08:48  gouriano
  2167.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.48
  2168.  *
  2169.  * Revision 1.48  2004/05/14 13:59:26  gorelenk
  2170.  * Added include of ncbi_pch.hpp
  2171.  *
  2172.  * Revision 1.47  2003/09/16 19:51:36  rsmith
  2173.  * move CreateArgs definition to avoid new Codewarrior compiler bug.
  2174.  *
  2175.  * Revision 1.46  2003/05/28 18:01:58  kuznets
  2176.  * Changed program help (usage section). Now prints flags as optional argument in []
  2177.  *
  2178.  * Revision 1.45  2003/05/16 16:00:41  vakatov
  2179.  * + CArgs::IsEmpty()
  2180.  * + CArgDescriptions::PrintUsageIfNoArgs()
  2181.  *
  2182.  * Revision 1.44  2003/03/10 18:57:07  kuznets
  2183.  * iterate->ITERATE
  2184.  *
  2185.  * Revision 1.43  2003/02/10 18:07:07  kuznets
  2186.  * Fixed problem with mandatory extra args
  2187.  *
  2188.  * Revision 1.42  2002/11/04 21:29:04  grichenk
  2189.  * Fixed usage of const CRef<> and CRef<> constructor
  2190.  *
  2191.  * Revision 1.41  2002/10/03 14:44:34  ucko
  2192.  * Tweak the interfaces to NStr::Wrap* to avoid publicly depending on
  2193.  * kEmptyStr, removing the need for fWrap_UsePrefix1 in the process; also
  2194.  * drop fWrap_FavorPunct, as WrapList should be a better choice for such
  2195.  * situations.
  2196.  *
  2197.  * Revision 1.40  2002/10/02 20:16:46  ucko
  2198.  * Take advantage of the new wrapping-related code in NStr:: when
  2199.  * formatting usage messages.
  2200.  * Move the note about "...." up if there are required extra arguments.
  2201.  *
  2202.  * Revision 1.39  2002/08/08 18:37:32  gouriano
  2203.  * corrected CArgDescriptions::Delete
  2204.  *
  2205.  * Revision 1.38  2002/07/15 18:17:23  gouriano
  2206.  * renamed CNcbiException and its descendents
  2207.  *
  2208.  * Revision 1.37  2002/07/11 14:18:25  gouriano
  2209.  * exceptions replaced by CNcbiException-type ones
  2210.  *
  2211.  * Revision 1.36  2002/06/13 20:41:57  ucko
  2212.  * Improve usage formatting for long choice lists.
  2213.  *
  2214.  * Revision 1.35  2002/04/24 04:02:45  vakatov
  2215.  * Do not use #NO_INCLASS_TMPL anymore -- apparently all modern
  2216.  * compilers seem to be supporting in-class template methods.
  2217.  *
  2218.  * Revision 1.34  2002/04/11 21:08:01  ivanov
  2219.  * CVS log moved to end of the file
  2220.  *
  2221.  * Revision 1.33  2001/07/24 23:33:14  vakatov
  2222.  * Use _DEBUG_ARG() to get rid of the compiler warnings in Release mode
  2223.  *
  2224.  * Revision 1.32  2001/03/16 16:40:18  vakatov
  2225.  * Moved <corelib/ncbi_limits.h> to the header
  2226.  *
  2227.  * Revision 1.31  2001/01/22 23:07:14  vakatov
  2228.  * CArgValue::AsInteger() to return "int" (rather than "long")
  2229.  *
  2230.  * Revision 1.30  2001/01/03 17:45:35  vakatov
  2231.  * + <ncbi_limits.h>
  2232.  *
  2233.  * Revision 1.29  2000/12/24 00:13:00  vakatov
  2234.  * Radically revamped NCBIARGS.
  2235.  * Introduced optional key and posit. args without default value.
  2236.  * Added new arg.value constraint classes.
  2237.  * Passed flags to be detected by HasValue() rather than AsBoolean.
  2238.  * Simplified constraints on the number of mandatory and optional extra args.
  2239.  * Improved USAGE info and diagnostic messages. Etc...
  2240.  *
  2241.  * Revision 1.26  2000/11/29 00:18:13  vakatov
  2242.  * s_ProcessArgument() -- avoid nested quotes in the exception message
  2243.  *
  2244.  * Revision 1.25  2000/11/29 00:07:28  vakatov
  2245.  * Flag and key args not to be sorted in alphabetical order by default; see
  2246.  * "usage_sort_args" in SetUsageContext().
  2247.  *
  2248.  * Revision 1.24  2000/11/24 23:28:33  vakatov
  2249.  * CArgValue::  added CloseFile()
  2250.  * CArgValue::  get rid of "change_mode" feature in AsInput/OutputFile()
  2251.  *
  2252.  * Revision 1.23  2000/11/22 22:04:31  vakatov
  2253.  * Added special flag "-h" and special exception CArgHelpException to
  2254.  * force USAGE printout in a standard manner
  2255.  *
  2256.  * Revision 1.22  2000/11/17 22:04:30  vakatov
  2257.  * CArgDescriptions::  Switch the order of optional args in methods
  2258.  * AddOptionalKey() and AddPlain(). Also, enforce the default value to
  2259.  * match arg. description (and constraints, if any) at all times.
  2260.  *
  2261.  * Revision 1.21  2000/11/13 20:31:07  vakatov
  2262.  * Wrote new test, fixed multiple bugs, ugly "features", and the USAGE.
  2263.  *
  2264.  * Revision 1.20  2000/11/09 21:02:58  vakatov
  2265.  * USAGE to show default value for optional arguments
  2266.  *
  2267.  * Revision 1.19  2000/11/08 17:48:37  butanaev
  2268.  * There was no minus in optional key synopsis, fixed.
  2269.  *
  2270.  * Revision 1.18  2000/11/01 20:37:15  vasilche
  2271.  * Fixed detection of heap objects.
  2272.  * Removed ECanDelete enum and related constructors.
  2273.  * Disabled sync_with_stdio ad the beginning of AppMain.
  2274.  *
  2275.  * Revision 1.17  2000/10/30 22:26:29  vakatov
  2276.  * Get rid of "s_IsAvailableExtra()" -- not used anymore
  2277.  *
  2278.  * Revision 1.16  2000/10/20 22:33:37  vakatov
  2279.  * CArgAllow_Integers, CArgAllow_Doubles:  swap min/max, if necessary
  2280.  *
  2281.  * Revision 1.15  2000/10/20 22:23:28  vakatov
  2282.  * CArgAllow_Strings customization;  MSVC++ fixes;  better diagnostic messages
  2283.  *
  2284.  * Revision 1.14  2000/10/20 20:25:55  vakatov
  2285.  * Redesigned/reimplemented the user-defined arg.value constraints
  2286.  * mechanism (CArgAllow-related classes and methods). +Generic clean-up.
  2287.  *
  2288.  * Revision 1.13  2000/10/13 16:26:30  vasilche
  2289.  * Added heuristic for detection of CObject allocation in heap.
  2290.  *
  2291.  * Revision 1.12  2000/10/11 21:03:49  vakatov
  2292.  * Cleanup to avoid 64-bit to 32-bit values truncation, etc.
  2293.  * (reported by Forte6 Patch 109490-01)
  2294.  *
  2295.  * Revision 1.11  2000/10/06 21:56:45  butanaev
  2296.  * Added Allow() function. Added classes CArgAllowValue, CArgAllowIntInterval.
  2297.  *
  2298.  * Revision 1.10  2000/09/29 17:10:54  butanaev
  2299.  * Got rid of IsDefaultValue(), added IsProvided().
  2300.  *
  2301.  * Revision 1.9  2000/09/28 21:00:14  butanaev
  2302.  * fPreOpen with opposite meaning took over fDelayOpen.
  2303.  * IsDefaultValue() added which returns true if no
  2304.  * value for an optional argument was provided in cmd. line.
  2305.  *
  2306.  *
  2307.  * Revision 1.7  2000/09/28 19:38:00  butanaev
  2308.  * stdin and stdout now referenced as '-' Example: ./test_ncbiargs -if - -of -
  2309.  *
  2310.  * Revision 1.6  2000/09/22 21:25:59  butanaev
  2311.  * Fixed bug in handling default arg values.
  2312.  *
  2313.  * Revision 1.5  2000/09/19 21:19:58  butanaev
  2314.  * Added possibility to change file open mode on the fly
  2315.  *
  2316.  * Revision 1.4  2000/09/18 19:39:02  vasilche
  2317.  * Added CreateArgs() from CNcbiArguments.
  2318.  *
  2319.  * Revision 1.3  2000/09/12 15:00:30  butanaev
  2320.  * Fixed bug with stdin, stdout caused compilation errors on IRIX.
  2321.  *
  2322.  * Revision 1.2  2000/09/06 18:56:04  butanaev
  2323.  * Added stdin, stdout support. Fixed bug in PrintOut.
  2324.  *
  2325.  * Revision 1.1  2000/08/31 23:54:49  vakatov
  2326.  * Initial revision
  2327.  *
  2328.  * ===========================================================================
  2329.  */