packageopt.h

// Name:        packageopt.h
// Purpose:     wxPackageCommandOption, wxPackageCommandOptionArray
// Author:      Francesco Montorsi
// Modified by:
// Created:     2006-1-07
// RCS-ID:      $Id: packageopt.h,v 1.5 2007/01/28 15:56:11 frm Exp $
// Copyright:   (c) Julian Smart, Francesco Montorsi, Daniel J. Lauk
// Licence:     wxWidgets licence

#ifndef _PACKAGEOPT_H_
#define _PACKAGEOPT_H_

// Includes
#include "wx/tokenzr.h"
#include "wxp/wxputils.h"
#include "wxp/compiler.h"
#include "wxp/packageutils.h"

// Forward declarations
class wxPackageCommandOption;
class wxPackageCommandOptionArray;
class wxPackageCommandArray;
class wxPackageCondition;
class wxPackage;



// ----------------------------------------------------------------------------
// enums
// ----------------------------------------------------------------------------

enum wxPackageCommandOptionCategory
{
    wxPCOC_INVALID = -1,

    wxPCOC_LISTED_VALUES,       
    wxPCOC_DIRECTORY,           
    wxPCOC_FILE,                
    wxPCOC_STRING,              

    wxPCOC_MAX
};

extern wxPackageCommandOption wxEmptyPackageCommandOption;
extern wxPackageCommandOptionArray wxEmptyPackageCommandOptionArray;
extern wxPackageCommandArray wxEmptyPackageCommandArray;

wxDEFINE_STRING2ENUM(PackageCommandOptionCategory)



// ----------------------------------------------------------------------------
// wxPackageCommandOption
// ----------------------------------------------------------------------------




class wxPackageCommandOption: public wxObject
{
    DECLARE_DYNAMIC_CLASS(wxPackageCommandOption)

public:

    wxPackageCommandOption(
             const wxString &name = wxEmptyString,
             const wxString &allowedvalues = wxEmptyString,
             const wxString &value = wxEmptyString,
             const wxString &def = wxEmptyString,
             const wxString &valuesdesc = wxEmptyString,
             const wxString &desc = wxEmptyString,
             const wxString &grp = wxEmptyString,
             wxPackageCommandOptionCategory cat = wxPCOC_LISTED_VALUES,
             const wxPackageCondition &cnd = wxEmptyPackageCondition)
             : m_strName(name),
               m_strAllowedValues(allowedvalues),
               m_strDefValue(def), m_strValue(value), m_strDesc(desc),
               m_strGroup(grp), m_strValuesDesc(valuesdesc),
               m_nCat(cat), m_cond(cnd) {}

    wxPackageCommandOption(
             const wxString &name,
             bool value,
             bool def = true,
             const wxString &desc = wxEmptyString,
             const wxString &grp = wxEmptyString,
             const wxPackageCondition &cnd = wxEmptyPackageCondition)
             : m_strName(name),
               m_strAllowedValues(wxT("1,0")),
               m_strDefValue(def ? wxT("1") : wxT("0")),
               m_strValue(value ? wxT("1") : wxT("0")),
               m_strDesc(desc),
               m_strGroup(grp),
               m_nCat(wxPCOC_LISTED_VALUES), m_cond(cnd) {}

    virtual ~wxPackageCommandOption() {}

public:     // miscellaneous

    void AutodetectCategory();

    void ResetToDefault()
        { m_strValue = m_strDefValue; }

    bool operator==(const wxPackageCommandOption &opt) const;
    bool operator!=(const wxPackageCommandOption &opt) const
        { return !(*this == opt); }

public:     // getters

    wxString GetName() const
        { return m_strName; }
    wxString GetAllowedValues() const
        { return m_strAllowedValues; }
    wxString GetDefaultValue() const
        { return m_strDefValue; }
    wxString GetValue() const
        { return m_strValue; }
    wxString GetValueDesc() const
        { return m_strValuesDesc; }

    wxString GetDescription() const
        { return m_strDesc; }
    wxString GetGroup() const
        { return m_strGroup; }

    wxPackageCommandOptionCategory GetCategory() const
        { return m_nCat; }
    wxString GetCategoryStr() const
        { return wxPackageCommandOptionCategory2String(m_nCat); }

    bool GetBooleanValue() const
    {
        wxASSERT(IsBoolean());
        return GetValue() == wxT("1");
    }

public:     // wxArrayString-friendly getters

    wxArrayString GetAllowedValuesArray() const
        { return wxString2Array(m_strAllowedValues); }
    wxArrayString GetAllowedValuesDescArray() const
        { return wxString2Array(m_strValuesDesc); }
    size_t GetDefaultValueIndex() const
        { return GetAllowedValuesArray().Index(GetDefaultValue()); }
    size_t GetValueIndex() const
        { return GetAllowedValuesArray().Index(GetValue()); }

    const wxPackageCondition &GetCondition() const
        { return m_cond; }
    wxPackageCondition &GetCondition()
        { return m_cond; }

public:     // setters

    void SetValue(const wxString &value)
        { m_strValue=value; }
    void SetDefaultValue(const wxString &value)
        { m_strDefValue=value; }

    void SetCondition(const wxPackageCondition &c)
        { m_cond=c; }

public:     // checkers

    bool IsBoolean() const
        { return m_strAllowedValues == wxT("0,1") ||
                 m_strAllowedValues == wxT("1,0"); }

    bool IsOk() const;

    bool IsChanged() const
        { return m_strValue != m_strDefValue; }

protected:
    wxString m_strName, m_strAllowedValues, m_strDefValue, m_strValue;
    wxString m_strDesc, m_strGroup, m_strValuesDesc;

    wxPackageCommandOptionCategory m_nCat;

    wxPackageCondition m_cond;
};

// the array
WX_DECLARE_OBJARRAY(wxPackageCommandOption, wxPackageCommandOptionArrayHelper);




// ----------------------------------------------------------------------------
// wxPackageCommandOptionArray
// ----------------------------------------------------------------------------

class wxPackageCommandOptionArray : public wxPackageCommandOptionArrayHelper
{
public:

    wxPackageCommandOptionArray() { m_bDirty=false; }
    wxPackageCommandOptionArray(const wxPackageCommandOptionArray &arr)
        : wxPackageCommandOptionArrayHelper(arr), m_bDirty(arr.m_bDirty) {}

    wxPackageCommandOptionArray &operator=(const wxPackageCommandOptionArray &arr)
    {
        *((wxPackageCommandOptionArrayHelper*)this)=arr;
        m_bDirty=arr.m_bDirty;
        m_strDesc=arr.m_strDesc;
        return *this;
    }

public:     // miscellaneous

    // define & implement IsOk(), IndexByName(), ItemByName(), Contains()
    // and ContainsItemNamed() functions
    WX_DECLARE_STD_OBJARRAY_HELPERS(wxPackageCommandOption, 
                                    wxEmptyPackageCommandOption);

    int IndexByGroup(const wxString &grpname) const
    {
        for (size_t i=0; i<GetCount(); i++)
            if (Item(i).GetGroup() == grpname)
                return i;
        return wxNOT_FOUND;
    }

    bool Add(const wxPackageCommandOption &opt, size_t copies = 1)
    {
        if (IndexByName(opt.GetName()) == wxNOT_FOUND)
        {
            wxPackageCommandOptionArrayHelper::Add(opt, copies);
            return true;
        }

        wxLogWarning(wxT("Discarding duplicate option named '%s'"),
                     opt.GetName().c_str());
        return false;
    }

    void ResetToDefaults()
    {
        for (size_t i=0; i<GetCount(); i++)
            Item(i).ResetToDefault();
    }

    bool UpdateOption(const wxPackageCommandOption &opt);

    bool Contains(const wxPackageCommandOptionArray &arr) const;

    bool Remove(const wxPackageCommandOptionArray &arr);


public:     // getters

    wxPackageCommandOption &ItemByGroup(const wxString &grpname)
    {
        int n = IndexByGroup(grpname);
        if (n != wxNOT_FOUND)
            return wxPackageCommandOptionArrayHelper::Item(n);
        return wxEmptyPackageCommandOption;
    }

    wxArrayString GetAllOptionGroups() const;

    wxArrayString GetOptionGroups(long stages = wxGetFullPackageBuildSystemStageList()) const;

    wxPackageCommandOptionArray GetChangedOptions() const;

    wxString GetAsList() const;

    wxString GetDescription() const
        { return m_strDesc; }

    wxPackageCondition GetCommonCondition() const;

public:     // setters

    void SetDescription(const wxString &str)
        { m_strDesc=str; }

public:     // substitution helpers

    wxStringHashMap GetSubstitutionOptionsHashMap(long flags, 
                const wxPackageCondition &cond = wxEmptyPackageCondition) const;

    wxString SubstituteOptions(const wxString &str, long flags,
                               const wxPackageCondition &cond = wxEmptyPackageCondition) const
        { return wxDoStringSubstitution(str, 
                    GetSubstitutionOptionsHashMap(flags, cond)); }

public:     // dirty status

    void SetDirty(bool d = true)
        { m_bDirty = d; }
    bool IsDirty() const
        { return m_bDirty; }

protected:      // internal helpers

    wxStringHashMap GetGroupNamesHashMap(long flags, const wxPackageCondition &cond) const;
    wxStringHashMap GetTypeNamesHashMap(long flags, const wxPackageCondition &cond) const;

protected:
    // have options been changed?
    bool m_bDirty;

    // description of this array
    wxString m_strDesc;
};


#endif      // _PACKAGEOPT_H_

---