prj/cam/src/object/propmix.cpp

   1 /*
   2 @Copyright Looking Glass Studios, Inc.
   3 1996,1997,1998,1999,2000 Unpublished Work.
   4 */
   5
   6 // $Header: r:/t2repos/thief2/src/object/propmix.cpp,v 1.7 1998/10/05 17:27:15 mahk Exp $
   7
   8 #include <propmix.h>
   9 #include <propbase.h>
  10
  11 // Must be last header
  12 #include <dbmem.h>
  13
  14
  15 cMixedPropertyStore::cMixedPropertyStore(IPropertyStore* abstract, IPropertyStore* concrete)
  16 {
  17    abstract->AddRef();
  18    concrete->AddRef();
  19    mStores[kAbstract] = abstract;
  20    mStores[kConcrete] = concrete;
  21    IDataOps* ops = concrete->GetOps();
  22    if (ops)
  23    {
  24       abstract->SetOps(ops);
  25       SafeRelease(ops);
  26    }
  27 }
  28
  29 cMixedPropertyStore::~cMixedPropertyStore()
  30 {
  31    SafeRelease(mStores[kAbstract]);
  32    SafeRelease(mStores[kConcrete]);
  33 }
  34
  35 //
  36 // METHODS
  37 //
  38
  39 STDMETHODIMP_(const sPropertyStoreDesc*) cMixedPropertyStore::Describe() const
  40 {
  41    static sPropertyStoreDesc desc = { "Hybrid implementation" };
  42    return &desc;
  43
  44 }
  45
  46 STDMETHODIMP cMixedPropertyStore::SetID(PropertyID id)
  47 {
  48    mStores[kAbstract]->SetID(id);
  49    mStores[kConcrete]->SetID(id);
  50    return S_OK;
  51 }
  52
  53 STDMETHODIMP_(sDatum) cMixedPropertyStore::Create(ObjID obj)
  54 {
  55    return Store(obj)->Create(obj);
  56 }
  57
  58 STDMETHODIMP cMixedPropertyStore::Delete(ObjID obj)
  59 {
  60    return Store(obj)->Delete(obj);
  61 }
  62
  63 STDMETHODIMP_(BOOL) cMixedPropertyStore::Relevant(ObjID obj) const
  64 {
  65    return Store(obj)->Relevant(obj);
  66 }
  67
  68 STDMETHODIMP_(BOOL) cMixedPropertyStore::Get(ObjID obj, sDatum* pdat) const
  69 {
  70    return Store(obj)->Get(obj,pdat);
  71 }
  72
  73 STDMETHODIMP cMixedPropertyStore::Set(ObjID obj, sDatum val)
  74 {
  75    return Store(obj)->Set(obj,val);
  76 }
  77
  78 STDMETHODIMP_(sDatum) cMixedPropertyStore::Copy(ObjID targ, ObjID src)
  79 {
  80    // could copy across stores, so have to do it stupidly
  81    sDatum dat;
  82    if (Get(src,&dat))
  83       Set(targ,dat);
  84    return dat;
  85 }
  86
  87 STDMETHODIMP cMixedPropertyStore::Reset()
  88 {
  89    mStores[kAbstract]->Reset();
  90    mStores[kConcrete]->Reset();
  91    return S_OK;
  92 }
  93
  94 STDMETHODIMP cMixedPropertyStore::IterStart(sPropertyObjIter* iter) const
  95 {
  96    // Start doing the abstract ones
  97    iter->next = kConcrete;
  98    sPropertyObjIter* subiter = new sPropertyObjIter;
  99    iter->state[0] = subiter;
 100    mStores[iter->next]->IterStart(subiter);
 101    return S_OK;
 102 }
 103
 104 STDMETHODIMP_(BOOL) cMixedPropertyStore::IterNext(sPropertyObjIter* iter,
 105                                                   ObjID* obj, sDatum* value) const
 106 {
 107    sPropertyObjIter* subiter = (sPropertyObjIter*) iter->state[0];
 108    if (mStores[iter->next]->IterNext(subiter,obj,value))
 109       return TRUE;
 110
 111    // if we finished the concretes, start on the abstracts
 112    if (iter->next == kConcrete)
 113    {
 114       iter->next = kAbstract;
 115       mStores[kConcrete]->IterStop(subiter);
 116       mStores[kAbstract]->IterStart(subiter);
 117       return mStores[kAbstract]->IterNext(subiter,obj,value);
 118    }
 119
 120    return FALSE;
 121 }
 122
 123
 124 STDMETHODIMP cMixedPropertyStore::IterStop(sPropertyObjIter* iter) const
 125 {
 126    sPropertyObjIter* subiter = (sPropertyObjIter*) iter->state[0];
 127    delete subiter;
 128    iter->state[0] = NULL;
 129    return S_OK;
 130 }
 131
 132 STDMETHODIMP_(BOOL) cMixedPropertyStore::GetCopy(ObjID obj, sDatum* val)
 133 {
 134    return Store(obj)->GetCopy(obj,val);
 135 }
 136
 137 STDMETHODIMP cMixedPropertyStore::ReleaseCopy(ObjID obj, sDatum val)
 138 {
 139    return Store(obj)->ReleaseCopy(obj,val);
 140 }
 141
 142
 143 STDMETHODIMP_(int) cMixedPropertyStore::WriteVersion()
 144 {
 145    // Really your data ops shouldn't be out of sync
 146    return mStores[kConcrete]->WriteVersion();
 147 }
 148
 149 STDMETHODIMP cMixedPropertyStore::WriteObj(ObjID obj, IDataOpsFile* file)
 150 {
 151    return Store(obj)->WriteObj(obj,file);
 152 }
 153
 154 STDMETHODIMP cMixedPropertyStore::ReadObj (ObjID obj, IDataOpsFile* file , int version)
 155 {
 156    return Store(obj)->ReadObj(obj,file,version);
 157 }
 158
 159 STDMETHODIMP_(IDataOps*) cMixedPropertyStore::GetOps()
 160 {
 161    return mStores[kConcrete]->GetOps();
 162 }
 163
 164 STDMETHODIMP cMixedPropertyStore::SetOps(IDataOps* ops)
 165 {
 166    mStores[kAbstract]->SetOps(ops);
 167    mStores[kConcrete]->SetOps(ops);
 168    return S_OK;
 169 }
 170
 171
 172