store.h

Go to the documentation of this file.

/* -*- Mode:c++ -*- */
/*
 *  this is part of Spm
 *
 *  Copyright (c) 2008 Guillaume Chevallereau
 *
 *  This program is free software. You can redistribute it and/or modify it 
 *  under the terms of the GNU General Public License as published by the 
 *  Free Software Foundation. Either version 2 of the license or (at your 
 *  option) any later version.
 *
 *  This program is distributed in the hope that it will be usefull but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
 *  more details.
 *
 *  You should have received a copy of the GNU General Public License along 
 *  with this program; if not, write to the Free Software Foundation, Inc., 
 *  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
 */
#ifndef __STORE_H__
#define __STORE_H__

#include <boost/shared_ptr.hpp>
#include <miniXml/ustring.h>

namespace Spm
{
  namespace Util
  {
    class PropertyList;
  }
  namespace Core
  {
    class PackageManager;
    class Element;
    class Category;
    class Branch;
    class InstalledVersion;
    class Package;
    class DependencyManager;
    class Dependency;
    class Versionned;
    class RepositeryManager;
    class Repositery;
    class FileSystemManager;
    struct fileSystemElement_;

    class ElementStore
    {
    protected:
      void add (PackageManager * pSystem,
                Element * element);
      void add (Package * package,
                InstalledVersion * iv,
                PackageManager * pSystem);
      InstalledVersion * newInstalledVersion (Package * package,
                                              const miniXml::ustring & version,
                                              const miniXml::ustring & prefix);
      Package * newPackage (const miniXml::ustring & packageName);
    public:
      virtual ~ElementStore()
      {
      }
      virtual void init (PackageManager * pManager) = 0;
      virtual void store (PackageManager * pSystem) = 0;
      virtual void store (Element * element) = 0;
      virtual void store (Versionned * element) = 0;
      virtual void remove (Element * element) = 0;
      virtual void remove (Versionned * branch) = 0;
    };
    
    class CategoryStore
    {
    protected:
      void add (PackageManager * pSystem,
                const miniXml::ustring & topCategoryName,
                Category * category);
      void setCategoryUser (Category * category,
                            const miniXml::ustring & user);
    public:
      virtual ~CategoryStore()
      {
      }
      virtual void init (PackageManager * pManager) = 0;
      virtual void store (Category * category) = 0;
      virtual void store (PackageManager * pSystem) = 0;
      virtual void remove (Category * category) = 0;
    };

    class DependencyManagerStore
    {
    protected:
      void add (Dependency * dependency,
                DependencyManager * pDependencyManager,
                const boost::shared_ptr<PackageManager> & pSystem);
    public:
      virtual ~DependencyManagerStore()
      {
      }
      virtual void init (DependencyManager * pDependencyManager,
                         boost::shared_ptr<PackageManager> & pSystem) = 0;
      virtual void store (Dependency * dependency) = 0;
      virtual void store (DependencyManager * pDependencyManager) = 0;
      virtual void remove (Dependency * dependency) = 0;
    };

    class FileSystemManagerStore
    {
    protected:
      void add(const fileSystemElement_ & element,
               FileSystemManager * pFileSystemManager);
    public:
      virtual ~FileSystemManagerStore()
      {
      }
      virtual void init (FileSystemManager * pFileSystemManager) = 0;
      virtual void store (FileSystemManager * pFileSystemManager) = 0;
      virtual void store (InstalledVersion * version,
                          const miniXml::ustring & path) = 0;
      virtual void remove (InstalledVersion * version) = 0;
    };

    class RepositeryManagerStore
    {
    public:
      virtual ~RepositeryManagerStore ()
      {
      }
      virtual void init (RepositeryManager * pRepositeryManager) = 0;
      virtual void store (Repositery * repositery) = 0;
      virtual void store (RepositeryManager * pRepositeryManager) = 0;
      virtual void remove (Repositery * repositery) = 0;
    };
  }
}

#endif

---