---

package.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 "activation.h"
#include "license.h"
#include "mirrors.h"
#include "verification.h"

#include "package.h"

using namespace libsvx;

Package::Package(TiXmlElement & Element)
 :ElementText(Element,"package")
 ,ElementLicense(Element,"package")
 ,ElementDownloadable(Element,"package")
 ,m_Verification(NULL)
 ,m_A_size(NULL)
 ,m_A_type(NULL)
 ,m_A_os(NULL)
 ,m_A_cpu(NULL)
 ,m_A_lang(NULL)
{
  assert(Element.Value().compare("package") == 0);

  // attributes
  if (Element.Attribute("size") != NULL)
  {
    m_A_size = new Attribute(*Element.Attribute("size"),"size");
  }

  if (Element.Attribute("type") != NULL)
  {
    m_A_type = new Attribute(*Element.Attribute("type"),"type");
  }

  if (Element.Attribute("os") != NULL)
  {
    m_A_os = new Attribute(*Element.Attribute("os"),"os");
  }
  else
  {
    m_A_os = new Attribute("win32","os");
  }

  if (Element.Attribute("cpu") != NULL)
  {
    m_A_cpu = new Attribute(*Element.Attribute("cpu"),"cpu");
  }
  else
  {
    m_A_cpu = new Attribute("x86","cpu");
  }

  if (Element.Attribute("lang") != NULL)
  {
    m_A_lang = new Attribute(*Element.Attribute("lang"),"lang");
  }
  else
  {
    m_A_lang = new Attribute("en","lang");
  }

  // elements
  if (Element.FirstChildElement("verification") != NULL)
  {
    m_Verification = new Verification(*Element.FirstChildElement("verification"));
  }

  TiXmlElement * txIterator;
  
  m_List_Activation.clear();
  txIterator = Element.FirstChildElement("activation");
  while (txIterator != NULL)
  {
    Activation * tmpText = new Activation(*txIterator);
    m_List_Activation.push_back(tmpText);
    txIterator = txIterator->NextSiblingElement("activation");
  }
}

Package::Package(const Package & a_package)
 :ElementText(a_package)
 ,ElementLicense(a_package)
 ,ElementDownloadable(a_package)
{
  m_Verification = a_package.m_Verification;
  if (a_package.m_A_size != NULL)
    m_A_size = new Attribute(*a_package.m_A_size);
  else
    m_A_size = a_package.m_A_size;

  if (a_package.m_A_type != NULL)
    m_A_type = new Attribute(*a_package.m_A_type);
  else
    m_A_type = a_package.m_A_type;

  if (a_package.m_A_os != NULL)
    m_A_os = new Attribute(*a_package.m_A_os);
  else
    m_A_os = a_package.m_A_os;

  if (a_package.m_A_cpu != NULL)
    m_A_cpu = new Attribute(*a_package.m_A_cpu);
  else
    m_A_cpu = a_package.m_A_cpu;

  if (a_package.m_A_lang != NULL)
    m_A_lang = new Attribute(*a_package.m_A_lang);
  else
    m_A_lang = a_package.m_A_lang;

  for (size_t i = 0; i < a_package.m_List_Activation.size();i++)
  {
    Activation * tmpText = new Activation(a_package.m_List_Activation[i]);
    m_List_Activation.push_back(tmpText);
  }
}

Package::~Package()
{
  if (m_Verification != NULL)
    delete m_Verification;
  if (m_A_size != NULL)
    delete m_A_size;
  if (m_A_type != NULL)
    delete m_A_type;
  if (m_A_os != NULL)
    delete m_A_os;
  if (m_A_cpu != NULL)
    delete m_A_cpu;
  if (m_A_lang != NULL)
    delete m_A_lang;
/* done automatically
  while (m_List_Activation.size() != 0)
  {
    Activation * tmp = m_List_Activation.front();
    m_List_Activation.pop_front();
    delete tmp;
  }
*/
}

bool Package::IsValid() const
{
  return (m_List_Activation.size() > 0 && m_List_Mirrors.size() > 0 &&
    m_A_type != NULL &&
    (m_A_type->String().compare("binary") == 0 || m_A_type->String().compare("source") == 0) && 
    (m_A_os == NULL || m_A_os->String().compare("win32") == 0 ||
                       m_A_os->String().compare("win95") == 0 ||
                       m_A_os->String().compare("winNT") == 0 ||
                       m_A_os->String().compare("win2K") == 0 ||
                       m_A_os->String().compare("winXP") == 0 ||
                       m_A_os->String().compare("Linux") == 0 ||
                       m_A_os->String().compare("MacOS") == 0 ||
                       m_A_os->String().compare("MacOSX") == 0 ||
                       m_A_os->String().compare("DOS") == 0 ||
                       m_A_os->String().compare("BSD") == 0 ||
                       m_A_os->String().compare("OS2") == 0 ||
                       m_A_os->String().compare("Solaris") == 0 ||
                       m_A_os->String().compare("SunOS") == 0 ||
                       m_A_os->String().compare("none") == 0) && 
    (m_A_cpu == NULL || m_A_cpu->String().compare("x86") == 0 ||
                        m_A_cpu->String().compare("IA64") == 0 ||
                        m_A_cpu->String().compare("AMD64") == 0 ||
                        m_A_cpu->String().compare("mips") == 0 ||
                        m_A_cpu->String().compare("alpha") == 0 ||
                        m_A_cpu->String().compare("ppc") == 0 ||
                        m_A_cpu->String().compare("sparc") == 0 ||
                        m_A_cpu->String().compare("680x0") == 0 ||
                        m_A_cpu->String().compare("none") == 0)
    );
}

TiXmlElement & Package::XmlElement()
{
  TiXmlElement * a_Node = ElementText::m_Node;

  ElementText::XmlElement(*a_Node);
  ElementLicense::XmlElement(*a_Node);
  ElementDownloadable::XmlElement(*a_Node);

  if (m_A_size != NULL)
    m_A_size->XmlElement(*a_Node);

  if (m_A_type != NULL)
    m_A_type->XmlElement(*a_Node);

  if (m_A_os != NULL)
    m_A_os->XmlElement(*a_Node);

  if (m_A_cpu != NULL)
    m_A_cpu->XmlElement(*a_Node);

  if (m_A_lang != NULL)
    m_A_lang->XmlElement(*a_Node);

  if (m_Verification != NULL)
    a_Node->InsertEndChild(m_Verification->XmlElement());

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

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

  // any of the following cases should never happen

  result = result || (static_cast<const ElementDownloadable&>(*this) != the_object_to_compare);
  result = result || (static_cast<const ElementText&>(*this) != the_object_to_compare);
  result = result || (static_cast<const ElementLicense&>(*this) != the_object_to_compare);
  
  if (!result)
  {
    if (m_A_size != NULL && the_object_to_compare.m_A_size != NULL)
      result = result || (*m_A_size != *the_object_to_compare.m_A_size);

    if (m_A_type != NULL && the_object_to_compare.m_A_type != NULL)
      result = result || (*m_A_type != *the_object_to_compare.m_A_type);
    
    if (m_A_os != NULL && the_object_to_compare.m_A_os != NULL)
      result = result || (*m_A_os != *the_object_to_compare.m_A_os);

    if (m_A_cpu != NULL && the_object_to_compare.m_A_cpu != NULL)
      result = result || (*m_A_cpu != *the_object_to_compare.m_A_cpu);

    if (m_A_lang != NULL && the_object_to_compare.m_A_lang != NULL)
      result = result || (*m_A_lang != *the_object_to_compare.m_A_lang);
    
    if (m_Verification != NULL && the_object_to_compare.m_Verification != NULL)
      result = result || (*m_Verification != *the_object_to_compare.m_Verification);
  }
  
  return result;
}

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

  if (the_object_to_add.IsValid())
  {
    static_cast<ElementText&>(*this) += the_object_to_add;
    static_cast<ElementLicense&>(*this) += the_object_to_add;
    static_cast<ElementDownloadable&>(*this) += the_object_to_add;

    // attributes
    if (the_object_to_add.m_Verification != NULL)
    {
      if (m_Verification == NULL)
      {
        delete m_Verification;
      }
      m_Verification = new Verification(*the_object_to_add.m_Verification);
    }
    
    if (the_object_to_add.m_A_size != NULL)
    {
      if (m_A_size == NULL)
      {
        delete m_A_size;
      }
      m_A_size = new Attribute(*the_object_to_add.m_A_size);
    }

    if (the_object_to_add.m_A_type != NULL)
    {
      if (m_A_type == NULL)
      {
        delete m_A_type;
      }
      m_A_type = new Attribute(*the_object_to_add.m_A_type);
    }

    if (the_object_to_add.m_A_os != NULL)
    {
      if (m_A_os == NULL)
      {
        delete m_A_os;
      }
      m_A_os = new Attribute(*the_object_to_add.m_A_os);
    }

    if (the_object_to_add.m_A_cpu != NULL)
    {
      if (m_A_cpu == NULL)
      {
        delete m_A_cpu;
      }
      m_A_cpu = new Attribute(*the_object_to_add.m_A_cpu);
    }
    
    if (the_object_to_add.m_A_lang != NULL)
    {
      if (m_A_lang == NULL)
      {
        delete m_A_lang;
      }
      m_A_lang = new Attribute(*the_object_to_add.m_A_lang);
    }
  }

  return *this;
}

---