TextTemplate.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
    #include <windows.h>
#endif
 
#include <wctype.h>
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Array.h>
#include <dcl/HashMapT.h>
#include <dcl/ListT.h>
#include <dcl/Regex.h>
#include <dcl/SQL.h>
#include <dcl/Files.h>
#include <dcl/Writer.h>
 
#include <dcl/TextTemplate.h>
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/TextTemplate.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
struct TextNode
{
    String      name;   // isEmpty() 이면 일반블록이고, 그 내용은 values에 있다.
    StringList  values;   // assigned values
};
 
typedef List<TextNode> TextList;
typedef HashMap<String, TextTemplate> SubTemplateMap;
 
#define TEXT_LIST()     ((TextList*)__textList)
#define SUB_TEMPLATE_MAP()  ((SubTemplateMap*)__subTemplateMap)
 
IMPLEMENT_CLASSINFO(TextTemplate, Object)
 
TextTemplate::~TextTemplate()
{
    delete TEXT_LIST();
    delete SUB_TEMPLATE_MAP();
}
 
TextTemplate::TextTemplate()
{
#ifdef __DCL_DEBUG
    __showEmptyName = false;
#endif
    __textList = new TextList;
    __subTemplateMap = new SubTemplateMap;
}
 
TextTemplate::TextTemplate(const TextTemplate& _src)
{
#ifdef __DCL_DEBUG
    __showEmptyName = false;
#endif
    __textList = new TextList;
    __subTemplateMap = new SubTemplateMap;
 
    *this = _src;
}
 
TextTemplate::TextTemplate(const String& _text)
{
#ifdef __DCL_DEBUG
    __showEmptyName = false;
#endif
    __textList = new TextList;
    __subTemplateMap = new SubTemplateMap;
 
    parse(_text);
}
 
TextTemplate& TextTemplate::operator = (const TextTemplate& _src)
{
    if (this != &_src) {
#ifdef __DCL_DEBUG
        __showEmptyName = _src.__showEmptyName;
#endif
        clear();
 
        *(TEXT_LIST()) = *((TextList*)_src.__textList);
        SubTemplateMap& srcMap = *((SubTemplateMap*)_src.__subTemplateMap);
        SubTemplateMap::ConstIterator it = srcMap.begin();
        for (; it != srcMap.end(); it++) {
            (*(SUB_TEMPLATE_MAP()))[(*it).key] = (*it).value;
        }
    }
    return *this;
}
 
void TextTemplate::parse(const String& _text)
    __DCL_THROWS1(IOException*)
{
    parse(_text.data(), _text.data() + _text.length());
}
 
// _name ==> _text
void TextTemplate::parse(const String& _name, const String& _text)
{
    __DCL_ASSERT(!_name.isEmpty());
 
    // sub 템플릿에 같은 이름을 사용하는 템플릿이 있으면
    // 기존의 템플릿의 내용을 삭제한다.
#ifdef __DCL_DEBUG
    SubTemplateMap::Iterator itMap = SUB_TEMPLATE_MAP()->find(_name);
    if (itMap != SUB_TEMPLATE_MAP()->end()) {
        __DCL_TRACE1(L"Warning - exist %ls ==> replaced\n", _name.data());
    }
#endif
    SUB_TEMPLATE_MAP()->erase(_name);
    (*SUB_TEMPLATE_MAP())[_name].parse(_text);
}
 
void TextTemplate::clear()
{
    TEXT_LIST()->clear();
    SubTemplateMap::Iterator itMap = SUB_TEMPLATE_MAP()->begin();
    for( ; itMap != SUB_TEMPLATE_MAP()->end(); itMap++)
        (*itMap).value.clear();
 
    SUB_TEMPLATE_MAP()->clear();
}
 
void TextTemplate::reset()
{
    TextList::Iterator itList = TEXT_LIST()->begin();
    for( ; itList != TEXT_LIST()->end(); itList++) {
        if (!(*itList).name.isEmpty()) {
            // 매크로 이름이 비어 있지 않은
            // 즉, 매크로의 values만 삭제한다.
            // 매크로 이름이 비어 있는것은 일반 블록이다.
            (*itList).values.clear();
        }
    }
 
    // 서브 템플릿을 reset 한다.
    SubTemplateMap::Iterator itMap = SUB_TEMPLATE_MAP()->begin();
    for( ; itMap != SUB_TEMPLATE_MAP()->end(); itMap++)
        (*itMap).value.reset();
}
 
void TextTemplate::erase(const char_t* _name)
{
    if (_name != NULL) {
        TextList::Iterator it = TEXT_LIST()->begin();
        while(it != TEXT_LIST()->end()) {
            if ((*it).name == _name)
                it = TEXT_LIST()->erase(it);
            else
                it++;
        }
    }
    else {
        TextList::Iterator it = TEXT_LIST()->begin();
        while(it != TEXT_LIST()->end()) {
            if (!(*it).name.isEmpty())
                it = TEXT_LIST()->erase(it);
            else
                it++;
        }
    }
}
 
int TextTemplate::append(
    const char_t* _name, 
    const String& _value, bool _clearExists
)
{
    int nCount = 0;
    TextList::Iterator it = TEXT_LIST()->begin();
    if (_name != NULL) {
        for( ; it != TEXT_LIST()->end(); it++) {
            if ((*it).name == _name) {
                if (_clearExists && !(*it).values.isEmpty())
                    (*it).values.clear();
 
                (*it).values.addTail(_value);
                nCount++;
            }
        }
    }
    else {
        for(; it != TEXT_LIST()->end(); it++) {
            if (!(*it).name.isEmpty()) {
                if (_clearExists && !(*it).values.isEmpty())
                    (*it).values.clear();
 
                (*it).values.addTail(_value);
                nCount++;
            }
        }
    }
    return nCount;
}
 
int TextTemplate::append(
    const char_t* _name,
    const TextTemplate& _template, bool _clearExists
)
{
    __DCL_ASSERT(_name != NULL);
    __DCL_ASSERT(&_template != this);
 
    int nCount = 0;
 
    for(TextList::Iterator it = TEXT_LIST()->begin();
        it != TEXT_LIST()->end(); it++
    ) {
        if ((*it).name == _name) {
            if (_clearExists && !(*it).values.isEmpty())
                (*it).values.clear();
 
            for(TextList::ConstIterator itSrc =
                ((const TextList*)_template.__textList)->begin();
                itSrc != ((const TextList*)_template.__textList)->end(); itSrc++
            ) {
                if (!(*itSrc).values.isEmpty()) {
                    (*it).values.insert(
                        (*it).values.end(), 
                        (*itSrc).values.begin(), 
                        (*itSrc).values.end()
                    );
                }
#ifdef __DCL_DEBUG
                else {
                    __DCL_ASSERT(!((*itSrc).name.isEmpty()));
                    if (_template.__showEmptyName) {
                        String name = L'$' + (*itSrc).name;
                        (*it).values.addTail(name);
                    }
                }
#endif
            }
            nCount++;
        }
    }
    return nCount;
}
 
int TextTemplate::append(const StringStringArray& _nameToValues,
    bool _clearExists)
{
    int nCount = 0;
    for(size_t i = 0; i < _nameToValues.size(); i++)
        nCount += append(_nameToValues[i].key, _nameToValues[i].value, _clearExists);
    return nCount;
}
 
int TextTemplate::append(_CONST SQLFields& _fields,
    const String& _fieldIsNullValue, bool _clearExists)
{
    int nCount = 0;
    for(size_t i = 0; i < _fields.count(); i++) {
        _CONST SQLField& field = _fields[i];
        nCount += append(
            field.name(),
            onSQLFieldValue(field, _fieldIsNullValue),
            _clearExists
        );
    }
    return nCount;
}
 
String TextTemplate::onSQLFieldValue(_CONST SQLField& _field,
    const String& _fieldIsNullValue)
{
    if (_field.isNull() || _field.dataSize() == 0)
        return _fieldIsNullValue;
 
    return _field.asString();
}
 
#ifdef __DCL_DEBUG
void TextTemplate::showEmptyName(bool _show, bool _withSubTemplate)
{
    __showEmptyName = _show;
    if (_withSubTemplate) {
        SubTemplateMap::Iterator itMap = SUB_TEMPLATE_MAP()->begin();
        for( ; itMap != SUB_TEMPLATE_MAP()->end(); itMap++)
            (*itMap).value.showEmptyName(_show, _withSubTemplate);
    }
}
#endif
 
// 구성된 템플릿의 내용을 출력한다.
void TextTemplate::printTo(Writer& out) const
    __DCL_THROWS1(IOException*)
{
    for(TextList::Iterator itList = TEXT_LIST()->begin();
        itList != TEXT_LIST()->end(); itList++
    ) {
        if (!(*itList).values.isEmpty()) {
            StringList::Iterator itValues = (*itList).values.begin();
            for(; itValues != (*itList).values.end(); itValues++)
                out << *itValues;
        }
#ifdef __DCL_DEBUG
        else {
            __DCL_ASSERT(!(*itList).name.isEmpty());
            if (__showEmptyName) {
                // '$' 가 제거되어 있다 추가하여 출력한다.
                out << L"$" << (*itList).name;
            }
        }
#endif
    }
}
 
TextTemplate& TextTemplate::operator [] (const String& _name)
{
    return (*SUB_TEMPLATE_MAP())[_name];
}
 
TextTemplate* TextTemplate::atP(const String& _name) const
{
    SubTemplateMap::Iterator itMap = SUB_TEMPLATE_MAP()->find(_name);
    if (itMap != SUB_TEMPLATE_MAP()->end()) {
        return &((*itMap).value);
    }
    return NULL;
}
 
bool TextTemplate::exists(
    const String& _name,
    bool bSubTemplate // = true
) const
{
    if (bSubTemplate) {
        return ((const SubTemplateMap*)__subTemplateMap)->find(_name)
            != ((const SubTemplateMap*)__subTemplateMap)->end();
    }
    else {
        const TextList* pList = (const TextList*)__textList;
        TextList::ConstIterator itList = pList->begin();
        for (; itList != pList->end(); itList++) {
            if ((*itList).name == _name) {
                return true;
            }
        }
    }
    return false;
}
 
void TextTemplate::parseHelper(const char_t* _begin, const char_t* _end)
{
    try {
        Regex re(__T("\\$[a-zA-Z0-9_]+"));
        Regex::MatchResults results;
        while(_begin < _end && re.search(_begin, _end, results)) {
            if (results[0].matched && results[0].first < results[0].second) {
                // $NAME 이전에 텍스트가 있다.
                if (_begin < results[0].first) {
                    String text(_begin, results[0].first);
                    TextNode node;
                    node.values.addTail(text);
                    TEXT_LIST()->addTail(node);
                }
 
                // '$' 는 제외한다.
                String name(results[0].first + 1, results[0].second);
                TextNode node;
                node.name = name;
                TEXT_LIST()->addTail(node);
 
                _begin = results[0].second;
            }
        }
 
        if (_begin < _end) {
            // $NAME 이후에 텍스트가 있다.
            String text(_begin, _end);
            TextNode node;
            node.values.addTail(text);
            TEXT_LIST()->addTail(node);
        }
    }
    catch(RegexException* e) {
        __DCL_TRACE1(__T("%ls\n"), e->toString().data());
        e->destroy();
        __DCL_ASSERT(false);
    }
}
 
static String __getName(const char_t* _begin, const char_t* _end)
{
    const char_t* begin = _begin + 4; // "<!--
    while(begin < _end && *begin++ != __T('$'))
        ;
 
    const char_t* end = begin;
    while(end < _end && (iswalnum(*end) || *end == __T('_')))
        end++;
 
    String r(begin, end);
    return r;
}
 
void TextTemplate::parse(const char_t* _begin, const char_t* _end)
{
    try
    {
        Regex reBegin(
            __T("<!--[\t\v\f ]*\\$[a-zA-Z0-9_]+[\t\v\f ]*-->[\t\v\f \r\n]*")
        );
 
        Regex::MatchResults matchBegin;
        while (_begin < _end && reBegin.search(_begin, _end, matchBegin)) {
            __DCL_ASSERT(matchBegin.size() > 0 && matchBegin[0].matched);
 
            // sub 템플릿의 시작을 찾았다.
            String _name = __getName(matchBegin[0].first, matchBegin[0].second);
            String strEndPattern =
                 __T("<!--[\t\v\f ]*/[\t\v\f ]*\\$")
                  + _name
                  + __T("[\t\v\f ]*-->[\t\v\f \r\n]*");
 
            Regex reEnd(strEndPattern);
            Regex::MatchResults matchEnd;
//          __DCL_TRACE1(L"%lc\n", *(psz + matchBegin.rm_eo));
            if (reEnd.search(matchBegin[0].second, _end, matchEnd)) {
                // sub 블록 이전에 대하여 템플릿을 구성한다.
                if (_begin < matchBegin[0].first) {
                    parseHelper(_begin, matchBegin[0].first);
                }
 
                // _name 템플릿을 구성한다.
                // sub 템플릿에 같은 이름을 사용하는 템플릿이 있으면
                // 기존의 템플릿의 내용을 삭제한다.
#ifdef __DCL_DEBUG
                SubTemplateMap::Iterator itMap = SUB_TEMPLATE_MAP()->find(_name);
                if (itMap != SUB_TEMPLATE_MAP()->end()) {
                    __DCL_TRACE1(
                        __T("Warning - exists %ls ==> replaced\n"),
                        _name.data()
                    );
                }
#endif
                SUB_TEMPLATE_MAP()->erase(_name);
 
                TextNode node;
                node.name = _name;
                TEXT_LIST()->addTail(node);
 
                TextTemplate& sub = (*SUB_TEMPLATE_MAP())[_name];
//              __DCL_TRACE2("%ls: %d\n", _name.data(), matchEnd.rm_so);
                if (matchBegin[0].second < matchEnd[0].first) {
                    sub.parse(matchBegin[0].second, matchEnd[0].first);
                }
 
                _begin = matchEnd[0].second;
//              __DCL_TRACE1(L"%ls\n", psz);
            }
            else {
                _begin = matchBegin[0].second;
            }
        }
 
        if (_begin < _end) {
            // 남은 데이터가 있다
            parseHelper(_begin, _end);
        }
    }
    catch(RegexException* e) {
        __DCL_TRACE1(__T("%ls\n"), e->toString().data());
        e->destroy();
        __DCL_ASSERT(false);
    }
}
 
__DCL_END_NAMESPACE