branch.h

Go to the documentation of this file.

/* -*- Mode: c++ -*- */
/*
 *  this is part of Spm
 *
 *  Copyright (c) 2005-2007 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 __BRANCH_H__ 
#define __BRANCH_H__
#include <string>
#include <map>
#include <list>
#include "coreException.h"
#include <util/utilException.h>
#include <plugin/installerInterface.h>
#include <algorithm>
#include <boost/thread.hpp>
#include <boost/filesystem/path.hpp>
#include <util/object.h>

namespace Spm
{
  namespace Core
  {
    const std::string BRANCH_NODE_ELEMENTS = "elementList";
    const std::string BRANCH_NODE_ELEMENT = "element";
    const std::string BRANCH_ATTRIBUTE_BRANCH = "branch";
    const std::string BRANCH_ATTRIBUTE_ELEMENT = "element";
    const std::string BRANCH_LIST_FILES = "branchFile";
    class Element;

    class Branch : public Util::Object
    {
      friend class PackageSystem;
      friend class Element;
      friend class Store;
      
    private:
      std::string major;
      std::string minor;
      std::string actualVersion;
      boost::filesystem::path __prefix;
      std::string cflags;

      std::string branchURL;
      std::string owner;
      mutable unsigned long size;
      std::map <std::string,
                std::string> extraInformation;
      mutable std::list<boost::filesystem::path> __files;
      std::list<Branch *> elements;
      Element * element;

      void loadFileList () const;
      void loadFileList ();
      bool removeFiles ();
      bool uninstall () const;
    public:
      static std::string getBranchName (const std::string major,
                                        const std::string minor,
                                        const std::string micro);
      Branch ()
      { 
        element = NULL;
      }

      Branch(const Branch &)
      {
      }

      Branch (Element * aElement)
        throw (Util::NullPointerException);

      Branch (const std::string & aVersion,
              Element * aElement)
        throw (Util::NullPointerException,
               BadNameException);

      Branch (const std::string & aMajor, 
              const std::string & aMinor, 
              const std::string & extraVersion,
              Element * aElement);

      ~Branch ();

      void setActual (const std::string & actual);
      void setMinor (const std::string & aMinor);

      void setMajor (const std::string & aMajor);
      
      std::string getName ();

      const std::string getMajor ();

      const std::string getMinor ();

      const std::string getActualVersion ();

      const std::string getMajor () const;
      const std::string getMinor () const;
      const std::string getActualVersion () const;

      std::string getName () const;
      
      void setPrefix (const boost::filesystem::path & prefix);
      
      void setFlags (const std::string & flags);

      const boost::filesystem::path & getPrefix ();
      const boost::filesystem::path & getPrefix () const;
      
      const std::string & getFlags ();
      const std::string & getFlags () const;

      void setUrl (const std::string & url);

      const std::string & getUrl ();
      const std::string & getUrl () const;

      const std::map<std::string,
                     std::string> & getExtraInformations ();
      const std::map<std::string,
                     std::string> & getExtraInformations () const;

      const std::string & getExtraInformation (const std::string & key)
        throw (UnknownKeyException);
      const std::string & getExtraInformation (const std::string & key) const
        throw (UnknownKeyException);

      void addExtraInformation(const std::string & key,
                               const std::string & val)
        throw (AlreadyExistingKeyException);
      void removeExtraInformation (const std::string & key)
        throw (UnknownKeyException);
      void setExtraInformation (const std::map<std::string,
                                std::string> & extra);
      void setExtraInformation (const std::string & key,
                                const std::string & val)
        throw (UnknownKeyException);
      const std::string & getOwner ();

      const std::string & getOwner () const;
      
      void setOwner (const std::string & aUser);

      bool queryForFile (const boost::filesystem::path & file) const;

      void setFiles (const std::list<boost::filesystem::path> & branchFiles);

      const std::list<boost::filesystem::path> & getFiles ();

      void setSize (unsigned long size);

      const unsigned long & getSize ();
      const unsigned long & getSize () const;

      void addElement (const Branch * branchOfElement);

      void delElement (const std::string & elementName);

      const std::list<Branch *> & getElements ();
      const std::list<Branch *> & getElements () const;

      const Branch * getElement (const std::string & elementName)
        throw (UnknownElementException);
      
      const Element * getElement ();

      const Element * getElement () const;

      bool operator< (const Branch & b) const;

      bool operator< (const std::string & branchVersion);
      bool operator== (const std::string & branchVersion);
      bool operator== (const Branch & otherBranch) const;
    };

    typedef struct equalBranchOfElement : public std::binary_function<Branch *, std::string, bool>
    {
      bool operator() (Branch * branch,
                       const std::string & elementName) const;
    };

    typedef struct fileIsInBranch : public std::binary_function<boost::filesystem::path, boost::filesystem::path, bool>
    {
      bool operator() (const boost::filesystem::path & file,
                       const boost::filesystem::path & searchedFile) const;
    };
  }
}
#endif

---