---

element_downloadable.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 Mirrors
Version 1.0 (the "Mirrors"); you may not use this file in any way except
in compliance with the Mirrors. You should have received a copy of the
Mirrors with this source; see <file or member name>. You may also obtain
a copy of the Mirrors 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 Mirrors is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the Mirrors for
the specific language governing rights and limitations under the Mirrors.

Definitions required by the Mirrors:
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 "mirrors.h"
#include "url.h"

#include "element_downloadable.h"

using namespace libsvx;

ElementDownloadable::ElementDownloadable(TiXmlElement & Element, const std::string the_name)
 :ElementGeneric(Element,the_name)
{
  //elements
  m_List_Mirrors.clear();
  TiXmlElement * txIterator = Element.FirstChildElement("mirrors");

  while (txIterator != NULL)
  {
    Mirrors * tmpText = new Mirrors(*txIterator);
    m_List_Mirrors.push_back(tmpText);
    txIterator = txIterator->NextSiblingElement("mirrors");
  }
}

ElementDownloadable::ElementDownloadable(const ElementDownloadable & a_element)
 :ElementGeneric(a_element)
{
  for (size_t i = 0; i < a_element.m_List_Mirrors.size();i++)
  {
    Mirrors * tmpText = new Mirrors(a_element.m_List_Mirrors[i]);
    m_List_Mirrors.push_back(tmpText);
  }
}

ElementDownloadable::~ElementDownloadable()
{
/* done automatically
  while (m_List_Mirrors.size() != 0)
  {
    Mirrors * tmp = m_List_Mirrors.front();
    m_List_Mirrors.pop_front();
    delete tmp;
  }
*/
}

bool ElementDownloadable::IsValid() const
{
  return true;
}


void ElementDownloadable::XmlElement(TiXmlElement & the_element_to_fill)
{
  for (size_t i = 0; i < m_List_Mirrors.size();i++)
  {
    the_element_to_fill.InsertEndChild(m_List_Mirrors[i].XmlElement());
  }
}

Mirrors * ElementDownloadable::FindMirrors(const Mirrors & the_item) const
{
  size_t current_version = 0;

  while (current_version < m_List_Mirrors.size() &&
       m_List_Mirrors[current_version] != the_item)
  {
    current_version++;
  }

  if (current_version < m_List_Mirrors.size())
    return &m_List_Mirrors[current_version];
  else
    return NULL;
}

ElementDownloadable & ElementDownloadable::operator+=(const ElementDownloadable & the_object_to_add)
{
  assert(IsValid());

  if (the_object_to_add.IsValid())
  {
    // hierarchy classes
    *static_cast<ElementGeneric*>(this) += the_object_to_add;

    // lists
    size_t i = 0;
    Mirrors * tmpFoundMirrors;
    while (i < the_object_to_add.m_List_Mirrors.size())
    {
      tmpFoundMirrors = FindMirrors(the_object_to_add.m_List_Mirrors[i]);
      if (tmpFoundMirrors == NULL)
      {
        // add this version to the list
        Mirrors * tmpMirrors = new Mirrors(the_object_to_add.m_List_Mirrors[i]);
        m_List_Mirrors.push_back(tmpMirrors);
      }
      else
      {
        // merge the same versions
        *tmpFoundMirrors += the_object_to_add.m_List_Mirrors[i];
      }

      i++;
    }
  }

  return *this;
}

bool ElementDownloadable::operator!=(const ElementDownloadable & the_object_to_compare) const
{
  bool result = !(IsValid() && the_object_to_compare.IsValid());

  result = result || (static_cast<const ElementGeneric &>(*this) != the_object_to_compare);

  return result;
}

---