---

document.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 "svx.h"
#include "attribute.h"
#include "Mnetwork.h"

#include "product.h"

#include "document.h"

using namespace libsvx;

static std::string NullString = "";

Document::Document():
  m_SvxInfo(NULL)
 ,m_Network(NULL)
{
}

Document::~Document()
{
  if (m_SvxInfo != NULL)
  {
    delete m_SvxInfo;
  }
  if (m_Network != NULL)
  {
    delete m_Network;
  }
}

bool Document::Parse(const std::string & SVX_buffer, const bool bAllowURLRetrieval)
{
  if (m_SvxInfo != NULL)
  {
    delete m_SvxInfo;
  }

  ::TiXmlDocument * m_XML_Document = new ::TiXmlDocument;

  if (m_XML_Document != NULL)
  {
    m_XML_Document->Parse(SVX_buffer.c_str());

    if (m_XML_Document->FirstChildElement("svx") != NULL)
    {
      m_SvxInfo = new Svx(*m_XML_Document->FirstChildElement("svx"));
    }

    delete m_XML_Document;
  }

  // now transform the XML hierarchy into a class hierarchy based on the DTD
  // sadly it's not generated automatically :(

  return true;
}

bool Document::ParseAdd(const std::string & SVX_buffer, const bool bAllowURLRetrieval)
{
  bool result = false;

  if (m_SvxInfo == NULL)
  {
    result = ParseAdd(SVX_buffer, bAllowURLRetrieval);
  }
  else
  {
    ::TiXmlDocument * m_XML_Document = new ::TiXmlDocument;

    if (m_XML_Document != NULL)
    {
      m_XML_Document->Parse(SVX_buffer.c_str());

      if (m_XML_Document->FirstChildElement("svx") != NULL)
      {
        result = m_SvxInfo->Add(*m_XML_Document->FirstChildElement("svx"));
      }

      delete m_XML_Document;
    }
  }

  return result;
}

bool Document::LoadFile(const std::string & filename, const bool bAllowURLRetrieval)
{
  FILE* fp = fopen( filename.c_str(), "r" );
  if ( fp )
  {
    unsigned size;
    fseek( fp, 0, SEEK_END );
    size = ftell( fp );
    fseek( fp, 0, SEEK_SET );

    char* buf = new char[size+1];
    char* p = buf;
    while( fgets( p, size, fp ) )
    {
      p = strchr( p, 0 );
    }
    fclose( fp );
    
    Parse( buf, bAllowURLRetrieval );
    delete [] buf;
    return true;
  }
  return false;
}

bool Document::AddFile(const std::string & filename, const bool AllowURLRetrieval)
{
  FILE* fp = fopen( filename.c_str(), "r" );
  if ( fp )
  {
    unsigned size;
    fseek( fp, 0, SEEK_END );
    size = ftell( fp );
    fseek( fp, 0, SEEK_SET );

    char* buf = new char[size+1];
    char* p = buf;
    while( fgets( p, size, fp ) )
    {
      p = strchr( p, 0 );
    }
    fclose( fp );
    
    ParseAdd( buf, AllowURLRetrieval );
    delete [] buf;
    return true;
  }
  return false;
}

bool Document::LoadURL(const std::string & Url, const bool bAllowURLRetrieval)
{
  return false;
}

bool Document::SaveFile(const std::string & filename)
{
  bool bResult = false;

  // create an XML document,
  ::TiXmlDocument * m_XML_Document = new ::TiXmlDocument;

  if (m_XML_Document != NULL)
  {
    // fill it with all the data in memory (ParseBack)
    if (ParseBack(*m_XML_Document))
    {
      // and save it
      m_XML_Document->SaveFile(filename);
    }
    delete m_XML_Document;
  }

  return bResult;
}

bool Document::ParseBack(::TiXmlDocument & m_XML_Document)
{
  bool bResult = false;
  
  if (m_SvxInfo != NULL)
  {
    m_XML_Document.InsertEndChild(m_SvxInfo->XmlElement());
    bResult = true;
  }

  return bResult;
}

void Document::UpdateProduct(const std::string & the_product_name, const bool AllowDependencyRetrieval)
{
  // find the product in the current document
  const Product * the_prod = FindProduct(the_product_name);

  if (the_prod != NULL)
  {
    // get the URL for updating
    const Attribute * update_url = the_prod->HREF();

    if (update_url != NULL)
    {
      if (m_Network == NULL)
      {
        m_Network = new MNetwork;
      }

      // retrieve the data from this URL
      m_Network->RetrieveURL(update_url->String(),NULL,0);

      // create a new document based on the content of this URL
    }
  }
}

Product * Document::FindProduct(const std::string & the_product_uid) const
{
  if (m_SvxInfo == NULL)
    return NULL;

  return m_SvxInfo->FindProduct(the_product_uid);
}

void Document::Iterate_Product_Begin()
{
  if (m_SvxInfo != NULL)
  {
    m_SvxInfo->Iterate_Product_Begin();
  }
}

bool Document::Iterate_Product_IsEnd()
{
  if (m_SvxInfo == NULL)
    return false;
  else return m_SvxInfo->Iterate_Product_IsEnd();
}

const std::string & Document::Iterate_Product_Next()
{
  if (m_SvxInfo == NULL)
    return NullString;
  else return m_SvxInfo->Iterate_Product_Next();
}

const std::string & Document::Iterate_Product_Prev()
{
  if (m_SvxInfo == NULL)
    return NullString;
  else return m_SvxInfo->Iterate_Product_Prev();
}

bool Document::IsOldProductVersion(const std::string & the_product_uid, const std::string & the_version_to_check) const
{
  const Product * the_product = FindProduct(the_product_uid);

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

const Version *Document::GetLatestProductVersion(const std::string & the_product_uid)
{
  Product * the_product = FindProduct(the_product_uid);

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

const Version * Document::FindVersion(const std::string & the_product_uid, const std::string & the_version_name) const
{
  if (m_SvxInfo == NULL)
    return NULL;

  return m_SvxInfo->FindVersion(the_product_uid, the_version_name);
}

void Document::Iterate_Version_Begin(const std::string & the_product_uid)
{
  if (m_SvxInfo != NULL)
  {
    m_SvxInfo->Iterate_Version_Begin(the_product_uid);
  }
}

bool Document::Iterate_Version_IsBegin(const std::string & the_product_uid)
{
  if (m_SvxInfo == NULL)
    return false;
  else return m_SvxInfo->Iterate_Version_IsBegin(the_product_uid);
}

bool Document::Iterate_Version_IsEnd(const std::string & the_product_uid)
{
  if (m_SvxInfo == NULL)
    return false;
  else return m_SvxInfo->Iterate_Version_IsEnd(the_product_uid);
}

const std::string & Document::Iterate_Version_Next(const std::string & the_product_uid)
{
  if (m_SvxInfo == NULL)
    return NullString;
  else return m_SvxInfo->Iterate_Version_Next(the_product_uid);
}

const std::string & Document::Iterate_Version_Prev(const std::string & the_product_uid)
{
  if (m_SvxInfo == NULL)
    return NullString;
  else return m_SvxInfo->Iterate_Version_Prev(the_product_uid);
}

---