|

Template.hpp

Go to the documentation of this file.

#ifndef IONFLUX_TOOLS_TEMPLATE
#define IONFLUX_TOOLS_TEMPLATE
/* ==========================================================================
 * Ionflux Tools
 * Copyright (c) 2004 Joern P. Meier
 * mail@ionflux.org
 * --------------------------------------------------------------------------
 * Template.hpp                    Template processor.
 * ==========================================================================
 * 
 * This file is part of Ionflux Tools.
 * 
 * Ionflux Tools is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at  your option)
 * any later version.
 * 
 * Ionflux Tools is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Ionflux Tools; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * 
 * ========================================================================== */

#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <map>
#include "ionflux/tools.hpp"
#include "ionflux/Reporter.hpp"
#include "ionflux/Tree.hpp"
#include "ionflux/Tokenizer.hpp"
#include "ionflux/StringFilter.hpp"

namespace Ionflux
{

namespace Tools
{

struct TemplateVar
{
    DataEntry data;
    StringFilter *filter;
};

struct TemplateElement
{
    int type;
    std::vector<std::string> params;
    std::vector<TemplateVar> vars;
    std::vector<int> refs;
    static const int TE_INVALID;
    static const int TE_CDATA;
    static const int TE_VAR;
    static const int TE_FOREACH;
    static const int TE_FOREACH_ELSE;
    static const int TE_FOREACH_END;
    static const int TE_IF;
    static const int TE_IF_ELSE;
    static const int TE_IF_END;
    static const int TE_FIRST;
    static const int TE_FIRST_END;
    static const int TE_MID;
    static const int TE_MID_END;
    static const int TE_LAST;
    static const int TE_LAST_END;
    static const int TE_SINGLE;
    static const int TE_SINGLE_END;
    static const int TE_NOTLAST;
    static const int TE_NOTLAST_END;
    static const int TE_NOTFIRST;
    static const int TE_NOTFIRST_END;
    static const int TE_NOTMID;
    static const int TE_NOTMID_END;
    static const int TE_NOTSINGLE;
    static const int TE_NOTSINGLE_END;
    static const int TE_INCLUDE;
    static const int TE_SWRAP;
    static const int TE_SWRAP_END;
    static const int TE_SECTION;
    static const int TE_SECTION_END;
    static const int TE_REF;
};

struct TagNestingLevel
{
    unsigned int tagForeach;
    unsigned int tagIf;
    unsigned int tagFirst;
    unsigned int tagMid;
    unsigned int tagLast;
    unsigned int tagSingle;
    unsigned int tagNotFirst;
    unsigned int tagNotMid;
    unsigned int tagNotLast;
    unsigned int tagNotSingle;
    unsigned int tagSWrap;
    unsigned int tagSection;
    unsigned int tagRef;
    unsigned int all;
    
    TagNestingLevel();
};

struct TemplateSection
{
    unsigned int first;
    unsigned int last;
};

typedef std::map<std::string, TemplateSection> TemplateSectionMap;

class Template
: public Tree
{
    protected:
        Ionflux::Tools::Reporter log;
        std::string templateInput;
        Tokenizer tok;
        Tokenizer tagTok;
        std::vector<TemplateElement *> elements;
        TemplateSectionMap sections;
        unsigned int maxNestingDepth;
        
        virtual void clearElements();
        
        virtual bool parse(std::vector<TemplateElement *> &target);
        
        virtual bool parse();
        
        virtual void addCharacterData(const std::string &characterData,
            std::vector<TemplateElement *> &target);
        
        virtual bool addTemplateTag(const std::string &tagData, 
            std::vector<TemplateElement *> &target);
        
        virtual bool preprocess(std::vector<TemplateElement *> &target);
        
        virtual std::string process(unsigned int from, unsigned int to, 
            TagNestingLevel depth);
        
    public:
        static const std::string ITERATION_COUNTER;
        static const std::string NUM_ITERATIONS;
        static const std::string CONDITION_NODE;
        static const TokenType TT_TEMPLATE_TAG_OPEN;
        static const TokenType TT_TEMPLATE_TAG_CLOSE;
        static const TokenType TT_VAR_MARKER;
        static const TokenType TT_COMMENT;
        static const TokenType TT_TREEPATH;
        static const TokenType TT_END_TAG_MARKER;
        static const TokenType TT_OPERATOR_NSO;
        static const std::string TAG_FOREACH;
        static const std::string TAG_FOREACH_ELSE;
        static const std::string TAG_FOREACH_IN;
        static const std::string TAG_IF;
        static const std::string TAG_IF_ELSE;
        static const std::string TAG_FIRST;
        static const std::string TAG_MID;
        static const std::string TAG_LAST;
        static const std::string TAG_SINGLE;
        static const std::string TAG_NOTFIRST;
        static const std::string TAG_NOTMID;
        static const std::string TAG_NOTLAST;
        static const std::string TAG_NOTSINGLE;
        static const std::string TAG_INCLUDE;
        static const std::string TAG_SWRAP;
        static const std::string TAG_SECTION;
        static const std::string TAG_REF;
        static const std::string SWRAP_DEFAULT_LINE_WIDTH;
        static const std::string SWRAP_DEFAULT_LINE_TERM;
        static const unsigned int DEFAULT_MAX_NESTING_DEPTH;
        
        Template();
        
        virtual ~Template();
        
        virtual void readTemplate(const std::string& templateFileName, 
            std::vector<TemplateElement *> &target);
        
        virtual void readTemplate(const std::string& templateFileName);
        
        virtual void setTemplate(const std::string& newTemplate, 
            std::vector<TemplateElement *> &target);
        
        virtual void setTemplate(const std::string& newTemplate);
        
        virtual std::string process(const std::string& newTemplate = "",
            Node* newConfig = 0);
        
        virtual void setMaxNestingDepth(unsigned int newMaxNestingDepth);
        
        virtual unsigned int getMaxNestingDepth();
        
        virtual void printElementDebugInfo();
        
        virtual Reporter &getLog();

};


}

}

#endif

---