UIDList.h

//========================================================================================
// 
// $File$
// 
// Owner: Robin_Briggs
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __UIDLIST__
#define __UIDLIST__
//#pragma export on
#include "IPMUnknown.h"

#include "K2Vector.h"
#include "UIDRef.h"
#include "PersistUtils.h"
#include "UIDListInternal.h"
#include "index_based_iterator.h"

// ==================================================================================
// * * * C L A S S U I D L i s t * * * *
// ==================================================================================
class UIDList
{
 // Traits
public:
 typedef object_type data_type;
 typedef UIDListInternal::value_type value_type;
 typedef UIDListInternal::size_type size_type;
 typedef UIDListInternal::const_reference const_reference;
 typedef UIDListInternal::reference reference;
 typedef UIDListInternal::difference_type difference_type;
 typedef UIDListInternal::pointer pointer;
 typedef UIDListInternal::const_pointer const_pointer;

private:
 friend class SortedUIDList;
 UIDListInternal * fUIDList;

public:
 // Defines iterators
 // Because of COW optimization these iterators use indexes instead of pointers.
 typedef index_based_iterator<UIDList, UIDList::value_type> iterator;
 typedef index_based_iterator<UIDList, UIDList::value_type const> const_iterator;
 typedef std::reverse_iterator<iterator> reverse_iterator;
 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

 // Constructors

 UIDList();

 explicit UIDList(IDataBase *db);

 UIDList(const UIDList &copy);

 UIDList(UIDList &&other) noexcept :
 fUIDList(other.fUIDList)
 {
 other.fUIDList = nil;
 }

 UIDList(IDataBase *db, const UID singleEntry);

 UIDList(const IPMUnknown *object);

 UIDList(const UIDRef &ref);

 ~UIDList();


 UIDList& operator=(const UIDList& other);

 UIDList& operator=(UIDList&& other) noexcept
 {
 using std::swap;
 swap(*this, other);
 return *this;
 }

 friend inline void swap(UIDList &a, UIDList &b) noexcept
 {
 std::swap(a.fUIDList, b.fUIDList);
 }

 bool16 operator==(const UIDList& other) const;

 bool16 operator!=(const UIDList& other) const;

 const_iterator begin() const
 {
 return fUIDList ? const_iterator(*this, 0) : const_iterator();
 }

 iterator begin()
 {
 // No PreModify() called here (only when dereferencing the iterator)
 return fUIDList ? iterator(*this, 0) : iterator();
 }

 const_reverse_iterator rbegin() const
 {
 return const_reverse_iterator(this->end());
 }

 reverse_iterator rbegin()
 {
 return reverse_iterator(this->end());
 }

 const_iterator end() const
 {
 return fUIDList ? const_iterator(*this, fUIDList->Length()) : const_iterator();
 }

 iterator end()
 {
 // No PreModify() called here (only when dereferencing the iterator)
 return fUIDList ? iterator(*this, fUIDList->Length()) : iterator();
 }

 const_reverse_iterator rend() const
 {
 return const_reverse_iterator(this->begin());
 }

 reverse_iterator rend()
 {
 return reverse_iterator(this->begin());
 }

 UID operator[](int32 i) const
 {
 //ASSERT(fUIDList && i > -1 && i < fUIDList->fArray.size());
 return (fUIDList && (i > -1)) ? fUIDList->fArray[i] : kInvalidUID;
 }

 // Modifier methods - allocate new fUIDListInternal if the current
 // UIDList is not the sole owner

 UID& At(int32 i);

 UID At(int32 i) const
 { return (*this)[i]; }

 void SetChunkSize(int32 chunk);

 bool16 Preallocate(int32 newlen);

 void Clear();

 void Insert(const UID t);

 void Insert(const UIDList &list, int32 before);

 void Insert(const UID t, int32 before);

 void Append(const UID t);

 void Append(const UID t, int32 after);

 void Append(const UIDList& list);

 void Remove(int32 at);

 iterator erase(iterator i);

 iterator erase(iterator first, iterator last);

 void push_back(const_reference value);

 size_type size() const
 {
 return fUIDList ? fUIDList->fArray.size() : 0;
 }

 void Replace(int32 at, const UID t);

 int32 Location(UID t) const
 {
 return fUIDList? fUIDList->Location(t) : - 1;
 }

 bool16 Contains(UID t) const
 {
 return Location(t) != -1;
 }

 bool16 DoesNotContain(UID t) const
 {
 return Location(t) == -1;
 }

 void AddRef()
 {
 if(fUIDList)
 fUIDList->AddRef();
 }

 void Release();

 // Fetch
 int32 ChunkSize() const
 {
 return fUIDList? 8 : 0; } //AW_TODO: Possibly deprecate this?

 int32 Length() const
 {
 return fUIDList? fUIDList->Length() : 0;
 }

 bool16 IsEmpty() const
 {
 return fUIDList? fUIDList->IsEmpty(): kTrue;
 }

 UID First() const;

 UID& First();

 UID Last() const;

 UID& Last();

 IDataBase *GetDataBase() const;

 UIDRef GetRef(int32 at) const;

 void ReadWriteXferObject(IPMStream* stream);

 void ReadWriteXferReference(IPMStream* stream);

private:
 // Iterators need access to the private methods.
 friend class index_based_iterator<UIDList, UIDList::value_type>;
 friend class index_based_iterator<UIDList, UIDList::value_type const>;

 void PreModify();

 void Replicate();

 enum EXferType { eXferObject, eXferReference };
 void ReadWrite(IPMStream* s, const EXferType xfer);

 const_reference get_const_ref(difference_type pos) const
 {
 ASSERT(fUIDList);
 return fUIDList->operator[](pos);
 }

 reference get_ref(difference_type pos)
 {
 // If a copy of the container occurs between two calls to this operator
 // we will be modifying shared data (because of the COW optimization)
 // so we have to call PreModify() every time;
 PreModify();
 return fUIDList->operator[](pos);
 }

#ifdef DEBUG

 bool IsValidIterator(const_iterator const& it) const
 {
 // Checks if the iterator is from this container (uidlist) and within legal range
 return ((it.get_container() == this) && it.is_valid());
 }
#endif
} ;

//L1 and L2 have items common to both removed from each (and as a side effect, items are sorted and distinct)
 void Disjoin( UIDList& L1, UIDList& L2);

//L1 receives the union of the two and L2 receives the intersection (and as a side effect, items are sorted and distinct)
 void Join( UIDList& L1, UIDList& L2);

//L1 receives L1\L2 and L2 receives the intersection (and as a side effect, items are sorted and distinct)
//That is, after the call to Difference, L1 has members _also_ in L2 removed, and L2 has members _not_ in L1 removed.
 void Difference( UIDList& L1, UIDList& L2);

/*
// Arithmetical operators
inline UIDList::difference_type operator-(const_iterator const& lhs, const_iterator const& rhs)
{
 return lhs.base() - rhs.base();
}

inline UIDList::iterator operator+(UIDList::difference_type offset, iterator const& rhs)
{
 return (rhs + offset);
}

inline UIDList::const_iterator operator+(UIDList::difference_type offset, const_iterator const& rhs)
{
 return (rhs + offset);
}

// Comparison operators
inline bool operator==(UIDList::const_iterator const& lhs, UIDList::const_iterator const& rhs)
{
 return (lhs.compare(rhs) == 0);
}

inline bool operator!=(UIDList::const_iterator const& lhs, UIDList::const_iterator const& rhs)
{
 return !(lhs == rhs);
}

inline bool operator<(UIDList::const_iterator const& lhs, UIDList::const_iterator const& rhs)
{
 return (lhs.compare(rhs) < 0);
}

inline bool operator>(UIDList::const_iterator const& lhs, UIDList::const_iterator const& rhs)
{
 return rhs < lhs;
}

inline bool operator<=(UIDList::const_iterator const& lhs, UIDList::const_iterator const& rhs)
{
 return !(rhs < lhs);
}

inline bool operator>=(UIDList::const_iterator const& lhs, UIDList::const_iterator const& rhs)
{
 return !(lhs < rhs);
}
*/
//#pragma export off

#endif // __UIDLIST__