lexical2/repeat.hpp: メソッド名を analyze() -> parse() にしたり、generate() を const メソッド化したり...

diff --git a/roast/include/roast/lexical2/repeat.hpp b/roast/include/roast/lexical2/repeat.hpp
index 308f276..6ff47c8 100644 (file)
--- a/roast/include/roast/lexical2/repeat.hpp
+++ b/roast/include/roast/lexical2/repeat.hpp
@@ -15,13 +15,13 @@ namespace roast
                {
                public:
                        template <typename _It, typename _Param>
-                       bool analyze(_It& it, _Param& param)
+                       bool parse(_It& it, _Param& param)
                        {
                                T t;
                                _It it_work = it;
                                for(;;)
                                {
-                                       if ( t.analyze(it_work, param) == false )
+                                       if ( t.parse(it_work, param) == false )
                                                break;
                                        else
                                                it = it_work;
@@ -32,7 +32,7 @@ namespace roast
                        //----
                        
                        template <typename _Strm, typename _Document>
-                       bool generate(_Strm& strm, _Document& doc)
+                       bool generate(_Strm& strm, _Document& doc) const
                        {
                                T t;
                                for(;;)
@@ -53,7 +53,7 @@ namespace roast
                {
                public:
                        template <typename _Strm, typename _Document>
-                       bool generate(_Strm& strm, _Document& doc)
+                       bool generate(_Strm& strm, _Document& doc) const
                        {
                                return true;
                        }
@@ -61,22 +61,23 @@ namespace roast
 
                ////////////////////
 
-               template <typename T, int N>
+               template <typename T, unsigned int N>
                class fixed_repeat// : public lengthable
                {
                public:
-                       const static int length = length_of<T>::value * N;
+                       const T t;
+
+                       //const static int length = length_of<T>::value * N;
 
                        /////////////////////////////////////////////////////////////
 
                        template <typename _It, typename _Param>
-                       bool analyze(_It& it, _Param& param)
+                       bool parse(_It& it, _Param& param)
                        {
-                               T t;
                                _It it_work = it;
-                               for(int i=0; i<N; i++)
+                               for(unsigned int i=0; i<N; i++)
                                {
-                                       if ( t.analyze(it_work, param) == false )
+                                       if ( t.parse(it_work, param) == false )
                                                return false;
                                        else
                                                it = it_work;
@@ -89,8 +90,7 @@ namespace roast
                        template <typename _Strm, typename _Document>
                        bool generate(_Strm& strm, _Document& doc)
                        {
-                               T t;
-                               for(int i=0; i<N; i++)
+                               for(unsigned int i=0; i<N; i++)
                                {
                                        if ( t.generate(strm, doc) == false )
                                                return false;
@@ -98,39 +98,41 @@ namespace roast
                                return true;
                        }
                };
-               template <typename T, int N>
+               template <typename T, unsigned int N>
                class fixed_loop : public fixed_repeat<T,N>{};
-               template <typename T, int N>
-               class n_loop : public fixed_loop<T,N>{};
+               /*template <typename T, unsigned int N>
+               class n_loop : public fixed_loop<T,N>{};*/
 
                ////////////////////
 
-               template <typename T, int N>
+               template <typename T, unsigned int N>
                class hard_repeat// : public lengthable
                {
                public:
-                       const static int length = length_of<T>::value * N;
+                       const T t;
+                       
+                       //const static int length = length_of<T>::value * N;
 
                        template <typename _It, typename _Param>
-                       bool analyze(_It& it, _Param& param)
+                       bool parse(_It& it, _Param& param)
                        {
-                               T t;
+                               //T t;
                                _It it_work = it;
-                               if ( t.analyze(it_work, param) == false )
+                               if ( t.parse(it_work, param) == false )
                                        return false;
                                else
                                {
                                        hard_repeat<T,N-1> fr2;
-                                       return fr2.analyze(it_work,param);
+                                       return fr2.parse(it_work,param);
                                }
                        }
 
                        //----
 
                        template <typename _Strm, typename _Document>
-                       bool generate(_Strm& strm, _Document& doc)
+                       bool generate(_Strm& strm, _Document& doc) const
                        {
-                               T t;
+                               //T t;
                                if ( t.generate(strm, doc) == false )
                                        return false;
                                else
@@ -146,11 +148,11 @@ namespace roast
                {
                public:
                        template <typename _It, typename _Param>
-                       bool analyze(_It& it, _Param& param)
+                       bool parse(_It& it, _Param& param)
                        {
                                T t;
                                _It it_work = it;
-                               if ( t.analyze(it_work, param) == false )
+                               if ( t.parse(it_work, param) == false )
                                        return false;
                                else
                                        it = it_work;
@@ -160,7 +162,7 @@ namespace roast
                        //----
 
                        template <typename _Strm, typename _Document>
-                       bool generate(_Strm& strm, _Document& doc)
+                       bool generate(_Strm& strm, _Document& doc) const
                        {
                                T t;
                                if ( t.generate(strm, doc) == false )
@@ -169,6 +171,11 @@ namespace roast
                        }
                };
                
+               //
+
+               template <typename T, unsigned int N>
+               class repeat : public fixed_repeat<T,N>{};
+               
                ////////////////////////////////////////////////////////
        }
 }