base/aaFact.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent tw=79 ft=cpp: */
   3 /*
   4  * Copyright (C) 2007 Sergey Yanovich <ynvich@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include "xpcom-config.h"
  23
  24 #include "nsCOMPtr.h"
  25 #include "nsAutoPtr.h"
  26 #include "nsComponentManagerUtils.h"
  27 #include "nsServiceManagerUtils.h"
  28 #include "nsIObserverService.h"
  29 #include "nsIMutableArray.h"
  30
  31 /* Project includes */
  32 #include "aaIFlow.h"
  33 #include "aaIResource.h"
  34 #include "aaIRule.h"
  35 #include "aaIEvent.h"
  36 #include "aaIState.h"
  37 #include "aaIHandler.h"
  38 #include "aaBaseKeys.h"
  39
  40 #include "aaFact.h"
  41
  42 aaFact::aaFact()
  43   :mAmount(0.0), mBroadcasting(PR_FALSE)
  44 {
  45 }
  46
  47 aaFact::~aaFact()
  48 {
  49 }
  50
  51 NS_IMPL_ISUPPORTS3(aaFact,
  52                    aaIDataNode,
  53                    aaIListNode,
  54                    aaIFact)
  55
  56 /* aaIListNode */
  57 NS_IMETHODIMP
  58 aaFact::GetId(PRInt64 *aId)
  59 {
  60   NS_ENSURE_ARG_POINTER(aId);
  61   *aId = mId;
  62   return NS_OK;
  63 }
  64 NS_IMETHODIMP
  65 aaFact::SetId(PRInt64 aId)
  66 {
  67   mId = aId;
  68   return NS_OK;
  69 }
  70 PRInt64
  71 aaFact::PickId()
  72 {
  73   return mId;
  74 }
  75
  76 /* aaIDataNode */
  77 NS_IMETHODIMP
  78 aaFact::Accept(aaIHandler* aQuery)
  79 {
  80   NS_ENSURE_ARG_POINTER(aQuery);
  81   return aQuery->HandleFact(this);
  82 }
  83
  84 NS_IMETHODIMP
  85 aaFact::GetEdited(PRBool* aEdited)
  86 {
  87   NS_ENSURE_ARG_POINTER(aEdited);
  88   *aEdited = PR_FALSE;
  89   return NS_OK;
  90 }
  91
  92 NS_IMETHODIMP
  93 aaFact::Sync(aaIStorager *aStorager, aaISqliteChannel *aChannel)
  94 {
  95   return NS_ERROR_NOT_IMPLEMENTED;
  96 }
  97
  98 /* aaIFact */
  99 NS_IMETHODIMP
 100 aaFact::GetEventId(PRInt64 *aEventId)
 101 {
 102   NS_ENSURE_ARG_POINTER( aEventId );
 103   if (NS_UNLIKELY( !mEvent ))
 104     return NS_ERROR_NOT_INITIALIZED;
 105   *aEventId = PickEventId();
 106   return NS_OK;
 107 }
 108 PRInt64
 109 aaFact::PickEventId()
 110 {
 111   if (!mEvent)
 112     return 0;
 113   nsCOMPtr<aaIEvent> event = do_QueryReferent(mEvent);
 114   if (event)
 115     event->GetId(&mEventId);
 116   return mEventId;
 117 }
 118
 119
 120 NS_IMETHODIMP
 121 aaFact::GetTime(PRTime *aTime)
 122 {
 123   NS_ENSURE_ARG_POINTER( aTime );
 124   if (NS_UNLIKELY( !mEvent ))
 125     return NS_ERROR_NOT_INITIALIZED;
 126   *aTime = mTime;
 127   return NS_OK;
 128 }
 129 PRTime
 130 aaFact::PickTime()
 131 {
 132   if (!mEvent)
 133     return 0;
 134   nsCOMPtr<aaIEvent> event = do_QueryReferent(mEvent);
 135   if (event)
 136     event->GetTime(&mTime);
 137   return mTime;
 138 }
 139
 140 NS_IMETHODIMP
 141 aaFact::SetEvent(aaIEvent *aEvent)
 142 {
 143   if (NS_UNLIKELY( ! aEvent )) {
 144     mEvent = nsnull;
 145     return NS_OK;
 146   }
 147   nsresult rv;
 148
 149   rv = aEvent->GetId( &mEventId );
 150   NS_ENSURE_SUCCESS(rv, rv);
 151
 152   rv = aEvent->GetTime( &mTime );
 153   NS_ENSURE_SUCCESS(rv, rv);
 154
 155   mEvent = do_GetWeakReference(aEvent, &rv);
 156   NS_ENSURE_SUCCESS(rv, rv);
 157
 158   return NS_OK;
 159 }
 160
 161 NS_IMETHODIMP
 162 aaFact::GetTakeFrom(aaIFlow * *aTakeFrom)
 163 {
 164   NS_ENSURE_ARG_POINTER( aTakeFrom );
 165   NS_IF_ADDREF( *aTakeFrom = mTakeFrom );
 166   return NS_OK;
 167 }
 168 NS_IMETHODIMP
 169 aaFact::SetTakeFrom(aaIFlow *aTakeFrom)
 170 {
 171   NS_ENSURE_TRUE(!mStateFrom, NS_ERROR_ALREADY_INITIALIZED);
 172   mTakeFrom = aTakeFrom;
 173   if (! mBroadcasting)
 174     return NS_OK;
 175   nsCOMPtr<nsIObserverService> broadcaster = do_GetService(
 176       "@mozilla.org/observer-service;1");
 177   NS_ENSURE_TRUE(broadcaster, NS_OK);
 178   broadcaster->NotifyObservers(this, "fact-from-flow-change", nsnull);
 179   return NS_OK;
 180 }
 181 aaIFlow *
 182 aaFact::PickTakeFrom()
 183 {
 184   return mTakeFrom;
 185 }
 186
 187 NS_IMETHODIMP
 188 aaFact::GetGiveTo(aaIFlow * *aGiveTo)
 189 {
 190   NS_ENSURE_ARG_POINTER( aGiveTo );
 191   NS_IF_ADDREF( *aGiveTo = mGiveTo );
 192   return NS_OK;
 193 }
 194 NS_IMETHODIMP
 195 aaFact::SetGiveTo(aaIFlow *aGiveTo)
 196 {
 197   NS_ENSURE_TRUE(!mStateTo, NS_ERROR_ALREADY_INITIALIZED);
 198   mGiveTo = aGiveTo;
 199   if (! mBroadcasting)
 200     return NS_OK;
 201   nsCOMPtr<nsIObserverService> broadcaster = do_GetService(
 202       "@mozilla.org/observer-service;1");
 203   NS_ENSURE_TRUE(broadcaster, NS_OK);
 204   broadcaster->NotifyObservers(this, "fact-to-flow-change", nsnull);
 205   return NS_OK;
 206 }
 207 aaIFlow *
 208 aaFact::PickGiveTo()
 209 {
 210   return mGiveTo;
 211 }
 212
 213 NS_IMETHODIMP
 214 aaFact::GetAmount(double *aAmount)
 215 {
 216   NS_ENSURE_ARG_POINTER( aAmount );
 217   *aAmount = mAmount;
 218   return NS_OK;
 219 }
 220 NS_IMETHODIMP
 221 aaFact::SetAmount(double aAmount)
 222 {
 223   mAmount = aAmount;
 224   return NS_OK;
 225 }
 226 double
 227 aaFact::PickAmount()
 228 {
 229   return mAmount;
 230 }
 231
 232 NS_IMETHODIMP
 233 aaFact::InitStateFrom(aaIState *aStateFrom)
 234 {
 235   NS_ENSURE_TRUE(!mStateFrom, NS_ERROR_ALREADY_INITIALIZED);
 236   if ((!mTakeFrom || !mTakeFrom->PickId()) && !aStateFrom)
 237     return NS_OK;
 238   nsresult rv;
 239   nsCOMPtr<aaIState> stateFrom = aStateFrom;
 240   if (stateFrom) {
 241     NS_ENSURE_TRUE(mTakeFrom, NS_ERROR_INVALID_ARG);
 242     NS_ENSURE_ARG_POINTER(aStateFrom->PickFlow());
 243     NS_ENSURE_TRUE(mTakeFrom->PickId() == aStateFrom->PickFlow()->PickId(),
 244         NS_ERROR_INVALID_ARG);
 245     if (mStateTo && mStateTo->PickFlow()->PickId()) {
 246       NS_ENSURE_TRUE(mStateTo->PickFlow()->PickGiveResource(),
 247           NS_ERROR_INVALID_ARG);
 248       NS_ENSURE_TRUE(aStateFrom->PickFlow()->PickTakeResource(),
 249           NS_ERROR_INVALID_ARG);
 250       if (mStateTo->PickFlow()->PickGiveResource()->PickId() !=
 251          aStateFrom->PickFlow()->PickTakeResource()->PickId())
 252         return NS_ERROR_INVALID_ARG;
 253     }
 254   }
 255   else {
 256     stateFrom = do_CreateInstance(AA_STATE_CONTRACT, &rv);
 257     NS_ENSURE_SUCCESS(rv, rv);
 258   }
 259
 260   rv = stateFrom->SetFlow(mTakeFrom);
 261   NS_ENSURE_SUCCESS(rv, rv);
 262
 263   rv = stateFrom->ApplyFact(this);
 264   NS_ENSURE_SUCCESS(rv, rv);
 265
 266   mStateFrom = stateFrom;
 267   return NS_OK;
 268 }
 269
 270 NS_IMETHODIMP
 271 aaFact::InitStateTo(aaIState *aStateTo)
 272 {
 273   NS_ENSURE_TRUE(!mStateTo, NS_ERROR_ALREADY_INITIALIZED);
 274   if ((!mGiveTo || !mGiveTo->PickId()) && !aStateTo)
 275     return NS_OK;
 276   nsresult rv;
 277   nsCOMPtr<aaIState> stateTo = aStateTo;
 278   if (stateTo) {
 279     NS_ENSURE_TRUE(mGiveTo, NS_ERROR_INVALID_ARG);
 280     NS_ENSURE_ARG_POINTER(aStateTo->PickFlow());
 281     NS_ENSURE_TRUE(mGiveTo->PickId() == aStateTo->PickFlow()->PickId(),
 282         NS_ERROR_INVALID_ARG);
 283     if (mStateFrom && mStateFrom->PickFlow()->PickId()) {
 284       NS_ENSURE_TRUE(mStateFrom->PickFlow()->PickTakeResource(),
 285           NS_ERROR_INVALID_ARG);
 286       NS_ENSURE_TRUE(aStateTo->PickFlow()->PickGiveResource(),
 287           NS_ERROR_INVALID_ARG);
 288       if (mStateFrom->PickFlow()->PickTakeResource()->PickId() !=
 289          aStateTo->PickFlow()->PickGiveResource()->PickId())
 290         return NS_ERROR_INVALID_ARG;
 291     }
 292   }
 293   else {
 294     stateTo = do_CreateInstance(AA_STATE_CONTRACT, &rv);
 295     NS_ENSURE_SUCCESS(rv, rv);
 296   }
 297
 298   rv = stateTo->SetFlow(mGiveTo);
 299   NS_ENSURE_SUCCESS(rv, rv);
 300
 301   rv = stateTo->ApplyFact(this);
 302   NS_ENSURE_SUCCESS(rv, rv);
 303
 304   mStateTo = stateTo;
 305   return NS_OK;
 306 }
 307
 308 NS_IMETHODIMP
 309 aaFact::GetStateFrom(aaIState * * aStateFrom)
 310 {
 311   NS_ENSURE_ARG_POINTER(aStateFrom);
 312   NS_IF_ADDREF(*aStateFrom = mStateFrom);
 313   return NS_OK;
 314 }
 315
 316 NS_IMETHODIMP
 317 aaFact::GetStateTo(aaIState * * aStateTo)
 318 {
 319   NS_ENSURE_ARG_POINTER(aStateTo);
 320   NS_IF_ADDREF(*aStateTo = mStateTo);
 321   return NS_OK;
 322 }
 323
 324 NS_IMETHODIMP
 325 aaFact::GetBroadcasting(PRBool *aBroadcasting)
 326 {
 327   NS_ENSURE_ARG_POINTER(aBroadcasting);
 328   *aBroadcasting = mBroadcasting;
 329   return NS_OK;
 330 }
 331 NS_IMETHODIMP
 332 aaFact::SetBroadcasting(PRBool aBroadcasting)
 333 {
 334   mBroadcasting = aBroadcasting;
 335   return NS_OK;
 336 }
 337
 338 NS_IMETHODIMP
 339 aaFact::UseRule(aaIRule *aRule, double aAmount)
 340 {
 341   nsresult rv;
 342   nsRefPtr<aaFact> newFact = new aaFact();
 343   double rate;
 344   rv = aRule->GetRate(&rate);
 345   NS_ENSURE_SUCCESS(rv, rv);
 346
 347   rv = newFact->SetAmount(rate * aAmount);
 348   NS_ENSURE_SUCCESS(rv, rv);
 349
 350   nsCOMPtr<aaIFlow> takeFrom, giveTo;
 351   rv = aRule->GetTakeFrom(getter_AddRefs(takeFrom));
 352   NS_ENSURE_SUCCESS(rv, rv);
 353
 354   rv = newFact->SetTakeFrom(takeFrom);
 355   NS_ENSURE_SUCCESS(rv, rv);
 356
 357   rv = aRule->GetGiveTo(getter_AddRefs(giveTo));
 358   NS_ENSURE_SUCCESS(rv, rv);
 359
 360   rv = newFact->SetGiveTo(giveTo);
 361   NS_ENSURE_SUCCESS(rv, rv);
 362
 363   nsCOMPtr<nsIMutableArray> factSet = do_QueryReferent(mEvent);
 364   rv = factSet->AppendElement(newFact, PR_FALSE);
 365   NS_ENSURE_SUCCESS(rv, rv);
 366
 367   return NS_OK;
 368 }