wxp.h

// Name:        wxp.h
// Purpose:     wxPackageXML, wxIfNodeListManager, wxPresetXMLDescriptor,
//              wxPackageRepositoryXMLDescriptor
// Author:      Francesco Montorsi
// Modified by:
// Created:     2006-06-29
// RCS-ID:      $Id: wxp.h,v 1.4 2007/01/31 13:27:46 frm Exp $
// Copyright:   (c) Francesco Montorsi
// Licence:     wxWidgets licence

#ifndef _WXP_H_
#define _WXP_H_

// Includes
#include <wx/xml/xml.h>
#include <wx/wfstream.h>
#include "wxp/package.h"


// the hashmap for storing OPTION presets
WX_DECLARE_STRING_HASH_MAP( wxPackageCommandOptionArray,
                            wxPackageCommandOptionArrayHashMap );

// the hashmap for storing COMMAND presets
WX_DECLARE_STRING_HASH_MAP( wxPackageCommandSet,
                            wxPackageCommandSetHashMap );


// ----------------------------------------------------------------------------
// wxPackageXML
// ----------------------------------------------------------------------------

class wxPackageXML : public wxXmlDocument
{
    DECLARE_DYNAMIC_CLASS(wxPackageXML)

public:

    // -1 for m_nIndentationStep means "no indentation"
    wxPackageXML() { m_nIndentationStep=-1; }
    virtual ~wxPackageXML() {}


public:     // indentation step (makes sense only in wxPackageXMLDescriptor currently!)

    int GetIndentationStep() const
        { return m_nIndentationStep; }
    void SetIndentationStep(int n)
        { m_nIndentationStep=n; }

public:         // load helpers

    void HandleUnknownTag(wxXmlNode *node);

    wxPackageCommandOptionArray LoadOptions(const wxXmlNode *n);

    wxPackageCommandOption LoadOption(const wxXmlNode *n);

    wxPackageCondition LoadCondition(const wxXmlNode *n);

    wxPackageCommand LoadCommand(const wxXmlNode *n);

    wxString GetStrippedNodeContent(const wxXmlNode *n) const;

public:         // save helpers

    wxXmlNode *AddChildIndentation(wxXmlNode *node, int level);

    wxXmlNode *AddSiblingIndentation(wxXmlNode *node, int level);

    wxXmlNode *InsertChildIndentation(wxXmlNode *node, wxXmlNode *before_node, int level);

    // NOTE: all the following functions create nodes which are then returned
    //       and not attached anywhere. They still take a "level" indentation 
    //       parameter because when creating nodes with subnodes, they need
    //       to indent the subnodes and thus need to know how many spaces to leave.

    wxXmlNode *SaveOption(const wxPackageCommandOption &opt, int level);

    wxXmlNode *SaveCommand(const wxPackageCommand &cmd, int level);

    wxXmlNode *SaveCondition(const wxPackageCondition &cond, int level);

protected:

    int m_nIndentationStep;
};



// ----------------------------------------------------------------------------
// wxIfNodeListManager
// ----------------------------------------------------------------------------

class wxIfNodeListManager
{
public:
    wxIfNodeListManager(wxPackageXML *xmldoc, wxXmlNode *parent)
        : m_parent(parent), m_doc(xmldoc) { m_previousif=NULL; }

    void SmartAppend(wxXmlNode *n, const wxPackageCondition &cnd, int level = 0);
    void SaveOptions(const wxPackageCommandOptionArray &arr, int level = 0);
    void SaveCommands(const wxPackageCommandArray &arr, int level = 0);


protected:      // not changed anymore after initialization

    // the parent of all nodes appended
    wxXmlNode *m_parent;

    // the instance of the class which owns m_parent
    wxPackageXML *m_doc;

protected:

    // the previous <if> node or NULL if previous node does not exist
    // or has a wxEmptyPackageCondition
    wxXmlNode *m_previousif;

    // the previous condition or wxEmptyPackageCondition if previous node
    // does not exist or has a wxEmptyPackageCondition
    wxPackageCondition m_previouscond;
};



// ----------------------------------------------------------------------------
// wxPresetXMLDescriptor
// ----------------------------------------------------------------------------

class wxPresetXMLDescriptor : public wxPackageXML
{
    DECLARE_DYNAMIC_CLASS(wxPresetXMLDescriptor)

public:
    wxPresetXMLDescriptor() {}
    virtual ~wxPresetXMLDescriptor() {}


public:         // static

    static wxPackageCommandOptionArrayHashMap s_hashmapOptions;

    static wxPackageCommandSetHashMap s_hashmapCommands;

    static wxArrayString GetCommandPresetNamesFor(wxPackageBuildSystemType type)
    {
        wxArrayString ret;
        wxPackageCommandSetHashMap::const_iterator it;
        for ( it = s_hashmapCommands.begin();
              it != s_hashmapCommands.end();
              it++ )
            if (it->second.GetBuildSystemType() == type)
                ret.Add(it->first);

        return ret;
    }

    static wxArrayString GetOptionPresetNamesFor(wxPackageBuildSystemType type)
    {
        wxArrayString ret;
        wxPackageCommandOptionArrayHashMap::const_iterator it;
        for ( it = s_hashmapOptions.begin();
              it != s_hashmapOptions.end();
              it++ )
            if (it->second.GetCommonCondition().IsValidForBuildSys(type))
                ret.Add(it->first);

        return ret;
    }


#ifdef __WXDEBUG__
    static void Dump();
#else
    static void Dump() {}
#endif

public:         // load & save

    bool Load(wxInputStream &stream);

    static bool Load(const wxString &filename);


    // NB: for these functions the "Save" name cannot be used as it is
    //     the name of a virtual function in the base class

    bool SavePresets(wxOutputStream &stream);

    static bool SavePresets(const wxString &filename);

public:         // load helpers

    wxPackageCommandSet LoadCommandSet(const wxXmlNode *n);
};


// ----------------------------------------------------------------------------
// wxPackageRepositoryXMLDescriptor
// ----------------------------------------------------------------------------

class wxPackageRepositoryXMLDescriptor : public wxPackageXML
{
    DECLARE_DYNAMIC_CLASS(wxPackageRepositoryXMLDescriptor)

public:
    wxPackageRepositoryXMLDescriptor() {}
    virtual ~wxPackageRepositoryXMLDescriptor() {}

    // loads the given gzipped WXL file:
    bool Load(const wxString &filename);

    // loads the WXL from the given input stream (which is supposed decompressed):
    bool Load(wxInputStream &stream)
        { return wxPackageXML::Load(stream); }

public:     // setters

    bool AddPackage(const wxString &pkgfile);

public:     // getters

    wxPackageArray GetPackageArray(const wxString &repourl);
};


#endif      // _WXP_H_

---