cocos2d-x開發: 一切應該從配置文件讀取開始

想要做一款完整的游戲,應該從配置文件讀取開始。cocos2d-x本身提供了UserDefault來操作xml格式的配置文件,准確的說配置這模塊引擎開發者已經考慮到了.但是xml格式包含大量無關的格式信息,對於開發者直接使用編輯器操作也不是很友好.我期望的配置文件應該具備兩個特點,第一：格式簡單.這是我一貫的*nix風格的要求,我喜歡只管的#注釋以及key-value的配置方式.可能唯一需要考慮的是這樣簡單的配置方式會不會因為業務擴展而顯得功能不足.這一點是可以放心的,那些都是業務邏輯相關的,選擇就會很多.至少現在不是應該考慮的范疇.第二:對開發者友好.什么叫做友好? 說白了,按照我的理解就是很容易可以定位配置信息的位置,容易修改,對編輯器依賴不高.我們隨便用個notepad++/subl之類的文本編輯器就可以直接閱讀和修改.

好了,基於上面的考慮,ini格式無疑是比較好的選擇.我最終選用了ini格式作為配置文件首選.所以就寫了一個c++類來解析和操作ini配置.代碼如下:

#ifndef __xy_INICache_INCLUDE__
#define __xy_INICache_INCLUDE__
#include <map>
#include <vector>
#include <string>
namespace xy
{
    class INICache
    {
    public:
        INICache();
        virtual ~INICache();
        static INICache* createFromFile(const std::string& filePath);
        static INICache* createFromStream(const std::stringstream& sstream);
        bool loadFromFile(const std::string& filePath);
        bool loadFromStream(const std::stringstream& sstream);
        void flush(const std::string& filePath);
        std::string getFilePath() const { return this->M_filePath_; }
        bool isSectionExist(const std::string& section) const;
        bool deleteSection(const std::string& section);
        void getSectionNames(std::vector<std::string>& sectionVector);
        void setString(const std::string& section, const std::string& key, const std::string& value);
        std::string getString(const std::string& section, const std::string& key, const std::string& defaultValue);
        void setInteger(const std::string& section, const std::string& key, int value);
        int getInteger(const std::string& section, const std::string& key, int defaultValue);
        void setDouble(const std::string& section, const std::string& key, double value, int pre);
        double getDouble(const std::string& section, const std::string& key, double defaultValue);
        void setBoolean(const std::string& section, const std::string& key, bool value);
        bool getBoolean(const std::string& section, const std::string& key, bool defalutValue);
    protected:
        void trimString(std::string& buffer, const std::string& trim, bool isAll);
        void parseLine(const std::string& buffer);
        std::string parseSection(const std::string& buffer, const std::string& leftTag, const std::string& rightTag);
        bool stringToBoolean(const std::string& buffer, bool defaultValue);

        typedef std::map<std::string, std::string> KVtype;
        typedef std::map<std::string, KVtype>       SKVtype;

        std::string M_filePath_;        
        std::string M_currentSection_;  
        SKVtype        propsMap_;            
    };
}
#endif//__xy_INICache_INCLUDE__

 

實現部分的代碼如下,如果需要看的,可以自行查看.

#include "INICache.h"
#include <fstream>
#include <sstream>
namespace xy
{
    INICache::INICache()
    {
    }
    INICache::~INICache()
    {
        if(!this->propsMap_.empty()) { this->propsMap_.clear(); }
    }
    INICache* INICache::createFromFile(const std::string& filePath)
    {
        INICache* pINICache = new INICache;
        if(!pINICache->loadFromFile(filePath))
        {
            delete pINICache;
            return NULL;
        }
        return pINICache;
    }
    bool INICache::loadFromFile(const std::string& filePath)
    {
        std::ifstream fin(filePath.c_str());
        if(!fin.is_open()) { return false; }
        
        std::string lineBuffer;
        while(!fin.eof())
        {
            std::getline(fin, lineBuffer);
            this->trimString(lineBuffer, std::string(" "), true);
            this->parseLine(lineBuffer);
        }
        fin.close();
        this->M_filePath_ = filePath;
        return true;
    }
    INICache* INICache::createFromStream(const std::stringstream& sstream)
    {
        INICache* pINICache = new INICache;
        if(!pINICache->loadFromStream(sstream))
        {
            delete pINICache;
            return NULL;
        }
        return pINICache;
    }
    bool INICache::loadFromStream(const std::stringstream& sstream)
    {
        std::string lineBuffer;
        std::istringstream isstream(sstream.str());
        while(!isstream.eof())
        {
            std::getline(isstream, lineBuffer);
            this->trimString(lineBuffer, std::string(" "), true);
            this->parseLine(lineBuffer);
        }
        return true;
    }
    void INICache::flush(const std::string& filePath)
    {
        std::ofstream fout(filePath.c_str());
        if(!fout.is_open()) { return; }
        std::string buffer;
        SKVtype::iterator skv_iter;
        KVtype::iterator  kv_iter;
        for(skv_iter = this->propsMap_.begin(); skv_iter != this->propsMap_.end(); ++skv_iter)
        {
            fout << std::endl;
            fout << std::string("[") << skv_iter->first << std::string("]") << std::endl;
            for(kv_iter = skv_iter->second.begin(); kv_iter != skv_iter->second.end(); ++kv_iter)
            {
                fout << kv_iter->first << std::string("=") << kv_iter->second << std::endl;
            }
        }
        fout.close();
    }
    bool INICache::isSectionExist(const std::string& section) const
    {  return (this->propsMap_.find(section) != this->propsMap_.end()); }
    bool INICache::deleteSection(const std::string& section)
    {
        if(!section.empty()) { return false; }
        SKVtype::iterator skv_iter = this->propsMap_.find(section);
        if(skv_iter != this->propsMap_.end())
        {
            this->propsMap_.erase(skv_iter);
            return true;
        }
        return false;
    }
    void INICache::getSectionNames(std::vector<std::string>& sectionVector)
    {
        if(!sectionVector.empty()) { sectionVector.clear(); }
        SKVtype::iterator skv_iter = this->propsMap_.begin();
        for(; skv_iter != this->propsMap_.end(); ++skv_iter)
        { sectionVector.push_back(skv_iter->first); }
    }
    void INICache::setString(const std::string& section, const std::string& key, const std::string& value)
    {
        if(!section.empty() && !key.empty())
        { this->propsMap_[section][key] = value; }
    }
    std::string INICache::getString(const std::string& section, const std::string& key, const std::string& defaultValue)
    {
        if(!section.empty() && !key.empty())
        {
            SKVtype::iterator skv_iter = this->propsMap_.find(section);
            if(skv_iter != this->propsMap_.end())
            {
                KVtype::iterator kv_iter = skv_iter->second.find(key);
                if(kv_iter != skv_iter->second.end())
                { return kv_iter->second; }
            }
        }
        return defaultValue;
    }
    void INICache::setInteger(const std::string& section, const std::string& key, int value)
    {
        std::stringstream sstream;
        sstream << value;
        this->setString(section, key, sstream.str());
    }
    int INICache::getInteger(const std::string& section, const std::string& key, int defaultValue)
    {
        std::string tmp = this->getString(section, key, std::string(""));
        std::stringstream sstream;
        sstream << tmp;
        sstream >> defaultValue;
        return defaultValue;
    }
    void INICache::setDouble(const std::string& section, const std::string& key, double value, int pre)
    {
        std::stringstream sstream;
        if(pre) { sstream.precision(pre); }
        sstream << value;
        this->setString(section, key, sstream.str());
    }
    double INICache::getDouble(const std::string& section, const std::string& key, double defaultValue)
    {
        std::string tmp = this->getString(section, key, std::string(""));
        std::stringstream sstream;
        if(!tmp.empty())
        {
            sstream << tmp;
            sstream >> defaultValue;
        }
        return defaultValue;
    }
    void INICache::setBoolean(const std::string& section, const std::string& key, bool value)
    { this->setInteger(section, key, value ? 1:0); }
    bool INICache::getBoolean(const std::string& section, const std::string& key, bool defaultValue)
    {
        std::string tmp = this->getString(section, key, std::string(""));
        if(!tmp.empty()) { return this->stringToBoolean(tmp, defaultValue); }
        return defaultValue;
    }
    void INICache::trimString(std::string& buffer, const std::string& trim, bool isAll)
    {
        if(buffer.empty()) { return; }
        while(buffer.find(trim) == 0)
        {
            buffer.erase(0, trim.length());
            if(!isAll) { break; }
        }
        while(!buffer.empty() && (buffer.rfind(trim) == (buffer.length() - trim.length())))
        {
            buffer.erase(buffer.length() - trim.length(), trim.length());
            if(!isAll) { break; }
        }
    }
    void INICache::parseLine(const std::string& buffer)
    {
        if(buffer.empty()) { return; }
        switch (buffer[0])
        {
        case '#':
        case '%':
            return;
        case '[':
            {
                std::string section = this->parseSection(buffer, std::string("["), std::string("]"));
                this->trimString(section, std::string(" "), true);
                if(!section.empty()) { this->M_currentSection_ = section; }
            }
            return;
        default:
            {
                if(buffer.find(std::string("=")) != std::string::npos && !this->M_currentSection_.empty())
                {
                    std::string key = this->parseSection(buffer, std::string(""), std::string("="));
                    this->trimString(key, std::string(" "), true);
                    std::string value = this->parseSection(buffer, std::string("="), std::string(""));
                    this->trimString(value, std::string(" "), true);
                    if(!key.empty()) { this->propsMap_[this->M_currentSection_][key] = value; }
                }
            }
            return;
        }
    }
    std::string INICache::parseSection(const std::string& buffer, const std::string& leftTag, const std::string& rightTag)
    {
        std::string ret;
        if(!buffer.empty())
        {
            std::string::size_type pos_begin = 0, pos_end = 0;
            if(!leftTag.empty())
            {
                pos_begin = buffer.find(leftTag);
                if(pos_begin == std::string::npos) { return ret; }
                pos_begin += leftTag.size();
            } else { pos_begin = 0; }
            if(!rightTag.empty())
            {
                pos_end = buffer.find(rightTag, pos_begin);
                if(pos_end == std::string::npos) { return ret; }
                ret = buffer.substr(pos_begin, pos_end - pos_begin);
            } else { ret = buffer.substr(pos_begin, std::string::npos); }
        }
        return ret;
    }
    bool INICache::stringToBoolean(const std::string& buffer, bool defaultValue)
    {
        if(buffer.empty()) { return defaultValue; }
        std::stringstream sstream;
        sstream << buffer;
        int tmp = 0;
        sstream >> tmp;
        return (buffer.compare(std::string("true"))==0 || tmp > 0);
    }
}

 

 這里主要是說一下我做的這些接口的思路. 讀取涉及到的get/set這些方法,是基本需求.提供了兩個讀取Ini buffer的方法,一個是loadFromFile(const std::string& filePath),這個接口主要是應對客戶端從本地讀取配置文件信息,而loadFromStream(const std::stringstream& sstream)接口則是作為預留,從buffer直接讀取Ini配置,為什么會做這樣一個接口的預留呢? 可以一起看一下getSectionNames這個接口方法,返回的是key值的集合.

我是這樣考慮的,c++這部分的接口盡量的簡單,實現基本的功能,盡量避開業務邏輯的操作.要什么,我就提供基本接口,除非是在lua那邊實現效率不高,或者是復雜,才會考慮提供完整的功能.因為緊接着下面會做更新模塊的功能,這部分至少會依賴讀取配置中一條關於資源版本的信息.而從遠程Http服務器下載資源的時候也還是需要做很多版本的檢測處理,如果是增量更新的話,需要按照版本的先后順序依次下載.這就是要對key值進行按照需求排序. 本來在c++這部分做很簡單的,我只要用std::sort函數,提供一個compare函數就好了。可是這部分是和具體的更新業務邏輯關聯的,所以我不應該在c++這部分實現,所以就只是提供給你獲取集合的方法.然后自己去處理.

綁定這部分就沒什么好說的了. getSectionNames loadFromStream createFromStream這三個函數接口需要skip掉,結合前面的更新需求,需要的話,另外綁定接口,傳入lua callback,在C++這邊調用getSectionNames接口就好了,具體細節在后面寫到更新的時候自然就會寫出來了.我寫了一個測試:

 ---------------------------------------------------------------------
 -- @Author        小岩
 -- @Created on  2014-12-26 21:29
 -- @Brief        INI解析測試
 ---------------------------------------------------------------------
 INICacheTestCase = class("INICacheTestCase", TestsCase)
 -----------------------------------------------------------
 -- 測試解析INI文件
 function INICacheTestCase:run()
     local iniCache = xy.INICache:createFromFile("src/Tests/INICache/INICache_conf.ini")
     if iniCache == nil then
         Logger.Error(" cannot get local conf file! ")
     end
     Logger.Info("load file succ!")
     Logger.Info("%s", iniCache:getString("Section", "Key", "Failed"))
     Logger.Info("%d", iniCache:getInteger("Section", "Integer", "-1"))
     Logger.Info("%f", iniCache:getDouble("Section", "Double", "-1"))
     local boolean = iniCache:getBoolean("Section", "Boolean", false)
     if boolean == true then
         Logger.Info("%s", "boolean == true")
     else
         Logger.Info("%s", "boolean == false")
     end
 end
 ---------------------------------------------------------------------
 -- End Of Lua File
 ---------------------------------------------------------------------

 

需要注意的問題是,INICache讀取文件后,將配置文件信息一直都是保存在map中的,所以不要在不同的地方對同一份配置文件做多次讀取操作,這樣的話,將配置再次持久化到設備的時候,配置信息就會錯掉.所以最好是提供配置的單例操作方式.