/*
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef RESOLVABLE_H
#define RESOLVABLE_H


#include <Referenceable.h>

#include <util/DoublyLinkedList.h>

#include "Dependency.h"


class Package;
class ResolvableFamily;
class Version;


class Resolvable : public BReferenceable,
        public DoublyLinkedListLinkImpl<Resolvable> {
public:
                                                                Resolvable(::Package* package);
        virtual                                         ~Resolvable();

                        status_t                        Init(const char* name, ::Version* version,
                                                                        ::Version* compatibleVersion);
                                                                        // version and compatibleVersion are
                                                                        // optional; object takes over ownership
                                                                        // (even in case of error)

                        ::Package*                      Package() const { return fPackage; }

                        void                            SetFamily(ResolvableFamily* family)
                                                                        { fFamily = family; }
                        ResolvableFamily*       Family() const
                                                                        { return fFamily; }

                        const String&           Name() const    { return fName; }
                        ::Version*                      Version() const { return fVersion; }
                        ::Version*                      CompatibleVersion() const
                                                                        { return fCompatibleVersion; }

                        void                            AddDependency(Dependency* dependency);
                        void                            RemoveDependency(Dependency* dependency);
                        void                            MoveDependencies(
                                                                        ResolvableDependencyList& dependencies);

private:
                        ::Package*                      fPackage;
                        ResolvableFamily*       fFamily;
                        String                          fName;
                        ::Version*                      fVersion;
                        ::Version*                      fCompatibleVersion;
                        ResolvableDependencyList fDependencies;

public: // conceptually package private
                        DoublyLinkedListLink<Resolvable> fFamilyListLink;
};


typedef DoublyLinkedList<Resolvable> ResolvableList;

typedef DoublyLinkedList<Resolvable,
        DoublyLinkedListMemberGetLink<Resolvable,
                &Resolvable::fFamilyListLink> > FamilyResolvableList;


#endif  // RESOLVABLE_H