library.h

个人电子图书管理系统.提供电子书的书名和其他信息.检查电子书信息的合法性（E-1） .为这本电子书生成 id.使用分类id

// 文件: Library.h
// 目的: KingBook的KingBookLibrary库 类声明
// 项目:
// 摘要:
// 时间: 2006-11-9 8:25:13
#ifndef _LIBRARY_
#define _LIBRARY_
#include <string>
#include <vector>
#include <exception>
#include <stdexcept>

//#define TIXML_USE_STL
#include "../../ticpp/tinyxml.h"

/// <summary>KingBool Library, 执行对图书的实际管理</summary>
namespace Library
{
    //TreeView中的根节点
    static const std::string IDS_BOOKCLASS_ROOT  = "1"; ///< 根节点"我的电子书" 的id
    static const std::string IDS_FAVORITE        = "2"; ///< 根节点"收藏夹" 的id
    static const std::string IDS_RECENT          = "3"; ///< 根节点"最近浏览" 的id
    static const std::string IDS_ALL_BOOK        = "4"; ///< 根节点"所有图书" 的id

    
    
    /// <summary>书对象, 一个基类.</summary>
    /// <remarks>在参数传递中经常使用; 声明了一些公共操作</remarks>
    class BookObject
    {
    protected:
        
        /// <summary>对象的id.是一个uuid</summary>
        std::string id;

    public:
        ///< 创建一个UUID
        static std::string CreateID();

    public:
        
        /// <summary>得到对象的ID</summary>
        /// <returns>对象的ID</returns>
        virtual const std::string& GetID() const
        {
            return id;
        }

        
        /// <summary>设置对象的id</summary>
        /// <param name="id">对象的新id</param>
        /// <returns>void</returns>
        /// <remarks></remarks>
        void SetID(const std::string& id)
        {
            this->id = id;
        }

        virtual int LoadFromXml(TiXmlElement* elem);

        virtual int SaveToXml(TiXmlElement* elem);


    public:
        ///< 使用一个id创建Object
        BookObject(std::string uuid);
    protected:
        ///< 缺省构造函数, 产生id
        BookObject();
        ///< 不产生ID的构造函数
        BookObject(int i);

    };// END CLASS DEFINITION BookObject

    
    /// <summary>电子书</summary>
    class Book : public BookObject
    {
    private:        
        /// <summary>书名</summary>
        std::string name;
        
        /// <summary>书的作者</summary>
        std::string author;
        
        /// <summary>摘要</summary>
        std::string brief;
        
        /// <summary>书的图片</summary>
        std::string image;
        
        /// <summary>书的链接, 本地文件或Web页</summary>
        std::vector<std::string> urls;
        
        /// <summary>出版社</summary>
        std::string publisher;
        
        /// <summary>电子书的版本</summary>
        std::string edition;
        
        /// <summary>对书的(详细)描述</summary>
        std::string descriprtion;
    public:
        // 构造函数
        Book(const std::string& name, const std::string& author, const std::string& brief);

        Book();

        // 从一个XML节点创建Book
        Book(TiXmlElement* bookElem);

        Book(std::string id);

        ///< 赋值运算符
        Book&  operator=(const Book& r);

        ///< 从一个XML节点加载Book
        int LoadFromXml(TiXmlElement* bookElem);

        ///< 把Book的信息保存到一个XML节点
        int SaveToXml(TiXmlElement* bookElem) const;

        ///< 将Book的信息已XML文件的方式保存到一个本地文件，以便显示
        int SaveToFile(const std::string& fileName, const std::string& xslt) const;

        
        /// <summary>返回书名</summary>
        const std::string& GetName() const
        {
            return this->name;
        }
        
        /// <summary>返回书的作者</summary>
        const std::string& GetAuthor() const
        {
            return this->author;
        }
        
        /// <summary>返回书的摘要</summary>
        const std::string& GetBrief() const
        {
            return this->brief;
        }
        
        /// <summary>返回书的图片</summary>
        const std::string& GetImage() const
        {
            return this->image;
        }
        
        /// <summary>返回书第一个的链接, 可能为空</summary>
        const std::string& GetURL() const
        {
            return this->urls[0];
        }
        
        /// <summary>返回书全部的链接</summary>
        const std::vector<std::string>& GetAllURL() const
        {
            return this->urls;
        }
        
        /// <summary>返回书的版本</summary>
        const std::string& GetEdition() const
        {
            return this->edition;
        }
        
        /// <summary>返回出版社</summary>
        const std::string& GetPublisher() const
        {
            return this->publisher;
        }
        
        /// <summary>返回对书的描述</summary>
        const std::string& GetDescription() const
        {
            return this->descriprtion;
        }
        
        ///< 设置图书的书名
        void SetName(const std::string& name);

        ///< 设置图书的作者
        void SetAuthor(const std::string& author);

        ///< 设置图书的简要介绍
        void SetBrief(const std::string& brief);

        ///< 设置图书的图片,封面
        void SetImage(const std::string& image);

        ///< 添加链接
        void AddURL(const std::string& url);

        ///< 添加链接
        void SetURL(const std::string& url);

        ///< 设置图书的版本
        void SetEdition(const std::string& edition);

        ///< 设置图书的详细描述
        void SetDescription(const std::string& description);

        ///< 设置图书的出版社
        void SetPublisher(const std::string& publisher);

    };// END CLASS DEFINITION Book
    // 
    
    /// <summary>书的种类</summary>
    /// <remarks></remarks>
    class BookClass : public BookObject
    {
    private:        		
        /// <summary>书的类别的名</summary>
        std::string name;
        		
        /// <summary>种类的描述 </summary>		 
        std::string descripton;

    public:
        BookClass();

        BookClass(const std::string& id);

        BookClass(const std::string& className, const std::string& desc);

        BookClass(const BookClass& r);

        BookClass& operator = (const BookClass& r);

    public:        		
        /// <summary>返回种类名 </summary>
        const std::string& GetName() const
        {
            return this->name;
        }
        		
        /// <summary>返回对种类的描述</summary>
        const std::string& GetDescription() const 
        {
            return this->descripton;
        }
        void SetName(const std::string& className);

        void SetDescription(const std::string& desc);

        int LoadFromXml(TiXmlElement* classElem);

        int SaveToXml(TiXmlElement* classElem) const;
    private:

    };// END CLASS DEFINITION BookClass

    ///< 收藏夹.<b>这个类未定义,未使用</b>
    class Favorite : public BookClass
    {

	};// END CLASS DEFINITION Favorite
    ///< 最近打开.<b>这个类未定义,未使用</b>
	class Recent : public BookClass
	{


	};// END CLASS DEFINITION Recent

    
    /// <summary>最近打开中的一项</summary>
    /// <remarks>包括三项:id, lasttime, count</remarks>
    class RecentItem : public BookObject
    {
    private:        
        /// <summary>上一次打开</summary>
        std::string lastTime;
        
        /// <summary>累计打开次数</summary>
        int count;
    public:
        // 默认构造函数
        RecentItem();
        // 拷贝构造函数
        RecentItem(const RecentItem& copy);

        /* get */
        
        /// <summary>得到上一次打开时间</summary>
        /// <returns></returns>
        const std::string& GetLastTime()
        {
            return this->lastTime;
        }
        
        /// <summary>得到这本图书的累计打开次数</summary>
        /// <returns></returns>
        int GetCount()
        {
            return this->count;
        }
        
        /// <summary>设置图书的最后一次打开时间</summary>
        /// <param name="lastTime">[IN]时间:一个字符串表示的32整数</param>
        /// <returns>void</returns>
        /// <remarks>不检查时间的格式</remarks>
        void SetLastTime(const std::string& lastTime)
        {
            this->lastTime = lastTime;
        }
        
        /// <summary>设置图书的打开次数</summary>
        /// <param name="count">新的次数</param>
        /// <returns>void</returns>
        /// <remarks>一般用法:SetCount(GetCount() + 1)</remarks>
        void SetCount(int count)
        {
            this->count = count;
        }
        int LoadFromXml(TiXmlElement* elem);

        int SaveToXml(TiXmlElement* elem);
    };
     
    /// <summary>书库.KingBook图书管理的核心</summary>
    /// <remarks>GUI对图书数据的所有操作, 最终都通过这个类</remarks>
    class BookLibrary
	{
//    protected:
    public:        
        TiXmlDocument doc;// XML 文档
        TiXmlNode*    classRoot;// 图书分类的节点根
        TiXmlNode*    bookRoot; // 图书的节点根
        std::string   xmlFile;  // 书库的数据文件
    public:
        BookLibrary();
        BookLibrary(const std::string& xmlFile );
        int Load(const std::string& xmlFile );
        int Save();
        int Save(const std::string& xmlFile);

	public:

		// 使用Book对象添加新电子书
		// 成功返回 0;失败返回 其他.
        int AddNewBook(const BookObject& bookCls,
				 const Book& book);

		// 删除电子书。
		// 成功返回0; 失败返回 其他值
		int DeleteBook(const BookObject& book);

		// 修改电子书的信息
		// 成功返回 0; 失败返回其他值
		int ModifyBookInfo(const BookObject& oldBook,
					 const Book& newBookInfo);

		// 修改电子书的分类（移动）
		// 成功返回0； 失败返回 其他值
		int MoveBook(const BookObject& book,
			   const BookObject& newBookCls);


		// 得到指定电子书的信息
		int GetBookInfo(const BookObject& book,
				  Book &bookInfo);

        int GetAllBookInfo(std::vector<BookObject>& booksID);

        // 将图书book添加到收藏夹
        int AddToFavorite(const BookObject& book);

        // 将图书book从收藏夹删除
        int DeleteFromFavorite(const BookObject& book);

		// 添加新的图书分类
		// 成功返回0;失败返回 其他值
		int AddNewBookClass(const BookClass& child,
					  const BookObject& parent);

		// 删除指定的图书分类，同时将删除子分类的属于这些分类的电子书
		// 成功返回0； 失败返回 其他值
		int DeleteBookClass(const BookObject& bookCls);

        // 得到指定分类的信息
        int BookLibrary::GetBookClassInfo(const BookObject& bookClass,
							 BookClass &bookClassInfo);

		// 修改图书分类的信息:名称和描述。
		int ModifyBookClassInfo(const BookObject& oldBookCls,
						  const BookClass& newBookClassInfo);

		// 移动子分类 所属的父类
		int MoveBookClass(const BookObject& child,
					const BookObject& newParent);

        // 得到图书分类bookClass下的图书
        int GetBooksOfClass(const BookObject& bookClass, std::vector<BookObject>& books);

        // 得到图书分类bookClass, 下面的子分类
        int GetSubsOfClass(const BookObject& bookClass, std::vector<BookClass>& subs);

        // 得到图书根分类, 收藏夹等
        int GetRootBookClass(std::vector<BookClass>& bookClasses);

        // 当打开图书时, 需要处理的任务
        int OnOpenBook(const BookObject& bookID); 

        // 得到最近浏览的信息
        int GetRecentInfo(std::vector<RecentItem>& recentItems);

    protected:
        // 从指定的xml节点使用id查找 分类
        TiXmlElement* FindBookClass(TiXmlElement* classElem, const std::string& bookClassID);

        //找到某本图书所属的分类
    public:
        TiXmlElement* FindClassOfBook(TiXmlElement* classElem, const std::string& bookID);

    };// END CLASS DEFINITION BookLibrary

    
    /// <summary>KingBook的异常处理类的基类</summary>
    /// <remarks></remarks>
    class KException:public std::runtime_error
    {
        // 构造和析构函数
    public:
        //给异常类一个消息, 并构造这个对象.string 方式
        KException(const std::string& msg);

        //KException的拷贝构造函数
        KException(const KException& r);
        //virtual ~KException();
        // 拷贝构造函数和赋值函数, 默认为私有
        // public:
    private:
        KException(void);
        KException& operator = (const KException& r);
    };

    
    /// <summary>异常类, XML数据文件格式错误</summary>
    /// <remarks>用在BookLibrary类中</remarks>
    class KXmlFileException:public KException
    {
        // 构造和析构函数
    public:

        //给异常类一个消息, 并构造这个对象.string 方式
        KXmlFileException(const std::string& msg);

        //KXmlFileException的拷贝构造函数
        KXmlFileException(const KXmlFileException& r);
        //virtual ~KXmlFileException();

        // 拷贝构造函数和赋值函数, 默认为私有
        // public:
    private:
        KXmlFileException(void);
        KXmlFileException& operator = (const KXmlFileException& r);

    };
} // Library


#endif // _LIBRARY_