Arguments.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/Arguments.h - Released 2024-06-18T15:48:54Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_Arguments_h
#define __PCL_Arguments_h
 
 
#include <pcl/Defs.h>
 
#include <pcl/Flags.h>
#include <pcl/String.h>
#include <pcl/StringList.h>
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS Argument
{
public:
 
   Argument()
   {
      Initialize();
   }
 
   Argument( const String& argv )
   {
      Parse( argv.c_str() );
   }
 
   Argument( const char16_type* argv )
   {
      Parse( argv );
   }
 
   Argument( const String& argv, const StringList& items )
   {
      type = item_arg;
      token = argv;
      asItems = items;
   }
 
   Argument( const Argument& ) = default;
 
   Argument& operator =( const Argument& ) = default;
 
   bool operator ==( const Argument& x ) const
   {
      if ( id == x.id && type == x.type )
      {
         if ( IsLiteral() || !IsValid() )
            return true;
         if ( IsNumeric() )
            return asNumeric == x.asNumeric;
         if ( IsString() )
            return asString == x.asString;
         if ( IsSwitch() )
            return asSwitch == x.asSwitch;
         if ( IsItemList() )
            return asItems == x.asItems;
      }
      return false;
   }
 
   bool IsValid() const
   {
      return type != invalid_arg;
   }
 
   String Token() const
   {
      return token;
   }
 
   String Id() const
   {
      return id;
   }
 
   bool IsItemList() const
   {
      return type == item_arg;
   }
 
   const StringList& Items() const
   {
      return asItems;
   }
 
   StringList& Items()
   {
      return asItems;
   }
 
   bool IsLiteral() const
   {
      return type == literal_arg;
   }
 
   bool IsSwitch() const
   {
      return type == switch_arg;
   }
 
   bool SwitchState() const
   {
      return asSwitch;
   }
 
   bool IsNumeric() const
   {
      return type == numeric_arg;
   }
 
   double NumericValue() const
   {
      return asNumeric;
   }
 
   bool IsString() const
   {
      return type == string_arg;
   }
 
   String StringValue() const
   {
      return asString;
   }
 
private:
 
   enum arg_type { invalid_arg = -1, item_arg, literal_arg, switch_arg, numeric_arg, string_arg };
 
   String      token;      // argument token
   String      id;         // argument id
   arg_type    type;       // argument type, or invalid
 
   StringList  asItems;    // list of non-parameters (e.g. file names or view ids)
   bool        asSwitch;   // logical state of a switch argument
   double      asNumeric;  // value of a numerical argument
   String      asString;   // value of a string argument
 
   void Initialize()
   {
      token.Clear();
      id.Clear();
      type = invalid_arg;
      asItems.Clear();
      asSwitch = false;
      asNumeric = 0;
      asString.Clear();
   }
 
   void Parse( const char16_type* );
};
 
using ArgumentList = Array<Argument>;
 
// ----------------------------------------------------------------------------
 
namespace ArgumentItemMode
{
   enum value_type
   {
      Ignore,  // Consider non-parametric items as literal items (plain strings)
      AsFiles, // Non-parametric items are file paths
      AsViews, // Non-parametric items are view identifiers
      NoItems, // Non-parametric items are not allowed
   };
}
 
using argument_item_mode = ArgumentItemMode::value_type;
 
// ----------------------------------------------------------------------------
 
namespace ArgumentOption
{
   enum mask_type
   {
      AllowWildcards       = 0x00000001, // Allow wildcard characters (*?) in non-parametric items
      NoPreviews           = 0x00000002, // Don't allow preview specifications (with the '->' standard separator)
      RecursiveDirSearch   = 0x00000004, // Perform recursive directory searches for wild path specifications
      RecursiveSearchArgs  = 0x00000008, // Use standard arguments to toggle recursive directory searching
   };
}
 
using ArgumentOptions = Flags<ArgumentOption::mask_type>;
 
// ----------------------------------------------------------------------------
 
// The implementation of ExtractArguments() is slightly different in core.
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
} // pcl
using namespace pcl;
namespace pi
{
#endif
 
ArgumentList PCL_FUNC ExtractArguments( const StringList& argv,
                           argument_item_mode mode = ArgumentItemMode::Ignore,
                           ArgumentOptions options = ArgumentOptions() );
 
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
} // pi
namespace pcl
{
#endif
 
String PCL_FUNC RecursiveDirSearchArgument();
 
void PCL_FUNC SetRecursiveDirSearchArgument( const String& id );
 
StringList PCL_FUNC SearchDirectory( const String& filePath, bool recursive = false );
 
String PCL_FUNC ReplaceEnvironmentVariables( const String& s );
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif   // __PCL_Arguments_h
 
// ----------------------------------------------------------------------------
// EOF pcl/Arguments.h - Released 2024-06-18T15:48:54Z