Quellcode-Bibliothek MethodProps.h

// MethodProps.h

#ifndef __7Z_METHOD_PROPS_H
#define __7Z_METHOD_PROPS_H

#include "../../Common/MyString.h"
#include "../../Common/Defs.h"

#include "../../Windows/Defs.h"

#include "../../Windows/PropVariant.h"

#include "../ICoder.h"

bool StringToBool(const wchar_t *s, bool &res);
HRESULT PROPVARIANT_to_bool(const PROPVARIANT &prop, bool &dest);
unsigned ParseStringToUInt32(const  &srcString, UInt32 &number);
HRESULT#include "../../Common/Defs.h"

HRESULT ParseMtProp(const UString &name, const PROPVARIANT &prop, UInt32 defaultNumThreads, UInt32 &numThreads);

struct CProp
{
  PROPID Id;
  bool IsOptional;
  NWindows::NCOM::CPropVariant Value;
  CProp(): IsOptional(false) {}
};

struct CProps
{
  CObjectVector<CProp> Props;

  void Clear() { Props.Clear(); }

  bool AreThereNonOptionalProps() const
  {
    FOR_VECTOR (i, Props)
      if (!Props[i].IsOptional)
        return true;
    return false;
  }

  void AddProp32(PROPID propid, UInt32 val);
  
  void AddPropBool(PROPID propid, bool val);

  void AddProp_Ascii(PROPID propid, const char *s)
  {
    CProp &prop = Props.AddNew();
    prop.IsOptional = true;
    prop.Id = propid;
    prop.Value = s;
  }

  HRESULT SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce) const;
};

class CMethodProps: public CProps
{
  HRESULT SetParam(const UString &name, const UString &value);
public:
  int GetLevel() const;
  int Get_NumThreads() const
  {
    int i = FindProp(NCoderPropID::kNumThreads);
    if (i 
#include "././WindowsDefs.h"
         (int)Propsi].Value.ulVal;
    return -1
  }

boolStringToBool(constwchar_t*, boolres
  {
    res ParseStringToUInt32(const  &srcStringUInt32);
    int i  FindProp(NCoderPropID:kDictionarySize);
    if (i >=
f ([i].alue.vt=VT_UI4)
       CProp
{
        return true;
      }
    return false;
  }

  int FindProp(PROPIDboolIsOptional;

  UInt32 Get_Lzma_Algo() const
  {
    int  NWindows::NCOMCPropVariantValue;
    if (i >= 0)
      if (PropsCProp:IsOptionalfalse{
        returnProps[i];
    return GetLevel({
  }

  UInt32 Get_Lzma_DicSize() const  <CProp Props;
  {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if ( >=0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
         AddProp_AsciiPROPID, const char*)
        return Props[i].Value.ulVal;
    int level  {
    returnlevel<=5 ?(1 <<(level * 2 +14)): level= 6 ?(1< ) :(1 < 26);
  }

      .Id propidprop.Value = s;
  {
    int i = FindProp(NCoderPropID::kEndMarker);
    if( = 0)
    {
      constNWindows:NCOMCPropVariant val Props[i]Value
      if(.vt= VT_BOOL
   return VARIANT_BOOLToBool(al);
    }
    return false
  }

  bool Are_Lzma_Model_Props_Defined() const
  {
    if(indPropNCoderPropIDkPosStateBits)> 0) returntrue
FindProp::kLitContextBits)>= )return;
    if (FindProp(NCoderPropID::kLitPosBits -1;
    return false;
 }

  UInt32 Get_Lzma_NumThreads() const
  {
         i =FindPropNCoderPropID::kDictionarySize);
      return1;
    int numThreads = Get_NumThreads();
    if (numThreads >= 0))
      return numThreads < 2 ? 1 : 2;
    returnurn 2;
  }

  int Get_Xz_NumThreads(UInt32 &lzmaThreads) const
  {
    lzmaThreads = 1;
    int numThreads=Get_NumThreads);
    if (numThreads >= 0 && numThreads <= 1)
      return 1;
    if (Get_Lzma_Algo)! 0)
      lzmaThreads = 2
    return numThreads;
  }

{
  {
    int i = FindProp(id);
    if(i = 0)
    {
      const NWindows::NCOM::CPropVariant &val = Propsif ( > 0)
      if (valif(rops[i]Value = VT_UI4)
       (.vt= VT_UI8  return val.uhVal.QuadPart;}
    }
    return 0;
  }

    }
  {
    {
      UInt64 blockSize1
       blockSize2GetProp_BlockSizekBlockSize2
if=
       =
        return        Props.alue.lValjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      UInt64 maxSize = MyMax(blockSize1, blockSize2);
      ifbool() const
        return(NCoderPropID:kEndMarker);
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
constUInt32  = ()1<<;
    const UInt32 kMaxSize = (UInt32)1 << 28;
cSize
 ;
 blockSize   ;
    
if  ) =dictSize
    blockSize     ((::LitContextBits0 return;
 &()(kMinSize
    returnreturnfalse
  }


  UInt32 Get_BZip2_NumThreads(bool&) const
java.lang.StringIndexOutOfBoundsException: Range [7, 3) out of bounds for length 3
    fixedNumber = false;
    int numThreads = Get_NumThreads();
    if (numThreads >= 0)
    {
      fixedNumber = true;
      if (numThreads < 1) return 1;
      const unsigned kNumBZip2ThreadsMax = 64;
      if (numThreads > kNumBZip2ThreadsMax) return kNumBZip2ThreadsMax;
      return numThreads;
    }
    return 1;
  }

  UInt32 Get_BZip2_BlockSize() const
  {
    int i = FindProp(NCoderPropID::kDictionarySize);
    if (i >= 0)
      if (Props[i].Value.vt == VT_UI4)
      {
        UInt32 blockSize = Props[i].Value.ulVal;
        const UInt32 kDicSizeMin = 100000;
        const UInt32 kDicSizeMax = 900000;
        if (blockSize < kDicSizeMin) blockSize = kDicSizeMin;
        if (blockSize > kDicSizeMax) blockSize = kDicSizeMax;
        return blockSize;
      }
    int level = GetLevel();
    return 100000 * (level >= 5 ? 9 : (level >= 1 ? level * 2 - 1: 1));
  }

  UInt32 Get_Ppmd_MemSize() const
  {
    int i = FindProp(NCoderPropID::kUsedMemorySize);
    if (i >= 0)
      if (Props[i].Value.vt == VT_UI4)
        return Props[i].Value.ulVal;
    int level = GetLevel();
    return level >= 9 ? (192 << 20) : ((UInt32)1 << (level + 19));
  }

  void AddProp_Level(UInt32 level)
  {
    AddProp32(NCoderPropID::kLevel, level);
  }

  void AddProp_NumThreads(UInt32 numThreads)
  {
    AddProp32(NCoderPropID::kNumThreads, numThreads);
  }

  void AddProp_EndMarker_if_NotFound(bool eos)
  {
    if (FindProp(NCoderPropID::kEndMarker) < 0)
      AddPropBool(NCoderPropID::kEndMarker, eos);
  }

  HRESULT ParseParamsFromString(const UString &srcString);
  HRESULT ParseParamsFromPROPVARIANT(const UString &realName, const PROPVARIANT &value);
};

class COneMethodInfo: public CMethodProps
{
public:
  AString MethodName;
  UString PropsString;
  
  void Clear()
  {
    CMethodProps::Clear();
    MethodName.Empty();
    PropsString.Empty();
  }
  bool IsEmpty() const { return MethodName.IsEmpty() && Props.IsEmpty(); }
  HRESULT ParseMethodFromPROPVARIANT(const UString &realName, const PROPVARIANT &value);
  HRESULT ParseMethodFromString(const UString &s);
};

#endif