ここでは、ソースのみ記載します。
ソースの説明はこちら を参照ください。
WordIterator.h
【サンプル】
//
#ifndef __WORD_ITERATOR_H__
#define __WORD_ITERATOR_H__
#include <cstdlib>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <sstream>
#include <functional>
#include "boost/shared_ptr.hpp"
namespace nana{
using namespace std;
using namespace boost;
class WordKind;
typedef shared_ptr<WordKind> WordKindPtr;
/**
長さを扱う基底クラス。 WordIterator に設定する。
*/
class WordKind
{
public:
enum{ NONE_KIND=-1 };
///
virtual ~WordKind(){};
///次の1文字を計算する
virtual const int calc(const char* p, int& type) const =0;
///自分自身を作成する
virtual const WordKindPtr create() const =0;
///内部の値を変更する
void change(const char* p, const int& len, const int& type){
m_len = len;
m_pos = p;
m_type = type;
};
///出力させる
friend ostream& operator << (ostream& out, const WordKind& w){
out << w.str();
return out;
};
///文字列が同じかどうか？
bool operator == (const WordKind& w) const {
if(m_len != w.m_len) return false;
return (strncmp(m_pos, w.m_pos, m_len) == 0);
};
///1文字をstringにする
const string str() const
{ return string(m_pos, m_len); };
///1文字のサイズを取得
const int& size() const
{ return m_len; };
///1文字のタイプ（派生クラスに定義）を取得
const int& type() const
{ return m_type; };
///現在の位置を取得する
const char* pos() const
{ return m_pos; };
protected:
WordKind(const int& len=0, const int& type=NONE_KIND)
: m_len(len), m_type(type)
{};
private:
int m_len;
int m_type;
const char* m_pos;
};
/**
WordKind のデフォルトを扱うクラス。
*/
class WordDefault{
public:
static const WordKindPtr create()
{ return defaultKind->create(); };
static void set(const WordKindPtr& ptr)
{ defaultKind = ptr; };
protected:
WordDefault(){};
static WordKindPtr defaultKind;
};
/**
文字列を扱うイテレータ。
文字列の長さは、 WordKind が計算する。
*/
template <typename Iterator>
class WordIterator : public std::iterator<input_iterator_tag, WordKind, int>
{
public:
///コンストラクタ
WordIterator(const Iterator& begin, const Iterator& end, const WordKindPtr& kindPtr)
: m_curPos(begin), m_nextPos(begin), m_end(end), m_kind(kindPtr)
{
++(*this);
};
///endイテレータを作る
WordIterator()
: m_end(endPos), m_curPos(endPos), m_nextPos(endPos), m_kind()
{};
///
const WordKind& operator *() const{
return *m_kind;
};
///実体参照
const WordKind* operator ->() const {
return m_kind.get();
};
///１つ次へ進める
WordIterator& operator ++()
{
int i, type;
//次の位置を設定する
m_curPos = m_nextPos;
if(isEnd()) return *this;
//次の位置の文字のバイト数と種別を取得する
int len = m_kind->calc(&*m_nextPos, type);
//長さの数だけ進める
for(i=0; i<len && m_nextPos!=m_end; ++i, ++m_nextPos){}
m_kind->change(&*m_curPos, i, type);
return *this;
};
///等価演算子
bool operator ==(const WordIterator& ite) const {
if(isEnd() != ite.isEnd()) return false;
if(isEnd() && ite.isEnd()) return true;
return (m_curPos == ite.m_curPos);
};
///否定演算子
bool operator !=(const WordIterator& ite) const {
return !(*this == ite);
};
protected:
///終了の位置かどうか。m_curPos == m_endのときtrue
const bool isEnd() const {
return (m_curPos == m_end);
};
private:
WordKindPtr m_kind;
Iterator m_curPos;
Iterator m_nextPos;
Iterator m_end;
static Iterator endPos;
};
/**
1文字比較のためのクラス。
*/
class FixedWordKind : public WordKind
{
public:
///
FixedWordKind(const char* str)
{ change(str, strlen(str), NONE_KIND); };
///次の1文字を計算する
const int calc(const char* p, int& type) const
{
type = NONE_KIND;
return size();
};
///NULLを返すことに注意
const WordKindPtr create() const
{ return WordKindPtr(); };
};
//型宣言-----------
//イテレータ型
typedef WordIterator<const char*> CharWordIterator;
typedef WordIterator<string::const_iterator> StringWordIterator;
//WordIterator作成のためのヘルパー---------------------
/**
CharWordIteratorのコンストラクタの記述を短くするための関数。
*/
inline CharWordIterator wordIterator(const char* str,
const WordKindPtr& kindPtr = WordDefault::create())
{
return CharWordIterator(str, str+strlen(str), kindPtr);
};
/**
StringWordIteratorのコンストラクタの記述を短くするための関数。
*/
inline StringWordIterator wordIterator(const string& str,
const WordKindPtr& kindPtr = WordDefault::create())
{
return StringWordIterator(str.begin(), str.end(), kindPtr);
};
}; //namespace nana
#endif