- 개요
- XML.h
- XML.cpp
1 개요
- boost 내부적으로 사용하는 tiny_xml 모듈을 참고해서 만든 최소한의 DOM 파서이다.
- 기본적인 괄호 체크와 노드 시작, 노드 끝의 이름이 서로 일치하는지 정도의 체크는 한다.
- 최소한의 파서이므로 DTD, XLS, 인코딩 등을 기대하지 말지어다.
- 허접하나마 바이너리 파일로의 입출력 기능도 들어있다. 파싱 속도 문제를 약간은 해결할 수 있을지도...
- 정통적(?)인 파서라기보다는, 뭔가 상당히 시행착오적으로 만들어진 파서라, 제대로 파싱 못 하는 구문이 다수 있을 수 있다. 일단 알고 있는 것은 주석 안에 주석을 넣을 경우, 제대로 처리되지 않는다는 것.
2 XML.h
//////////////////////////////////////////////////////////////////////////////
/// \file XML.h
/// \author excel96
/// \date 2004.9.20
//////////////////////////////////////////////////////////////////////////////
#pragma once
#include <string>
#include <map>
#include <vector>
#include <cassert>
//////////////////////////////////////////////////////////////////////////////
/// \class XMLTree
/// \brief 최소한의 기능만을 집어넣은 DOM 트리 클래스. 인코딩 따위(?)는
/// 지원하지 않으며, DTD, XLS 등은 어림도 없다.
//////////////////////////////////////////////////////////////////////////////
class XMLTree
{
public:
typedef std::map<std::string, std::string> ATTRIBUTES;
typedef std::vector<XMLTree*> CHILDREN;
// load, save 함수에서 사용할 파일의 종류
enum IOMode
{
IO_TEXT, ///< 텍스트 파일 입출력
IO_BINARY ///< 바이너리 파일 입출력
};
private:
class XMLUtil;
class XMLStream;
std::string m_Name; ///< 노드의 이름
std::string m_Text; ///< 노드에 속한 텍스트
XMLTree* m_pParent; ///< 부모 노드의 포인터
ATTRIBUTES m_Attributes; ///< 가지고 있는 속성값들
CHILDREN m_Children; ///< 자식 노드들
public:
/// \brief 생성자
/// \param name 노드의 이름
/// \param text 노드에 속한 텍스트
XMLTree(const std::string& name="", const std::string& text="");
/// \brief 소멸자
virtual ~XMLTree();
public:
/// \brief 노드의 이름을 반환한다.
/// \return const std::string& 노드의 이름
const std::string& getName() const { return m_Name; }
/// \brief 노드의 이름을 설정한다.
/// \param name 노드의 이름
void setName(const std::string& name) { m_Name = name; }
/// \brief 노드에 할당된 텍스트를 반환한다.
/// \return const std::string& 노드에 할당된 텍스트
const std::string& getText() const { return m_Text; }
/// \brief 노드에 할당할 텍스트를 설정한다.
/// \param text 노드에 할당할 텍스트
void setText(const std::string& text) { m_Text = text; }
/// \brief 부모 노드를 반환한다.
/// \return XMLTree* 부모 노드의 포인터
XMLTree* getParent() const { return m_pParent; }
/// \brief 부모 노드를 설정한다.
/// \param pParent 부모 노드 객체
void setParent(XMLTree* pParent) { m_pParent = pParent; }
public:
/// \brief 노드에 속성을 추가한다.
/// \param name 속성 이름
/// \param value 속성 값
void setAttr(const std::string& name, int value) {
char buf[256] = {0,};
_snprintf(buf, sizeof(buf)-1, "%d", value);
buf[sizeof(buf)-1] = 0;
setAttr(name, std::string(buf));
}
void setAttr(const std::string& name, unsigned int value) {
char buf[256] = {0,};
_snprintf(buf, sizeof(buf)-1, "%d", value);
buf[sizeof(buf)-1] = 0;
setAttr(name, std::string(buf));
}
/// \brief 노드에 속성을 추가한다.
/// \param name 속성 이름
/// \param value 속성 값
void setAttr(const std::string& name, double value) {
char buf[256] = {0,};
_snprintf(buf, sizeof(buf)-1, "%f", value);
buf[sizeof(buf)-1] = 0;
setAttr(name, std::string(buf));
}
/// \brief 노드에 속성을 추가한다.
/// \param name 속성 이름
/// \param value 속성 값
void setAttr(const std::string& name, float value) {
char buf[256] = {0,};
_snprintf(buf, sizeof(buf)-1, "%f", value);
buf[sizeof(buf)-1] = 0;
setAttr(name, std::string(buf));
}
/// \brief 노드에 속성을 추가한다.
/// \param name 속성 이름
/// \param value 속성 값
void setAttr(const std::string& name, bool value) {
setAttr(name, value ? std::string("true") : std::string("false"));
}
/// \brief 노드에 속성을 추가한다.
/// \param name 속성 이름
/// \param value 속성 값
void setAttr(const std::string& name, const char* value) {
assert(!name.empty());
m_Attributes[name] = value;
}
/// \brief 노드에 속성을 추가한다.
/// \param name 속성 이름
/// \param value 속성 값
void setAttr(const std::string& name, const std::string& value) {
assert(!name.empty());
m_Attributes[name] = value;
}
public:
/// \brief 해당하는 이름의 속성의 존재 유뮤를 리턴한다.
/// \param name 속성 이름
/// \return bool 속성 값이 존재하는 경우 true, 존재하지 않는다면 false
bool attrExist(const std::string& name) const {
return m_Attributes.find(name) != m_Attributes.end();
}
/// \brief 해당 속성의 값을 문자열 형태로 반환한다.
/// \param name 속성 이름
/// \return std::string 속성 값
std::string attrAsString(const std::string& name) const;
/// \brief 해당 속성의 값을 정수 형태로 반환한다.
/// \param name 속성 이름
/// \return int 속성 값
int attrAsInt(const std::string& name) const {
return atoi(attrAsString(name).c_str());
}
/// \brief 해당 속성의 값을 실수 형태로 반환한다.
/// \param name 속성 이름
/// \return double 속성 값
double attrAsDouble(const std::string& name) const {
return atof(attrAsString(name).c_str());
}
/// \brief 해당 속성의 값을 실수 형태로 반환한다.
/// \param name 속성 이름
/// \return float 속성 값
float attrAsFloat(const std::string& name) const {
return static_cast<float>(atof(attrAsString(name).c_str()));
}
/// \brief 해당 속성의 값을 불린 형태로 반환한다.
/// \param name 속성 이름
/// \return bool 속성 값
bool attrAsBool(const std::string& name) const {
return attrAsString(name) == "true";
}
/// \brief 해당 속성의 값을 문자열 형태로 반환한다.
/// \param name 속성 이름
/// \param default_value 해당 속성이 존재하지 않는 경우 반환할 값
/// \return std::string 속성 값
std::string attrAsStringSafe(const std::string& name, const std::string& default_value="") const;
/// \brief 해당 속성의 값을 정수 형태로 반환한다.
/// \param name 속성 이름
/// \param default_value 해당 속성이 존재하지 않는 경우 반환할 값
/// \return int 속성 값
int attrAsIntSafe(const std::string& name, int default_value=0) const;
/// \brief 해당 속성의 값을 실수 형태로 반환한다.
/// \param name 속성 이름
/// \param default_value 해당 속성이 존재하지 않는 경우 반환할 값
/// \return double 속성 값
double attrAsDoubleSafe(const std::string& name, double default_value=0.0) const;
/// \brief 해당 속성의 값을 실수 형태로 반환한다.
/// \param name 속성 이름
/// \param default_value 해당 속성이 존재하지 않는 경우 반환할 값
/// \return float 속성 값
float attrAsFloatSafe(const std::string& name, float default_value=0.0) const;
/// \brief 해당 속성의 값을 불린 형태로 반환한다.
/// \param name 속성 이름
/// \param default_value 해당 속성이 존재하지 않는 경우 반환할 값
/// \return bool 속성 값
bool attrAsBoolSafe(const std::string& name, bool default_value=false) const;
/// \brief 속성 컬렉션을 반환한다.
/// \return const ATTRIBUTES& 속성 컬렉션
const ATTRIBUTES& getAttributes() const { return m_Attributes; }
public:
/// \brief 자식 노드를 추가한다.
/// \param pTree 자식 노드 객체
void addChild(XMLTree* pTree)
{
m_Children.push_back(pTree);
pTree->setParent(this);
}
/// \brief 자식 노드를 추가한다.
/// \param name 자식 노드의 이름
/// \param text 노드에 속한 텍스트
/// \return XMLTree* 새로 생성한 자식 노드 객체
XMLTree* addChild(const std::string& name, const std::string& text="")
{
XMLTree* pChild = new XMLTree(name, text);
pChild->setParent(this);
m_Children.push_back(pChild);
return pChild;
}
/// \brief 자식 노드의 숫자를 반환.
/// \return size_t 자식 노드의 갯수
size_t getChildCount() const { return m_Children.size(); }
/// \brief 해당하는 인덱스의 자식 노드를 반환.
/// \param index 자식 노드 인덱스
/// \return XMLTree* 자식 노드 객체. 인덱스가 범위를 넘어가는 경우에는
/// NULL을 반환한다.
XMLTree* getChild(size_t index) const {
return index < m_Children.size() ? m_Children[index] : NULL;
}
/// \brief 자식 노드 중에 해당하는 이름을 가진 제일 첫번째 노드를 반환.
/// \param name 자식 노드의 이름
/// \return XMLTree* 같은 이름을 가지는 자식 노드들 중에서 첫번째로
/// 나타나는 노드. 해당하는 이름을 가지는 자식 노드가 존재하지 않는
/// 경우에는 NULL을 반환한다.
XMLTree* getChild(const std::string& name) const
{
for (size_t i=0; i<m_Children.size(); i++)
if (m_Children[i]->getName() == name) return m_Children[i];
return NULL;
}
/// \brief 해당하는 인덱스의 노드를 삭제한다.
/// \param index 삭제할 자식 노드의 인덱스
/// \return XMLTree* 컨테이너에서 삭제한 후, 해당하는 노드를 반환한다.
/// 인덱스가 잘못된 경우에는 NULL을 반환한다.
XMLTree* removeChild(size_t index)
{
if (index >= m_Children.size()) return NULL;
XMLTree* pChild = m_Children[index];
m_Children.erase(m_Children.begin() + index);
return pChild;
}
/// \brief 모든 자식 노드들과 속성값을 삭제한다.
void clear()
{
m_Attributes.clear();
for (size_t i=0; i<m_Children.size(); i++) { delete m_Children[i]; }
m_Children.clear();
}
public:
/// \brief XML 파일에서 데이터를 읽어들여 데이터를 구성한다.
/// \param filename 읽어들일 파일의 이름
/// \param mode 입출력 모드
/// \return bool 파일을 성공적으로 읽어들인 경우에는 false, 뭔가 에러가
/// 생긴 경우에는 true를 반환한다.
bool load(const char* filename, IOMode mode=IO_TEXT);
/// \brief 자신과 자식 노드에 관한 정보를 파일에다 저장한다.
/// \param filename 쓸 파일의 이름
/// \param encoding XML 파일 앞부분에다 붙일 인코딩 문자열
/// \param mode 입출력 모드
/// \return bool 파일을 성공적으로 쓴 경우에는 false, 뭔가 에러가 생긴
/// 경우에는 false를 반환한다.
bool save(const char* filename, IOMode mode=IO_TEXT, const char* encoding="euc-kr");
private:
/// \brief 내부적으로 사용하는 재귀 호출용 파싱 함수
/// \param file XML 데이터가 들어있는 스트림 객체
/// \param msg 파싱 중 에러가 발생했을 때 출력할 메시지 헤더
void loadText(XMLStream& file, const std::string& msg);
/// \brief 내부적으로 사용하는 재귀 호출용 저장 함수
/// \param file 파일 스트림
/// \param indent 들여쓰기 레벨
void saveText(std::ofstream& file, size_t indent);
/// \brief 내부적으로 사용하는 재귀 호출용 파싱 함수
/// \param file XML 데이터가 들어있는 스트림 객체
/// \param msg 파싱 중 에러가 발생했을 때 출력할 메시지 헤더
void loadBinary(std::ifstream& file, const std::string& msg);
/// \brief 내부적으로 사용하는 재귀 호출용 저장 함수
/// \param file 파일 스트림
void saveBinary(std::ofstream& file);
};
3 XML.cpp
//////////////////////////////////////////////////////////////////////////////
/// \file XML.cpp
/// \author excel96
/// \date 2004.9.20
//////////////////////////////////////////////////////////////////////////////
#include "XMLTree.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <time.h>
#include <fstream>
//////////////////////////////////////////////////////////////////////////////
// 상수 선언
//////////////////////////////////////////////////////////////////////////////
static const char* XML_ERROR_FILENAME = "__XMLError.log";
static const std::string XML_OPERATORS = " \t\r\n\"\'<>!=/?!";
static const std::string XML_WHITESPACES = " \t\r\n";
static const std::string XML_LINEFEEDS = "\r\n";
static const std::string XML_ATTR_TOKENS = "\"\'";
static const char XML_LEFT_BRACKET = '<';
static const char XML_RIGHT_BRACKET = '>';
static const char XML_BANG = '!';
static const char XML_HYPHEN = '-';
static const char XML_EQUAL = '=';
static const char XML_DIVIDE = '/';
static const unsigned short XML_STRING_LENGTH_MAX = 1024;
//////////////////////////////////////////////////////////////////////////////
/// \class XMLUtil
/// \brief 유틸리티 함수들
//////////////////////////////////////////////////////////////////////////////
class XMLTree::XMLUtil
{
public:
/// \brief 해당 캐릭터가 공백 문자인지의 여부를 반환한다.
/// \param c 검사할 캐릭터
/// \return bool 공백 문자인 경우 true, 아니라면 flase
static bool isWhitespace(char c) {
return XML_WHITESPACES.find_first_of(c) != std::string::npos;
}
/// \brief 해당 캐릭터가 라인피드 문자인지의 여부를 반환한다.
/// \param c 검사할 캐릭터
/// \return bool 공백 문자인 경우 true, 아니라면 false
static bool isLinefeed(char c) {
return XML_LINEFEEDS.find_first_of(c) != std::string::npos;
}
/// \brief sprintf 함수와 같은 방식으로 문자열을 생성해서 반환한다.
/// \param fmt 포맷
/// \param ... 가변 인수
/// \return std::string 문자열
static std::string sprintf(const char* fmt, ...)
{
assertPtr(fmt);
std::string formatted;
va_list args;
va_start(args, fmt);
formatted = XMLUtil::vsprintf(fmt, args);
va_end(args);
return formatted;
}
/// \brief sprintf 함수와 같은 방식으로 문자열을 생성해서 반환한다.
/// \param fmt 포맷
/// \param args 인자
/// \return std::string 생성한 문자열
static std::string vsprintf(const char* fmt, va_list args)
{
assertPtr(fmt);
std::string formatted;
// 일단 기본 스택 버퍼를 가지고 문자열 만들기를 시도한다.
char stack_buf[512] = {0,};
int nchars = _vsnprintf(stack_buf, sizeof(stack_buf)-1, fmt, args);
if (0 < nchars || nchars < sizeof(stack_buf))
{
// 기본 스택 버퍼로 문자열 만들기에 성공했다. 파일에다 로그한다.
stack_buf[sizeof(stack_buf)-1] = 0;
formatted = stack_buf;
}
else
{
// 기본 스택 버퍼로는 크기가 모자랐다. realloc 함수를 이용해
// 힙 버퍼의 크기를 늘려가며, 문자열 만들기를 시도한다.
int buflen = sizeof(stack_buf);
char* heap_buf = NULL;
do {
buflen = buflen * 2;
heap_buf = reinterpret_cast<char*>(::realloc(heap_buf, buflen));
memset(heap_buf, 0, buflen);
nchars = _vsnprintf(heap_buf, buflen, fmt, args);
} while (nchars < 0 || nchars >= buflen);
heap_buf[buflen-1] = 0;
formatted = heap_buf;
::free(heap_buf);
}
return formatted;
}
/// \brief 파일에다 에러를 로그한다.
/// \param fmt 포맷
/// \param ... 가변 인수
static void filelog(const char* fmt, ...)
{
assertPtr(fmt);
std::ofstream file(XML_ERROR_FILENAME, std::ios::out | std::ios::app);
if (file.is_open())
{
va_list args;
va_start(args, fmt);
file << XMLUtil::vsprintf(fmt, args) << std::endl;
va_end(args);
}
}
/// \brief 파일에서 문자열을 읽어들여 반환한다.
/// \param file 문자열을 읽어들일 파일 객체
/// \return std::string 읽어들인 문자열
static std::string readWORDString(std::ifstream& file)
{
assert(file.good());
unsigned short length = 0;
file.read(reinterpret_cast<char*>(&length), sizeof(length));
assert(length < XML_STRING_LENGTH_MAX);
if (length > 0)
{
char buf[XML_STRING_LENGTH_MAX] = {0,};
file.read(buf, length);
return buf;
}
return "";
}
/// \brief 파일에다 문자열의 길이를 2바이트로 기록하고, 그 다음 문자열
/// 내용을 기록한다.
/// \param file 기록할 파일 객체
/// \param text 기록할 텍스트
static void writeWORDString(std::ofstream& file, const std::string& text)
{
assert(file.good());
unsigned short length = static_cast<unsigned short>(text.size());
file.write(reinterpret_cast<const char*>(&length), sizeof(length));
if (length > 0)
file.write(text.c_str(), length);
}
};
//////////////////////////////////////////////////////////////////////////////
/// \class XMLTree::XMLStream
/// \brief 스트림 객체
//////////////////////////////////////////////////////////////////////////////
class XMLTree::XMLStream
{
private:
std::istream& m_stream; ///< 스트림 객체 참조
int m_line; ///< 현재 라인
int m_column; ///< 현재 컬럼
char m_prev; ///< 마지막으로 읽어들인 글자
public:
/// \brief 생성자
/// \param stream 원본 스트림 객체
XMLStream(std::istream& stream)
: m_stream(stream), m_line(1), m_column(1), m_prev(0) {}
/// \brief 소멸자
~XMLStream() {}
public:
/// \brief 스트림에서 캐릭터 하나를 뽑아낸다.
/// \return char 스트림에서 뽑아낸 캐릭터. 스트림에서 더 이상의 캐릭터를
/// 뽑아낼 수 없는 경우, 예외를 던진다.
char get()
{
char c = 0;
if (!m_stream.get(c))
{
throw XMLUtil::sprintf(
"unexpected eof at %d line %d column", m_line, m_column);
}
if (XMLUtil::isLinefeed(c) && !XMLUtil::isLinefeed(m_prev))
{
m_line++;
m_column = 0;
}
m_prev = c;
m_column++;
return c;
}
/// \brief 스트림에서 캐릭터 하나를 뽑아낸다.
/// \return char 스트림에서 뽑아낸 캐릭터. 스트림에서 더 이상의
/// 캐릭터를 뽑아낼 수 없는 경우에는 0을 반환한다.
char getRaw()
{
char c = 0;
if (!m_stream.get(c)) return 0;
if (XMLUtil::isLinefeed(c) && !XMLUtil::isLinefeed(m_prev))
{
m_line++;
m_column = 0;
}
m_prev = c;
m_column++;
return c;
}
/// \brief 다음에 읽어들일 캐릭터를 검사한다.
/// \return char 스트림에 들어있는 캐릭터.
char peek() const { return (char)m_stream.peek(); }
/// \brief 현재 처리 중인 라인 번호를 반환한다.
/// \return int 현재 처리 중인 라인 번호
int getCurrentLine() const { return m_line; }
/// \brief 현재 처리 중인 컬럼 번호를 반환한다.
/// \return int 현재 처리중인 컬럼 번호
int getCurrentColumn() const { return m_column; }
public:
/// \brief 스트림에서 공백 문자 및 주석을 건너뛴다.
/// \param c 공백 문자를 다 건너뛴 다음에 나오는 글자.
void eatWhitespace(char& c)
{
do
{
while (XMLUtil::isWhitespace(c))
c = get();
if (c == XML_LEFT_BRACKET && peek() == XML_BANG)
{
c = get();
do {
c = get();
} while(!(c == XML_HYPHEN && peek() == XML_RIGHT_BRACKET));
// eat last '>' and next char
c = get();
c = get();
}
while (XMLUtil::isWhitespace(c))
c = get();
} while (c == '<' && peek() == XML_BANG);
}
/// \brief 스트림에서 공백 문자들을 건너뛴 후, 나오는 글자가 주어진
/// 구분자인지를 검사하고 건너뛴다.
/// \param c 공백 문자를 다 건너뛴 다음에 나오는 글자.
/// \param delim 나와야하는 문자
/// \param msg 에러가 발생했을 때 출력할 메시지 헤더
void eatDelim(char& c, const char delim, const std::string& msg)
{
eatWhitespace(c);
if (c != delim)
{
throw XMLUtil::sprintf(
"%s: syntax error at %d line %d column, expect '%c' but '%c'",
msg.c_str(), m_line, m_column, delim, c);
}
c = getRaw();
}
/// \brief 스트림에서 공백 문자들을 건너뛴 후, 나오는 글자가 속성값의
/// 시작 문자(' 또는 ")인지를 검사하고 건너뛴다.
/// 구분자인지를 검사하고
/// \param c 공백 문자를 다 건너뛴 다음에 나오는 글자.
/// \param msg 에러가 발생했을 때 출력할 메시지 헤더
void eatAttributeDelim(char& c, const std::string& msg)
{
eatWhitespace(c);
if (XML_ATTR_TOKENS.find_first_of(c) == std::string::npos)
{
throw XMLUtil::sprintf(
"%s: syntax error at %d line %d column, expect '%s' but '%c'",
msg.c_str(), m_line, m_column, XML_ATTR_TOKENS.c_str(), c);
}
c = getRaw();
}
/// \brief 스트림에서 XML 헤더를 건너뛴다.
void eatHeader()
{
char c = 0;
do
{
c = get();
} while (c != XML_RIGHT_BRACKET);
c = get();
eatWhitespace(c);
}
/// \brief 스트림에서 속성 이름 문자열을 읽어내어 반환한다.
///
/// <sample name="somevalue">...
/// ^^^^^^ ^^^^
///
/// \param c 이름 문자열 끝에 나오는 글자
/// \return std::string 이름 문자열
std::string extractName(char& c)
{
std::string result;
eatWhitespace(c);
while (XML_OPERATORS.find_first_of(c) == std::string::npos)
{
result += c;
c = get();
}
return result;
}
/// \brief 스트림에서 속성 값 문자열을 읽어내어 반환한다.
///
/// <sample name="somevalue">...
/// ^^^^^^^^^
///
/// \param c 값 문자열 끝에 나오는 글자
/// \return std::string 값 문자열
std::string extractValue(char& c)
{
std::string result;
while (XML_ATTR_TOKENS.find_first_of(c) == std::string::npos)
{
result += c;
c = get();
}
c = get();
return result;
}
private:
// 복사 및 대입 연산 방지
XMLStream(const XMLStream& other) : m_stream(other.m_stream) {}
const XMLStream& operator = (const XMLStream&) { return *this; }
};
//////////////////////////////////////////////////////////////////////////////
/// \brief 생성자
/// \param name 노드의 이름
/// \param text 노드에 속한 텍스트
//////////////////////////////////////////////////////////////////////////////
XMLTree::XMLTree(const std::string& name, const std::string& text)
: m_Name(name), m_Text(text), m_pParent(NULL)
{
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 소멸자
//////////////////////////////////////////////////////////////////////////////
XMLTree::~XMLTree()
{
clear();
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 해당 속성의 값을 문자열 형태로 반환한다.
/// \param name 속성 이름
/// \return std::string 속성 값
//////////////////////////////////////////////////////////////////////////////
std::string XMLTree::attrAsString(const std::string& name) const
{
assert(!name.empty());
ATTRIBUTES::const_iterator itr = m_Attributes.find(name);
if (itr == m_Attributes.end())
{
XMLUtil::filelog("specified attr '%s' does not exist in node '%s'",
name.c_str(), m_Name.c_str());
assert(false && "specified attr does not exist");
return "";
}
return itr->second;
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 해당 속성의 값을 문자열 형태로 반환한다.
/// \param name 속성 이름
/// \return std::string 속성 값
//////////////////////////////////////////////////////////////////////////////
std::string XMLTree::attrAsStringSafe(const std::string& name,
const std::string& default_value) const
{
assert(!name.empty());
ATTRIBUTES::const_iterator itr = m_Attributes.find(name);
return itr != m_Attributes.end() ? itr->second : default_value;
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 해당 속성의 값을 정수 형태로 반환한다.
/// \param name 속성 이름
/// \param default_value 해당 속성이 존재하지 않는 경우 반환할 값
/// \return int 속성 값
//////////////////////////////////////////////////////////////////////////////
int XMLTree::attrAsIntSafe(const std::string& name, int default_value) const
{
assert(!name.empty());
ATTRIBUTES::const_iterator itr = m_Attributes.find(name);
return itr != m_Attributes.end() ?
atoi(itr->second.c_str()) : default_value;
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 해당 속성의 값을 실수 형태로 반환한다.
/// \param name 속성 이름
/// \param default_value 해당 속성이 존재하지 않는 경우 반환할 값
/// \return double 속성 값
//////////////////////////////////////////////////////////////////////////////
double XMLTree::attrAsDoubleSafe(const std::string& name,
double default_value) const
{
assert(!name.empty());
ATTRIBUTES::const_iterator itr = m_Attributes.find(name);
return itr != m_Attributes.end() ?
atof(itr->second.c_str()) : default_value;
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 해당 속성의 값을 실수 형태로 반환한다.
/// \param name 속성 이름
/// \param default_value 해당 속성이 존재하지 않는 경우 반환할 값
/// \return float 속성 값
//////////////////////////////////////////////////////////////////////////////
float XMLTree::attrAsFloatSafe(const std::string& name,
float default_value) const
{
assert(!name.empty());
ATTRIBUTES::const_iterator itr = m_Attributes.find(name);
return itr != m_Attributes.end() ?
static_cast<float>(atof(itr->second.c_str())) : default_value;
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 해당 속성의 값을 불린 형태로 반환한다.
/// \param name 속성 이름
/// \param default_value 해당 속성이 존재하지 않는 경우 반환할 값
/// \return bool 속성 값
//////////////////////////////////////////////////////////////////////////////
bool XMLTree::attrAsBoolSafe(const std::string& name,
bool default_value) const
{
assert(!name.empty());
ATTRIBUTES::const_iterator itr = m_Attributes.find(name);
return itr != m_Attributes.end() ? itr->second == "true" : default_value;
}
//////////////////////////////////////////////////////////////////////////////
/// \brief XML 파일에서 데이터를 읽어들여 데이터를 구성한다.
/// \param filename 읽어들일 파일의 이름
/// \param mode 입출력 모드
/// \return bool 파일을 성공적으로 읽어들인 경우에는 false, 뭔가 에러가
/// 생긴 경우에는 true를 반환한다.
//////////////////////////////////////////////////////////////////////////////
bool XMLTree::load(const char* filename, IOMode mode)
{
if (mode == IO_TEXT)
{
std::ifstream file(filename, std::ios::in);
if (!file)
{
XMLUtil::filelog(
"cannot open specified file for read - %s", filename);
return true;
}
bool rvalue = false;
XMLStream stream(file);
stream.eatHeader();
try
{
loadText(stream, filename);
}
catch (std::string& e)
{
XMLUtil::filelog("%s", e.c_str());
assert(false && "xml parsing error");
rvalue = true;
}
return rvalue;
}
else if (mode == IO_BINARY)
{
std::ifstream file(filename, std::ios::in | std::ios::binary);
if (!file)
{
XMLUtil::filelog(
"cannot open specified file for read - %s", filename);
return true;
}
XMLUtil::readWORDString(file); // 헤더를 읽어들인다.
loadBinary(file, filename);
return false;
}
return true;
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 자신과 자식 노드에 관한 정보를 파일에다 저장한다.
/// \param filename 쓸 파일의 이름
/// \param encoding XML 파일 앞부분에다 붙일 인코딩 문자열
/// \param mode 입출력 모드
/// \return bool 파일을 성공적으로 쓴 경우에는 false, 뭔가 에러가 생긴
/// 경우에는 false를 반환한다.
//////////////////////////////////////////////////////////////////////////////
bool XMLTree::save(const char* filename, IOMode mode, const char* encoding)
{
if (mode == IO_TEXT)
{
std::ofstream file(filename, std::ios::out | std::ios::trunc);
if (!file)
{
XMLUtil::filelog(
"cannot open specified file for write - %s", filename);
return true;
}
file << XMLUtil::sprintf(
"<?xml version=\"1.0\" encoding=\"%s\"?>", encoding) << std::endl;
saveText(file, 0);
return false;
}
else if (mode == IO_BINARY)
{
std::ofstream file(filename, std::ios::out | std::ios::binary | std::ios::trunc);
if (!file)
{
XMLUtil::filelog(
"cannot open specified file for write - %s", filename);
return true;
}
XMLUtil::writeWORDString( file, XMLUtil::sprintf(
"<?xml version=\"1.0\" encoding=\"%s\"?>", encoding) );
saveBinary(file);
return false;
}
return true;
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 내부적으로 사용하는 재귀 호출용 파싱 함수
/// \param file XML 데이터가 들어있는 스트림 객체
/// \param msg 파싱 중 에러가 발생했을 때 출력할 메시지 헤더
//////////////////////////////////////////////////////////////////////////////
void XMLTree::loadText(XMLStream& file, const std::string& msg)
{
char c = file.get();
if (c == XML_LEFT_BRACKET)
{
c = file.get();
}
setName(file.extractName(c));
file.eatWhitespace(c);
// attributes
while (c != XML_RIGHT_BRACKET)
{
if (c == XML_DIVIDE && file.peek() == XML_RIGHT_BRACKET)
{
c = file.get(); // next XML_RIGHT_BRACKET
return;
}
std::string attrname = file.extractName(c);
file.eatDelim(c, XML_EQUAL, msg);
file.eatAttributeDelim(c, msg);
std::string attrvalue = file.extractValue(c);
setAttr(attrname, attrvalue);
file.eatWhitespace(c);
}
c = file.get(); // next after XML_RIGHT_BRACKET
file.eatWhitespace(c);
// sub-elements
while (c == XML_LEFT_BRACKET)
{
if (file.peek() == XML_DIVIDE) break;
XMLTree* pChild = new XMLTree;
assertPtr(pChild);
pChild->setParent(this);
pChild->loadText(file, msg);
addChild(pChild);
c = file.get(); // next after XML_RIGHT_BRACKET
file.eatWhitespace(c);
}
// content
if (c != XML_LEFT_BRACKET)
{
std::string content;
content += '\n';
while (c != XML_LEFT_BRACKET)
{
content += c;
c = file.get();
}
setText(content);
}
assert(c == XML_LEFT_BRACKET);
c = file.get(); // next after XML_LEFT_BRACKET
file.eatDelim(c, XML_DIVIDE, msg);
std::string end_name(file.extractName(c));
if (getName() != end_name)
{
throw XMLUtil::sprintf(
"syntax error at %d line %d column - beginning name '%s' does not match end name '%s'",
file.getCurrentLine(), file.getCurrentColumn(),
getName().c_str(), end_name.c_str());
}
file.eatDelim(c, XML_RIGHT_BRACKET, msg);
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 내부적으로 사용하는 재귀 호출용 저장 함수
/// \param file 파일 스트림
/// \param indent 들여쓰기 레벨
//////////////////////////////////////////////////////////////////////////////
void XMLTree::saveText(std::ofstream& file, size_t indent)
{
for (size_t i=0; i<indent; i++) file << "\t";
file << "<" << m_Name;
for (ATTRIBUTES::const_iterator itr = m_Attributes.begin();
itr != m_Attributes.end(); itr++)
{
file << " " << itr->first << "=\"" << itr->second << "\"";
}
// 할당된 텍스트 및 자식 노드가 존재하지 않는다면,
// <nodename/>
// 형식으로 기록하는 것이 보기 좋다.
if (m_Text.empty() && m_Children.empty())
{
file << "/>" << std::endl;
}
// 할당된 텍스트가 있거나, 자식 노드가 있다면,
// <nodename>text...<childnode>...</childnode>...</nodename>
// 이런 식으로 해야한다.
else
{
file << ">" << m_Text << std::endl;
for (CHILDREN::const_iterator itr = m_Children.begin();
itr != m_Children.end(); itr++)
{
(*itr)->saveText(file, indent + 1);
}
for (size_t i=0; i<indent; i++) file << "\t";
file << "</" << m_Name << ">" << std::endl;
}
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 내부적으로 사용하는 재귀 호출용 파싱 함수
/// \param file XML 데이터가 들어있는 스트림 객체
/// \param msg 파싱 중 에러가 발생했을 때 출력할 메시지 헤더
//////////////////////////////////////////////////////////////////////////////
void XMLTree::loadBinary(std::ifstream& file, const std::string& msg)
{
assert(file.good());
// 자신의 이름을 읽어들인다.
m_Name = XMLUtil::readWORDString(file);
// 자신의 텍스트를 읽어들인다.
m_Text = XMLUtil::readWORDString(file);
// 속성의 갯수를 읽어들인다.
unsigned short attrcount = 0;
file.read(reinterpret_cast<char*>(&attrcount), sizeof(attrcount));
// 속성들을 읽어들인다.
for (unsigned short i=0; i<attrcount; ++i)
{
std::string attrname = XMLUtil::readWORDString(file);
std::string attrvalue = XMLUtil::readWORDString(file);
setAttr(attrname, attrvalue);
}
// 자식의 갯수를 읽어들인다.
unsigned short childcount = 0;
file.read(reinterpret_cast<char*>(&childcount), sizeof(childcount));
// 자식을 읽어들인다.
for (unsigned short i=0; i<childcount; i++)
{
XMLTree* pChild = new XMLTree();
assertPtr(pChild);
pChild->setParent(this);
pChild->loadBinary(file, msg);
addChild(pChild);
}
}
//////////////////////////////////////////////////////////////////////////////
/// \brief 내부적으로 사용하는 재귀 호출용 저장 함수
/// \param file 파일 스트림
//////////////////////////////////////////////////////////////////////////////
void XMLTree::saveBinary(std::ofstream& file)
{
assert(file.good());
// 자신의 이름을 저장한다.
XMLUtil::writeWORDString(file, m_Name);
// 자신의 텍스트를 기록한다.
XMLUtil::writeWORDString(file, m_Text);
// 속성의 갯수를 저장한다.
unsigned short attrcount = static_cast<unsigned short>(m_Attributes.size());
file.write(reinterpret_cast<const char*>(&attrcount), sizeof(attrcount));
// 모든 속성을 저장한다.
for (ATTRIBUTES::const_iterator itr(m_Attributes.begin());
itr != m_Attributes.end(); ++itr)
{
XMLUtil::writeWORDString(file, itr->first);
XMLUtil::writeWORDString(file, itr->second);
}
// 자식의 갯수를 저장한다.
unsigned short childcount = static_cast<unsigned short>(m_Children.size());
file.write(reinterpret_cast<const char*>(&childcount), sizeof(childcount));
// 자식 노드를 저장한다.
for (CHILDREN::const_iterator itr(m_Children.begin());
itr != m_Children.end(); ++itr)
{
(*itr)->saveBinary(file);
}
}
SeriousMoin v1 (koMoinMoin 1.0a4 Modified)
