---

svx.cxx

Go to the documentation of this file.

/******************************************************************************

                           Copyright Notice.

               Licensed material - Property of Steve Lhomme

This source file is part of Steve Lhomme's libSVX.
(C) Copyright Steve Lhomme, France, 2001-2002.
All rights reserved. Modifications (C) copyrighted by their respective
contributors, all rights reserved.

The contents of this file are subject to the Bixoft Public License
Version 1.0 (the "License"); you may not use this file in any way except
in compliance with the License. You should have received a copy of the
License with this source; see <file or member name>. You may also obtain
a copy of the License at http://www.bixoft.nl/english/license.htm
or http://mukoli.free.fr/BXAPL/

ANY USE OF THE SOFTWARE CONSTITUTES ACCEPTANCE OF THE LICENSE.

Anything distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
the specific language governing rights and limitations under the License.

Definitions required by the License:
Copyright Holder: Steve Lhomme, France
          e-mail: steve.lhomme@free.fr
Country: France, i.e. the laws of France apply.
Court  : ????
Programming Tool status: This source is not a Programming Tool.

Contributor(s):                      Contribution:

******************************************************************************/

#include "../tinyxml/tinyxml.h"

#include "attribute.h"
#include "product.h"

#include "svx.h"

using namespace libsvx;

static std::string NullString = "";

Svx::Svx(TiXmlElement & a_Element)
 :Element(a_Element,"svx")
 ,m_A_href(NULL)
 ,m_A_version(NULL)
{
  assert(a_Element.Value().compare("svx") == 0);
  Add(a_Element);
}

Svx::~Svx()
{
  if (m_A_href != NULL)
    delete m_A_href;
  if (m_A_version != NULL)
    delete m_A_version;
/* done automatically
  while (m_List_Product.size() != 0)
  {
    Product * tmp = m_List_Product.front();
    m_List_Product.pop_front();
    delete tmp;
  }
*/
}

bool Svx::Add(TiXmlElement & Element)
{
  bool result = true;

  assert(Element.Value().compare("svx") == 0);

  if (m_A_version != NULL && Element.Attribute("version") != NULL)
  {
    // should be "1.0"
    result = (m_A_version->String().compare(*Element.Attribute("version")) == 0);
  }

  if (result)
  {
    // override the URL
    if (Element.Attribute("href") != NULL)
    {
      if (m_A_href != NULL)
        delete m_A_href;
      
      m_A_href = new Attribute(*Element.Attribute("href"),"href");
    }

    // treat all the child Elements and chain them
    TiXmlElement * txIterator = Element.FirstChildElement("product");

    while (txIterator != NULL)
    {
      Product * tmpNewText = new Product(*txIterator);

      Product * tmpFound = FindProduct(tmpNewText->UID()->String());
      if (tmpFound == NULL)
      {
        // this is a new product, add it to the list
        m_List_Product.push_back(tmpNewText);
      }
      else
      {
        // this is a known product, merge the content with the old one
        *tmpFound += *tmpNewText;
        delete tmpNewText;
      }
      
      txIterator = txIterator->NextSiblingElement("product");
    }
  }

  return result;
}

bool Svx::IsValid() const
{
  return (m_List_Product.size() > 0 && m_A_version != NULL && m_A_version->String().compare("1.0") == 0);
}

TiXmlElement & Svx::XmlElement()
{
  assert(m_Node != NULL);

  if (m_A_href != NULL)
    m_A_href->XmlElement(*m_Node);

  if (m_A_version != NULL)
    m_A_version->XmlElement(*m_Node);

  for (size_t i = 0; i < m_List_Product.size();i++)
  {
    m_Node->InsertEndChild(m_List_Product[i].XmlElement());
  }
  
  return *m_Node;
}

Product * Svx::FindProduct(const std::string & the_product_uid) const
{
  size_t current_product = 0;

  while (current_product < m_List_Product.size() &&
       m_List_Product[current_product].UID() != NULL &&
       m_List_Product[current_product].UID()->String().compare(the_product_uid) != 0)
  {
    current_product++;
  }

  if (current_product < m_List_Product.size())
    return &m_List_Product[current_product];
  else
    return NULL;
}

void Svx::Iterate_Product_Begin()
{
  m_Iterator_Product = 0;
}

bool Svx::Iterate_Product_IsEnd()
{
  return (m_Iterator_Product == m_List_Product.size()-1);
}

const std::string & Svx::Iterate_Product_Next()
{
  return m_List_Product[m_Iterator_Product++].UID()->String();
}

const std::string & Svx::Iterate_Product_Prev()
{
  return m_List_Product[m_Iterator_Product--].UID()->String();
}

Version * Svx::FindVersion(const std::string & the_product_uid, const std::string & the_version_name)
{
  Product * the_product = FindProduct(the_product_uid);

  if (the_product == NULL)
    return NULL;
  else return the_product->FindVersion(the_version_name);
}

void Svx::Iterate_Version_Begin(const std::string & the_product_uid)
{
  Product * the_product = FindProduct(the_product_uid);

  if (the_product != NULL)
    the_product->Iterate_Version_Begin();
}

bool Svx::Iterate_Version_IsBegin(const std::string & the_product_uid)
{
  Product * the_product = FindProduct(the_product_uid);

  if (the_product == NULL)
    return false;
  else
    return the_product->Iterate_Version_IsBegin();
}

bool Svx::Iterate_Version_IsEnd(const std::string & the_product_uid)
{
  Product * the_product = FindProduct(the_product_uid);

  if (the_product == NULL)
    return false;
  else
    return the_product->Iterate_Version_IsEnd();
}

const std::string & Svx::Iterate_Version_Next(const std::string & the_product_uid)
{
  Product * the_product = FindProduct(the_product_uid);

  if (the_product == NULL)
    return NullString;
  else
    return the_product->Iterate_Version_Next();
}

const std::string & Svx::Iterate_Version_Prev(const std::string & the_product_uid)
{
  Product * the_product = FindProduct(the_product_uid);

  if (the_product == NULL)
    return NullString;
  else
    return the_product->Iterate_Version_Prev();
}

---