packagedep.cpp

00001 
00002 // Name:        packagedep.cpp
00003 // Purpose:     wxPackageDependency, wxPackageDependencyArray
00004 // Author:      Francesco Montorsi
00005 // Modified by:
00006 // Created:     2006-06-29
00007 // RCS-ID:      $Id: packagedep.cpp,v 1.1.1.1 2006/12/12 09:39:35 frm Exp $
00008 // Copyright:   (c) Francesco Montorsi
00009 // Licence:     wxWidgets licence
00011 
00012 
00013 // For compilers that support precompilation, includes "wx/wx.h".
00014 #include "wx/wxprec.h"
00015 
00016 #ifdef __BORLANDC__
00017 #pragma hdrstop
00018 #endif
00019 
00020 #ifndef WX_PRECOMP
00021     #include "wx/wx.h"
00022 #endif
00023 
00024 // includes
00025 #include <wx/fileconf.h>
00026 
00027 #include "wxp/packagedep.h"
00028 #include "wxp/packagecmd.h"
00029 #include "wxp/package.h"
00030 
00031 // definitions
00032 
00033 wxString wxPackageDependencyTypeName[] =
00034 {
00035     _T("Required"),
00036     _T("Suggested"),
00037     _T("RequiredButNotPackaged")
00038 };
00039 
00040 // RTTI
00041 IMPLEMENT_DYNAMIC_CLASS(wxPackageDependency, wxObject)
00042 
00043 
00044 
00045 // wx array implementations
00046 #include <wx/arrimpl.cpp> // this is a magic incantation which must be done!
00047 WX_DEFINE_OBJARRAY(wxPackageDependencyArrayHelper);
00048 
00049 
00050 wxPackageDependency wxEmptyPackageDependency;
00051 wxPackageDependencyArray wxEmptyPackageDependencyArray;
00052 
00053 
00054 
00055 // ----------------------------------------------------------------------------
00056 // string2enum helpers
00057 // ----------------------------------------------------------------------------
00058 
00059 wxIMPLEMENT_STRING2ENUM(PackageDependencyType, wxPDT_MAX)
00060 
00061 
00062 
00063 // ----------------------------------------------------------------------------
00064 // wxPackageDependency
00065 // ----------------------------------------------------------------------------
00066 
00067 bool wxPackageDependency::IsSatisfiedBy(const wxPackageId &pkg) const
00068 {
00069     // do this check regardless of the type of dependency represented
00070     // by this object: be it required, suggested or even required but
00071     // not packaged (in this last case it could still be successful
00072     // because e.g. the package which represents that dependency could
00073     // have been created since the creation of pkg)...
00074 
00075     if (m_strName.CmpNoCase(pkg.GetName()) != 0)
00076         return false;
00077 
00078     // check version
00079     if (!m_version.Contains(pkg.GetVersion()))
00080         return false;
00081 
00082     return true;
00083 }
00084 
00085 bool wxPackageDependency::IsSatisfiedByOneOf(const wxPackageArray &arr) const
00086 {
00087     for (size_t i=0; i<arr.GetCount(); i++)
00088         if (IsSatisfiedBy(arr[i]))
00089             return true;
00090     return false;
00091 }
00092 
00093 int wxPackageDependency::GetBestMatch(const wxPackageArray &arr) const
00094 {
00095     int best = wxNOT_FOUND;
00096     wxVersion bestdiff(9,9,9);
00097 
00098     for (size_t i=0; i < arr.GetCount(); i++)
00099     {
00100         if (IsSatisfiedBy(arr[i]) &&
00101             (best == wxNOT_FOUND || arr[i].GetVersion() > arr[best].GetVersion()))
00102         {
00103             // this package has a more recent version
00104             best = i;
00105 
00106             // FIXME: add a break here if the array is surely not
00107             // containing any duplicate package
00108         }
00109     }
00110 
00111     return best;
00112 }
00113 
00114 bool wxPackageDependency::DoGetRecursiveDependencies(wxPackageDependencyArray *ret, const wxPackageArray &arr,
00115         wxPackageDependencyType type, wxPackageDependencyArray *notfound, wxPackageIdArray *alreadyprocessed) const
00116 {
00117     wxASSERT(type == wxPDT_INVALID || type == m_nType);
00118 
00119     int n = GetBestMatch(arr);
00120     if (n == wxNOT_FOUND)
00121     {
00122         if (notfound)
00123         {
00124             // do not add duplicates !
00125             if (!notfound->Contains(*this))
00126                 notfound->Add(*this);
00127         }
00128 
00129         return false;
00130     }
00131 
00132     // NB: the check on alreadyprocessed is done by wxPackage::GetRecursiveDependency
00133     return arr[n].DoGetRecursiveDependencies(ret, arr, type, notfound, alreadyprocessed);
00134 }
00135 
00136 
00137 
00138 // ----------------------------------------------------------------------------
00139 // wxPackageDependencyArray
00140 // ----------------------------------------------------------------------------
00141 
00142 wxPackageDependencyArray wxPackageDependencyArray::GetDependenciesOfType(wxPackageDependencyType t) const
00143 {
00144     wxPackageDependencyArray ret;
00145     for (size_t i=0; i<GetCount(); i++)
00146         if (Item(i).GetType() == t)
00147             ret.Add(Item(i));
00148     return ret;
00149 }
00150 
00151 wxPackageDependencyArray wxPackageDependencyArray::GetDependenciesNotAvailableIn(const wxPackageArray &arr) const
00152 {
00153     wxPackageDependencyArray ret(*this);
00154     for (size_t i=0; i<ret.GetCount(); i++)
00155     {
00156         if (ret[i].IsSatisfiedByOneOf(arr))
00157         {
00158             // this dependency can be satisfied using the given array of
00159             // packages... just remove it then
00160             ret.RemoveAt(i);
00161             i--;
00162         }
00163     }
00164 
00165     return ret;
00166 }
00167 
00168 wxPackageDependencyArray wxPackageDependencyArray::GetDependenciesAvailableIn(const wxPackageArray &arr) const
00169 {
00170     wxPackageDependencyArray ret(*this);
00171     for (size_t i=0; i<ret.GetCount(); i++)
00172     {
00173         if (!ret[i].IsSatisfiedByOneOf(arr))
00174         {
00175             // this dependency cannot be satisfied using the given array of
00176             // packages... just remove it then
00177             ret.RemoveAt(i);
00178             i--;
00179         }
00180     }
00181 
00182     return ret;
00183 }
00184 
00185 wxPackageDependencyArray wxPackageDependencyArray::GetConflictingDependencies() const
00186 {
00187     wxPackageDependencyArray ret;
00188 
00189     for (size_t i=0; i<GetCount(); i++)
00190     {
00191         for (size_t n=i; n<GetCount(); n++)
00192         {
00193             if (Item(i).IsPartiallySatisfiedBy(Item(n).GetName()))
00194             {
00195                 // we have two dependencies with the same name...
00196                 // let's check if it's possible to satisfy both of them
00197                 // contemporaneously:
00198 
00199                 if (Item(i).GetVersion().OverlapsWith(Item(n).GetVersion()))
00200                     continue;       // yes; these are not "conflicting"
00201 
00202                 // if the two version ranges do not overlap, it's impossible
00203                 // to satisfy both these dependencies thus they are conflicting!
00204                 ret.Add(Item(i));
00205                 ret.Add(Item(n));
00206             }
00207         }
00208     }
00209 
00210     return ret;
00211 }
00212 
00213 bool wxPackageDependencyArray::DoGetRecursiveDependencies(wxPackageDependencyArray *ret, const wxPackageArray &arr,
00214         wxPackageDependencyType type, wxPackageDependencyArray *notfound, wxPackageIdArray *alreadyprocessed) const
00215 {
00216     bool success = true;
00217     for (size_t i=0; i<GetCount(); i++)
00218     {
00219         // expand recursively the dependencies for our i-th dependency
00220         if (type == wxPDT_INVALID || type == Item(i).GetType())
00221             success &= Item(i).DoGetRecursiveDependencies(ret, arr, type,
00222                                                           notfound, alreadyprocessed);
00223     }
00224 
00225     return success;
00226 }
00227 

Generated on Thu Feb 1 22:14:31 2007 for wxWidgets Package Manager by  doxygen 1.5.1-p1