booklibrary.cpp

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

            if(book.GetID() == std::string(child->ToElement()->Attribute("id")))
            {
                break; // 找到 指定的相应的电子书
            }
        }
        if(NULL == child) // 没有相应的电子书
        {
            throw KXmlFileException("没有指定的书");
        }

        // 需要返回的信息
        TiXmlElement* bookElem = child->ToElement();

        // 构造临时对象        
        bookInfo.LoadFromXml(bookElem);
        return 0;
    }
     
 
    /// <summary>得到所有图书的-ID</summary>
    /// <param name="booksID">[OUT] 所有图书的ID</param>
    /// <returns>成功返回0; 失败返回其他值</returns>
    /// <exception></exception>
    /// <remarks>这个函数用于GUI的TreeView, 得到所有图书的ID, 图书的其他信息通过
    /// BookLibrary::GetBookInfo(...).</remarks>
    int BookLibrary::GetAllBookInfo(std::vector<BookObject>& booksID)
    {
        if(bookRoot == NULL)
            return 1;
        TiXmlNode* bookItem = bookRoot->FirstChild("Book");
        for(; bookItem != NULL; bookItem = bookItem->NextSibling("Book"))
        {
            const char* strID = ((TiXmlElement*)bookItem)->Attribute("id");

            if(strID == NULL)
                continue;

            Library::BookObject obj(strID);
            booksID.push_back(obj);
        }
        return 0;
    }
 
    /// <summary>从指定的xml节点使用id查找 图书分类</summary>
    /// <param name="classElem">[IN]将从这个节点搜索图书分类</param>
    /// <param name="id">[IN]图书分类的id号</param>
    /// <returns>返回图书分类所在的节点。返回NULL, 说明不存在这样的节点</returns>
    /// <remarks></remarks>
    TiXmlElement* BookLibrary::FindBookClass(TiXmlElement* classElem, const std::string& bookClassID)
    {
        TiXmlNode* child = NULL;
        for(child  = classElem->FirstChild("BookClass");
            child != NULL;
            child  = child->NextSibling("BookClass"))
        {
            if(bookClassID == std::string(child->ToElement()->Attribute("id")))
            {
                return child->ToElement(); // 找到 指定的相应的类别
            }
            else
            {
                TiXmlNode* hr = FindBookClass(child->ToElement(), bookClassID);
                if(hr != NULL)
                    return hr->ToElement();
            }

        }
        return (TiXmlElement*)child;
    }

 
    /// <summary>添加新的图书分类</summary>
    /// <param name="child">[IN]新的图书分类及分类的信息</param>
    /// <param name="parent">[IN]新分类的父分类。新的分类将成为这个分类的子分类</param>
    /// <returns>成功返回0;失败返回 其他值</returns>
    /// <exception cref="KXmlFileException">没有找到父分类</exception>
    /// <exception cref="KXmlFileException">无法添加新分类</exception>
    /// <remarks>
    /// 失败原因:BookLibrary 没有初始化返回 1
    /// </remarks>
    int BookLibrary::AddNewBookClass(const BookClass& child, const BookObject& parent)
    {
        if(classRoot == NULL)
            return 1;
        // 找到父节点
        TiXmlElement* pParentElem = NULL;
        pParentElem = this->FindBookClass(this->classRoot->ToElement(), parent.GetID());
        if(pParentElem == NULL)
        {
            throw KXmlFileException("没有找到父分类");
        }

        // 构造一个新的图书分类节点
        TiXmlElement childElem("");
        if(0 != child.SaveToXml(&childElem))
        {
            throw KXmlFileException("无法添加新分类");
        }

        // 插入
        if(NULL == pParentElem->InsertEndChild(childElem))
        {
            throw KXmlFileException("无法添加新分类");
        }
        return 0;
    }


 
    /// <summary>删除指定的图书分类，同时将删除子分类的属于这些分类的电子书</summary>
    /// <param name="bookCls">[IN]要删除的图书分类</param>
    /// <returns>成功返回0； 失败返回 其他值</returns>
    /// <exception cref="KXmlFileException">无法删除图书分类:没有指定的书</exception>
    /// <exception cref="KXmlFileException">无法删除图书分类:删除图书失败</exception>
    /// <remarks>考虑子分类
    /// 在递归中多次this->doc.SaveFile(), 有效率问题。</remarks>
    int BookLibrary::DeleteBookClass(const BookObject& bookCls)
    {
        // 1 删除该分类下的图书
        // TODO: 向下类型转换
        // const BookClass& foo = (BookClass&)bookCls;
        std::vector<BookObject> books;
        this->GetBooksOfClass(bookCls, books);
        for(int i = 0; i < books.size(); i ++)
        {
            // 1.1查找
            TiXmlNode* child = bookRoot->FirstChild("Book");
            for(; child != NULL; child = child->NextSibling("Book"))
            {
                if(books[i].GetID() == std::string(child->ToElement()->Attribute("id")))
                {
                    break; // 找到 指定的相应的电子书
                }
            }
            if(NULL == child) // 没有相应的电子书
            {
                throw KXmlFileException("无法删除图书分类:没有指定的书");
            }

            // 1.2 删除
            if(! bookRoot->RemoveChild(child))
            {
                throw KXmlFileException("无法删除图书分类:删除图书失败");
            }
        }

        // 2 删除子分类
        std::vector<BookClass> subBookCls;;
        this->GetSubsOfClass(bookCls, subBookCls);
        for(int i = 0; i < subBookCls.size(); i ++)
        {
            this->DeleteBookClass(subBookCls[i]);
        }


        // 3 删除分类节点
        TiXmlElement* clsElem = this->FindBookClass((TiXmlElement*)this->classRoot, bookCls.GetID());
        if(clsElem == NULL)
        {
        }
        TiXmlNode* parentNode = clsElem->Parent();
        parentNode->RemoveChild(clsElem);

        return 0;
    }

 
    /// <summary>得到指定分类的信息</summary>
    /// <param name="bookClass">[IN]得到这个分类的信息(使用id)</param>
    /// <param name="bookInfo">[OUT]分类的信息将保存到这里</param>
    /// <returns>成功返回0； 失败返回 其他值</returns>
    /// <exception cref="KXmlFileException">没有指定的图书分类</exception>
    /// <exception cref="KXmlFileException">调用的函数会跑出异常</exception>
    /// <remarks>
    /// 失败原因:BookLibrary 没有初始化返回 1
    /// </remarks>
    int BookLibrary::GetBookClassInfo(const BookObject& bookClass,
        BookClass &bookClassInfo)
    {
        // TODO: Assumed, classRoot is "the root of bookclass"
        if(classRoot == NULL)
            return 1;
        TiXmlNode* child;// = this->classRoot->FirstChild("BookClass");

        child = this->FindBookClass(classRoot->ToElement(), bookClass.GetID());
        if(NULL == child) // 没有相应的类别            
        {
            throw KXmlFileException("没有指定的图书分类!");
        }

        // 需要返回的信息
        TiXmlElement* classElem = child->ToElement();

        // 构造临时对象        
        bookClassInfo.LoadFromXml(classElem);
        return 0;
    }

 
    /// <summary>修改图书分类的信息:名称和描述。</summary>
    /// <param name="oldBookCls">[IN]修改这个分类的信息</param>
    /// <param name="newBookClassInfo">[IN]分类的新的信息</param>
    /// <returns>成功返回0; 失败返回 其他值</returns>
    /// <exception cref="KXmlFileException">没有指定的图书分类</exception>
    /// <exception cref="KXmlFileException">无法修改指定图书分类的信息</exception>
    /// <remarks>
    /// 失败原因:BookLibrary 没有初始化返回 1；
    /// </remarks>
    int BookLibrary::ModifyBookClassInfo(const BookObject& oldBookCls,
        const BookClass& newBookClassInfo)
    {
        std::stringstream ss;
        std::string       strXML;
        if(classRoot == NULL)
            return 1;
        TiXmlElement* child;

        child = this->FindBookClass(classRoot->ToElement(), oldBookCls.GetID());
        if(NULL == child) // 没有相应的类别            
        {
            throw KXmlFileException("没有指定的图书分类!");
        }
        //cout<<endl<<"----1----"<< endl;
        
        //child->Print(stdout, 10);
        // 组合 id 和信息
        BookClass clsTmp(newBookClassInfo);
        clsTmp.SetID(oldBookCls.GetID());

        // 保存到XmlDom节点
        //TiXmlElement* newChild = child->Clone()->ToElement();
        //cout<<endl<<"----2----"<< endl;
        //newChild->Print(stdout, 10);
        if(clsTmp.SaveToXml(child))
        {
            throw KXmlFileException("无法修改指定图书分类的信息");
        }
        //cout<<endl<<"----3----"<< endl;
        //child->Print(stdout, 10);
        //cout<<endl<<"----4----"<< endl;
        //newChild->Print(stdout, 10);

        // 更新DOM
        //if(NULL == this->classRoot->ReplaceChild(child, newChild))
        //if(NULL == child->Parent()->ReplaceChild(child, *newChild))
        //{
        //    throw KXmlFileException("无法修改指定图书分类的信息");
        //}
        return 0;
    }

    //TODO: 移动子分类 所属的父类
    int BookLibrary::MoveBookClass(const BookObject& child,
        const BookObject& newParent)
    {
        return 0;
    }

 
    /// <summary>得到某个图书分类包括的图书</summary>
    /// <param name="bookClass">[IN]图书分类</param>
    /// <param name="books">[OUT]图书数组</param>
    /// <returns>成功返回0; 失败返回 其他值</returns>
    /// <exception cref="KXmlFileException">没有指定的图书分类</exception>
    /// <remarks>得到bookClass这个包括的图书, 但是不包括子分类的图书
    /// 图书分类没有包含图书的详细信息, 只需要得到图书的id, 通过其他方式得到图书的信息</remarks>
    int BookLibrary::GetBooksOfClass(const BookObject& bookClass, std::vector<BookObject>& books )
    {
        if(classRoot == NULL)
            return 1;
        TiXmlNode* child;
        TiXmlNode* bookItem;

        child = this->FindBookClass(classRoot->ToElement(), bookClass.GetID());
        if(NULL == child) // 没有相应的类别            
        {
            throw KXmlFileException("没有指定的图书分类!");
        }        
         
        for(bookItem  = child->FirstChild("BookItem");
            bookItem != NULL;
            bookItem  = bookItem->NextSibling("BookItem"))
        {
            const char* strID = ((TiXmlElement*)bookItem)->Attribute("id");

            if(strID == NULL)
                continue;

            Library::BookObject obj(strID);

            books.push_back(obj);
        }

        return 0;
    }
 
    /// <summary>得到某个分类的子分类</summary>
    /// <param name="bookClass">[IN]父分类</param>
    /// <param name="subs">[OUT]子分类</param>
    /// <returns>成功返回0; 失败返回 其他值</returns>
    /// <exception cref="KXmlFileException">没有指定的图书分类</exception>
    /// <remarks>得到分类的详细信息, 包括id, name, 和描述
    /// </remarks>
    int BookLibrary::GetSubsOfClass(const BookObject& bookClass, std::vector<BookClass>& subs)
    {