storage/base/aaLoadBuilder.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) 2008 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 "nsIMutableArray.h"
  26 #include "nsComponentManagerUtils.h"
  27 #include "nsStringAPI.h"
  28
  29 /* Unfrozen API */
  30
  31 /* Project includes */
  32 #include "aaIEntity.h"
  33 #include "aaIResource.h"
  34 #include "aaIMoney.h"
  35 #include "aaIFlow.h"
  36 #include "aaIRule.h"
  37 #include "aaIState.h"
  38 #include "aaIEvent.h"
  39 #include "aaIFact.h"
  40 #include "aaIQuote.h"
  41 #include "aaIIncome.h"
  42 #include "aaITransaction.h"
  43 #include "aaIChart.h"
  44 #include "aaBaseKeys.h"
  45 #include "aaChartKeys.h"
  46 #include "aaStorageUtils.h"
  47 #include "aaISqlRequest.h"
  48 #include "aaISqlResult.h"
  49 #include "aaLoadBuilder.h"
  50
  51
  52 NS_IMPL_ISUPPORTS2(aaLoadBuilder,
  53                    aaIHandler,
  54                    aaIChartHandler)
  55
  56 nsresult
  57 aaLoadBuilder::Load(aaISqlResult *result, aaIDataNode **_retval)
  58 {
  59   NS_ENSURE_ARG_POINTER(result);
  60   nsresult rv;
  61   mData = result;
  62
  63   nsCOMPtr<aaIDataNode> iid = do_QueryInterface(mData, &rv);
  64   rv = iid->Accept(this);
  65   NS_ENSURE_SUCCESS(rv, rv);
  66
  67   NS_IF_ADDREF(*_retval = mResult);
  68   return NS_OK;
  69 }
  70
  71 /* aaIHandler */
  72 NS_IMETHODIMP
  73 aaLoadBuilder::HandleNode(aaIListNode *aNode)
  74 {
  75   nsresult rv;
  76   nsCOMPtr<aaIListNode> item = aNode;
  77   if (!aNode) {
  78     item = do_CreateInstance(AA_ENTITY_CONTRACT, &rv);
  79     NS_ENSURE_SUCCESS(rv, rv);
  80   }
  81
  82   PRInt64 id;
  83   rv = mData->GetInt64(getColumn("id"), &id);
  84   NS_ENSURE_SUCCESS(rv, rv);
  85   rv = item->SetId(id);
  86   NS_ENSURE_SUCCESS(rv, rv);
  87
  88   if (!aNode)
  89     mResult = item;
  90   return NS_OK;
  91 }
  92
  93 NS_IMETHODIMP
  94 aaLoadBuilder::HandleEntity(aaIEntity *aEntity)
  95 {
  96   nsresult rv;
  97   nsCOMPtr<aaIEntity> item = do_CreateInstance(AA_ENTITY_CONTRACT, &rv);
  98   NS_ENSURE_SUCCESS(rv, rv);
  99
 100   rv = HandleNode(item);
 101   NS_ENSURE_SUCCESS(rv, rv);
 102
 103   nsCAutoString tag;
 104   rv = mData->GetUTF8String(getColumn("tag"), tag);
 105   NS_ENSURE_SUCCESS(rv, rv);
 106   rv = item->SetTag(NS_ConvertUTF8toUTF16(tag));
 107   NS_ENSURE_SUCCESS(rv, rv);
 108
 109   mResult = item;
 110   return NS_OK;
 111 }
 112
 113 NS_IMETHODIMP
 114 aaLoadBuilder::HandleResource(aaIResource *aResource)
 115 {
 116   nsresult rv;
 117   PRInt32 type;
 118   rv = mData->GetInt32(getColumn("type"), &type);
 119   NS_ENSURE_SUCCESS(rv, rv);
 120   switch (type) {
 121   case aaIResource::TYPE_MONEY:
 122     rv = HandleMoney(nsnull);
 123     NS_ENSURE_SUCCESS(rv, rv);
 124     break;
 125   case aaIResource::TYPE_ASSET:
 126     rv = HandleAsset(nsnull);
 127     NS_ENSURE_SUCCESS(rv, rv);
 128     break;
 129   default:
 130     NS_ASSERTION(PR_FALSE, "Wrong resource type.");
 131     return NS_ERROR_UNEXPECTED;
 132   };
 133   return NS_OK;
 134 }
 135
 136 NS_IMETHODIMP
 137 aaLoadBuilder::HandleMoney(aaIMoney *aMoney)
 138 {
 139   nsresult rv;
 140   nsCOMPtr<aaIMoney> item = do_CreateInstance(AA_MONEY_CONTRACT, &rv);
 141   NS_ENSURE_SUCCESS(rv, rv);
 142
 143   PRInt64 id;
 144   rv = mData->GetInt64(getColumn("id"), &id);
 145   NS_ENSURE_SUCCESS(rv, rv);
 146   rv = item->SetNumCode(id);
 147   NS_ENSURE_SUCCESS(rv, rv);
 148
 149   nsCAutoString alphaCode;
 150   rv = mData->GetUTF8String(getColumn("alpha_code"), alphaCode);
 151   NS_ENSURE_SUCCESS(rv, rv);
 152   rv = item->SetAlphaCode(NS_ConvertUTF8toUTF16(alphaCode));
 153   NS_ENSURE_SUCCESS(rv, rv);
 154
 155   mResult = item;
 156   return NS_OK;
 157 }
 158
 159 NS_IMETHODIMP
 160 aaLoadBuilder::HandleAsset(aaIAsset *aAsset)
 161 {
 162   nsresult rv;
 163   nsCOMPtr<aaIAsset> item = do_CreateInstance(AA_ASSET_CONTRACT, &rv);
 164   NS_ENSURE_SUCCESS(rv, rv);
 165
 166   PRInt64 id;
 167   rv = mData->GetInt64(getColumn("id"), &id);
 168   NS_ENSURE_SUCCESS(rv, rv);
 169   rv = item->SetId(id);
 170   NS_ENSURE_SUCCESS(rv, rv);
 171
 172   nsCAutoString tag;
 173   rv = mData->GetUTF8String(getColumn("tag"), tag);
 174   NS_ENSURE_SUCCESS(rv, rv);
 175   rv = item->SetTag(NS_ConvertUTF8toUTF16(tag));
 176   NS_ENSURE_SUCCESS(rv, rv);
 177
 178   mResult = item;
 179   return NS_OK;
 180 }
 181
 182 NS_IMETHODIMP
 183 aaLoadBuilder::HandleFlow(aaIFlow *aFlow)
 184 {
 185   nsresult rv;
 186
 187   PRUint32 colId = getColumn("id");
 188
 189   PRBool isNull = PR_TRUE;
 190   PRInt64 id = 0;
 191   if (colId != (PRUint32) -1) {
 192     rv = mData->GetIsNull(colId, &isNull);
 193     NS_ENSURE_SUCCESS(rv, rv);
 194   }
 195   if (!isNull) {
 196     rv = mData->GetInt64(colId, &id);
 197     NS_ENSURE_SUCCESS(rv, rv);
 198   }
 199   if (!id) {
 200     mResult = do_CreateInstance(AA_INCOMEFLOW_CONTRACT, &rv);
 201     NS_ENSURE_SUCCESS(rv, rv);
 202
 203     return NS_OK;
 204   }
 205
 206   nsCOMPtr<aaIFlow> item = do_CreateInstance(AA_FLOW_CONTRACT, &rv);
 207   NS_ENSURE_SUCCESS(rv, rv);
 208   rv = item->SetId(id);
 209   NS_ENSURE_SUCCESS(rv, rv);
 210
 211   nsCAutoString tag;
 212   rv = mData->GetUTF8String(getColumn("tag"), tag);
 213   NS_ENSURE_SUCCESS(rv, rv);
 214   rv = item->SetTag(NS_ConvertUTF8toUTF16(tag));
 215   NS_ENSURE_SUCCESS(rv, rv);
 216
 217   double rate;
 218   rv = mData->GetDouble(getColumn("rate"), &rate);
 219   NS_ENSURE_SUCCESS(rv, rv);
 220   rv = item->SetRate(rate);
 221   NS_ENSURE_SUCCESS(rv, rv);
 222
 223   PRUint32 colOffBalance = getColumn("off_balance");
 224   if (colOffBalance != (PRUint32) -1) {
 225     PRBool isOffBalance;
 226     rv = mData->GetInt32(colOffBalance, &isOffBalance);
 227     NS_ENSURE_SUCCESS(rv, rv);
 228     rv = item->SetIsOffBalance(isOffBalance);
 229     NS_ENSURE_SUCCESS(rv, rv);
 230   }
 231
 232   {
 233     aaLoadBuilder::PrefixStacker stacker(this);
 234     rv = appendPrefix("entity.");
 235     NS_ENSURE_SUCCESS(rv, rv);
 236     rv = HandleEntity(nsnull);
 237     NS_ENSURE_SUCCESS(rv, rv);
 238     nsCOMPtr<aaIEntity> entity = do_QueryInterface(mResult, &rv);
 239     NS_ENSURE_SUCCESS(rv, rv);
 240     rv = item->SetEntity(entity);
 241     NS_ENSURE_SUCCESS(rv, rv);
 242   }
 243
 244   {
 245     aaLoadBuilder::PrefixStacker stacker(this);
 246     rv = appendPrefix("give_resource.");
 247     NS_ENSURE_SUCCESS(rv, rv);
 248     rv = HandleResource(nsnull);
 249     NS_ENSURE_SUCCESS(rv, rv);
 250     nsCOMPtr<aaIResource> resource = do_QueryInterface(mResult, &rv);
 251     NS_ENSURE_SUCCESS(rv, rv);
 252     rv = item->SetGiveResource(resource);
 253     NS_ENSURE_SUCCESS(rv, rv);
 254   }
 255
 256   {
 257     aaLoadBuilder::PrefixStacker stacker(this);
 258     rv = appendPrefix("take_resource.");
 259     NS_ENSURE_SUCCESS(rv, rv);
 260     rv = HandleResource(nsnull);
 261     NS_ENSURE_SUCCESS(rv, rv);
 262     nsCOMPtr<aaIResource> resource = do_QueryInterface(mResult, &rv);
 263     NS_ENSURE_SUCCESS(rv, rv);
 264     rv = item->SetTakeResource(resource);
 265     NS_ENSURE_SUCCESS(rv, rv);
 266   }
 267   mResult = item;
 268   return NS_OK;
 269 }
 270
 271 NS_IMETHODIMP
 272 aaLoadBuilder::HandleRule(aaIRule *aRule)
 273 {
 274   nsresult rv;
 275   nsCOMPtr<aaIRule> item = do_CreateInstance(AA_RULE_CONTRACT, &rv);
 276   NS_ENSURE_SUCCESS(rv, rv);
 277
 278   rv = HandleNode(item);
 279   NS_ENSURE_SUCCESS(rv, rv);
 280
 281   PRBool changeSide, factSide;
 282   rv = mData->GetInt32(getColumn("fact_side"), &factSide);
 283   NS_ENSURE_SUCCESS(rv, rv);
 284   rv = item->SetFactSide(factSide);
 285   NS_ENSURE_SUCCESS(rv, rv);
 286
 287   rv = mData->GetInt32(getColumn("change_side"), &changeSide);
 288   NS_ENSURE_SUCCESS(rv, rv);
 289   rv = item->SetChangeSide(changeSide);
 290   NS_ENSURE_SUCCESS(rv, rv);
 291
 292   double rate;
 293   rv = mData->GetDouble(getColumn("rate"), &rate);
 294   NS_ENSURE_SUCCESS(rv, rv);
 295   rv = item->SetRate(rate);
 296   NS_ENSURE_SUCCESS(rv, rv);
 297
 298   nsCAutoString tag;
 299   rv = mData->GetUTF8String(getColumn("tag"), tag);
 300   NS_ENSURE_SUCCESS(rv, rv);
 301   rv = item->SetTag(NS_ConvertUTF8toUTF16(tag));
 302   NS_ENSURE_SUCCESS(rv, rv);
 303
 304   {
 305     aaLoadBuilder::PrefixStacker stacker(this);
 306     rv = appendPrefix("take_flow.");
 307     NS_ENSURE_SUCCESS(rv, rv);
 308     rv = HandleFlow(nsnull);
 309     NS_ENSURE_SUCCESS(rv, rv);
 310     nsCOMPtr<aaIFlow> flow = do_QueryInterface(mResult, &rv);
 311     NS_ENSURE_SUCCESS(rv, rv);
 312     rv = item->SetTakeFrom(flow);
 313     NS_ENSURE_SUCCESS(rv, rv);
 314   }
 315
 316   {
 317     aaLoadBuilder::PrefixStacker stacker(this);
 318     rv = appendPrefix("give_flow.");
 319     NS_ENSURE_SUCCESS(rv, rv);
 320     rv = HandleFlow(nsnull);
 321     NS_ENSURE_SUCCESS(rv, rv);
 322     nsCOMPtr<aaIFlow> flow = do_QueryInterface(mResult, &rv);
 323     NS_ENSURE_SUCCESS(rv, rv);
 324     rv = item->SetGiveTo(flow);
 325     NS_ENSURE_SUCCESS(rv, rv);
 326   }
 327
 328   mResult = item;
 329   return NS_OK;
 330 }
 331
 332 NS_IMETHODIMP
 333 aaLoadBuilder::HandleState(aaIState *aState)
 334 {
 335   nsresult rv;
 336   nsCOMPtr<aaIState> item = aState;
 337
 338   if (!item) {
 339     item = do_CreateInstance(AA_STATE_CONTRACT, &rv);
 340     NS_ENSURE_SUCCESS(rv, rv);
 341   }
 342
 343   {
 344     aaLoadBuilder::PrefixStacker stacker(this);
 345     rv = appendPrefix("flow.");
 346     NS_ENSURE_SUCCESS(rv, rv);
 347     rv = HandleFlow(nsnull);
 348     NS_ENSURE_SUCCESS(rv, rv);
 349     nsCOMPtr<aaIFlow> flow = do_QueryInterface(mResult, &rv);
 350     NS_ENSURE_SUCCESS(rv, rv);
 351
 352     if (flow->PickId()) {
 353       rv = item->SetFlow(flow);
 354       NS_ENSURE_SUCCESS(rv, rv);
 355     }
 356   }
 357
 358   PRUint32 col = getColumn("id");
 359   PRBool isNull = PR_TRUE;
 360   if (col != (PRUint32) -1) {
 361     rv = mData->GetIsNull(col, &isNull);
 362     NS_ENSURE_SUCCESS(rv, rv);
 363     if (isNull) {
 364       if (!aState)
 365         mResult = item;
 366       return NS_OK;
 367     }
 368   }
 369   if (!isNull) {
 370     PRInt64 id;
 371     rv = mData->GetInt64(col, &id);
 372     NS_ENSURE_SUCCESS(rv, rv);
 373     rv = item->SetId(id);
 374     NS_ENSURE_SUCCESS(rv, rv);
 375   }
 376
 377   PRBool side;
 378   rv = mData->GetInt32(getColumn("side"), &side);
 379   NS_ENSURE_SUCCESS(rv, rv);
 380   rv = item->SetSide(side);
 381   NS_ENSURE_SUCCESS(rv, rv);
 382
 383   double amount;
 384   rv = mData->GetDouble(getColumn("amount"), &amount);
 385   NS_ENSURE_SUCCESS(rv, rv);
 386   rv = item->SetAmount(amount);
 387   NS_ENSURE_SUCCESS(rv, rv);
 388
 389   PRTime start;
 390   rv = mData->GetInt64(getColumn("start"), &start);
 391   NS_ENSURE_SUCCESS(rv, rv);
 392   rv = item->SetStart(start * 1000000);
 393   NS_ENSURE_SUCCESS(rv, rv);
 394
 395   PRUint32 colPaid = getColumn("paid");
 396   NS_ENSURE_TRUE(colPaid != (PRUint32) -1, NS_ERROR_INVALID_ARG);
 397   rv = mData->GetIsNull(colPaid, &isNull);
 398   NS_ENSURE_SUCCESS(rv, rv);
 399   if (!isNull) {
 400     PRTime end;
 401     rv = mData->GetInt64(colPaid, &end);
 402     NS_ENSURE_SUCCESS(rv, rv);
 403     rv = item->SetEnd(end * 1000000);
 404     NS_ENSURE_SUCCESS(rv, rv);
 405   }
 406
 407   if (!aState)
 408     mResult = item;
 409   return NS_OK;
 410 }
 411
 412 NS_IMETHODIMP
 413 aaLoadBuilder::HandleFact(aaIFact *aFact)
 414 {
 415   nsresult rv;
 416   nsCOMPtr<aaIFact> item = do_CreateInstance(AA_FACT_CONTRACT, &rv);
 417   NS_ENSURE_SUCCESS(rv, rv);
 418
 419   PRInt64 id;
 420   rv = mData->GetInt64(getColumn("id"), &id);
 421   NS_ENSURE_SUCCESS(rv, rv);
 422   rv = item->SetId(id);
 423   NS_ENSURE_SUCCESS(rv, rv);
 424
 425   double amount;
 426   rv = mData->GetDouble(getColumn("amount"), &amount);
 427   NS_ENSURE_SUCCESS(rv, rv);
 428   rv = item->SetAmount(amount);
 429   NS_ENSURE_SUCCESS(rv, rv);
 430
 431   {
 432     aaLoadBuilder::PrefixStacker stacker(this);
 433     rv = appendPrefix("event.");
 434     NS_ENSURE_SUCCESS(rv, rv);
 435     rv = HandleEvent(nsnull);
 436     NS_ENSURE_SUCCESS(rv, rv);
 437     nsCOMPtr<aaIEvent> event = do_QueryInterface(mResult, &rv);
 438     NS_ENSURE_SUCCESS(rv, rv);
 439     rv = item->SetEvent(event);
 440     NS_ENSURE_SUCCESS(rv, rv);
 441   }
 442
 443   {
 444     aaLoadBuilder::PrefixStacker stacker(this);
 445     rv = appendPrefix("giveToFlow.");
 446     NS_ENSURE_SUCCESS(rv, rv);
 447     rv = HandleFlow(nsnull);
 448     NS_ENSURE_SUCCESS(rv, rv);
 449     nsCOMPtr<aaIFlow> flow = do_QueryInterface(mResult, &rv);
 450     NS_ENSURE_SUCCESS(rv, rv);
 451     rv = item->SetGiveTo(flow);
 452     NS_ENSURE_SUCCESS(rv, rv);
 453   }
 454
 455   {
 456     aaLoadBuilder::PrefixStacker stacker(this);
 457     rv = appendPrefix("takeFromFlow.");
 458     NS_ENSURE_SUCCESS(rv, rv);
 459     rv = HandleFlow(nsnull);
 460     NS_ENSURE_SUCCESS(rv, rv);
 461     nsCOMPtr<aaIFlow> flow = do_QueryInterface(mResult, &rv);
 462     NS_ENSURE_SUCCESS(rv, rv);
 463     rv = item->SetTakeFrom(flow);
 464     NS_ENSURE_SUCCESS(rv, rv);
 465   }
 466
 467   mResult = item;
 468   return NS_OK;
 469 }
 470
 471 NS_IMETHODIMP
 472 aaLoadBuilder::HandleEvent(aaIEvent *aEvent)
 473 {
 474   nsresult rv;
 475   nsCOMPtr<aaIEvent> item = do_CreateInstance(AA_EVENT_CONTRACT, &rv);
 476   NS_ENSURE_SUCCESS(rv, rv);
 477
 478   PRTime time;
 479   rv = mData->GetInt64(getColumn("time"), &time);
 480   NS_ENSURE_SUCCESS(rv, rv);
 481   rv = item->SetTime(time * 1000000);
 482   NS_ENSURE_SUCCESS(rv, rv);
 483
 484   PRInt64 id;
 485   rv = mData->GetInt64(getColumn("id"), &id);
 486   NS_ENSURE_SUCCESS(rv, rv);
 487   rv = item->SetId(id);
 488   NS_ENSURE_SUCCESS(rv, rv);
 489
 490   mResult = item;
 491   return NS_OK;
 492 }
 493
 494 NS_IMETHODIMP
 495 aaLoadBuilder::HandleQuote(aaIQuote *aQuote)
 496 {
 497   nsresult rv;
 498   PRUint32 colRate = getColumn("rate");
 499   if (colRate == (PRUint32) -1) {
 500     mResult = nsnull;
 501     return NS_OK;
 502   }
 503
 504   nsCOMPtr<aaIQuote> item = do_CreateInstance(AA_QUOTE_CONTRACT, &rv);
 505   NS_ENSURE_SUCCESS(rv, rv);
 506
 507   {
 508     aaLoadBuilder::PrefixStacker stacker(this);
 509     rv = appendPrefix("money.");
 510     NS_ENSURE_SUCCESS(rv, rv);
 511     rv = HandleMoney(nsnull);
 512     NS_ENSURE_SUCCESS(rv, rv);
 513     nsCOMPtr<aaIResource> resource = do_QueryInterface(mResult, &rv);
 514     NS_ENSURE_SUCCESS(rv, rv);
 515     rv = item->SetResource(resource);
 516     NS_ENSURE_SUCCESS(rv, rv);
 517   }
 518
 519   PRUint32 colChart = getColumn("is_chart");
 520   PRBool isNull = PR_TRUE;
 521   if (colChart != (PRUint32) -1) {
 522     rv = mData->GetIsNull(colChart, &isNull);
 523     NS_ENSURE_SUCCESS(rv, rv);
 524   }
 525   if (!isNull) {
 526     rv = item->SetRate(1.0);
 527     NS_ENSURE_SUCCESS(rv, rv);
 528     mResult = item;
 529     return NS_OK;
 530   }
 531
 532   double rate;
 533   isNull = PR_TRUE;
 534   rv = mData->GetIsNull(colRate, &isNull);
 535   NS_ENSURE_SUCCESS(rv, rv);
 536   if (isNull) {
 537     mResult = nsnull;
 538     return NS_OK;
 539   }
 540   rv = mData->GetDouble(colRate, &rate);
 541   NS_ENSURE_SUCCESS(rv, rv);
 542   rv = item->SetRate(rate);
 543   NS_ENSURE_SUCCESS(rv, rv);
 544
 545   PRTime time;
 546   rv = mData->GetInt64(getColumn("time"), &time);
 547   NS_ENSURE_SUCCESS(rv, rv);
 548   rv = item->SetTime(time * 1000000);
 549   NS_ENSURE_SUCCESS(rv, rv);
 550
 551   double diff;
 552   rv = mData->GetDouble(getColumn("diff"), &diff);
 553   NS_ENSURE_SUCCESS(rv, rv);
 554   rv = item->SetDiff(diff);
 555   NS_ENSURE_SUCCESS(rv, rv);
 556
 557   mResult = item;
 558   return NS_OK;
 559 }
 560
 561 NS_IMETHODIMP
 562 aaLoadBuilder::HandleTransaction(aaITransaction *aTransaction)
 563 {
 564   nsresult rv;
 565   nsCOMPtr<aaIFact> fact;
 566   {
 567     aaLoadBuilder::PrefixStacker stacker(this);
 568     rv = appendPrefix("fact.");
 569     NS_ENSURE_SUCCESS(rv, rv);
 570     rv = HandleFact(nsnull);
 571     NS_ENSURE_SUCCESS(rv, rv);
 572     fact = do_QueryInterface(mResult, &rv);
 573     NS_ENSURE_SUCCESS(rv, rv);
 574   }
 575
 576   PRUint32 colValue = getColumn("value");
 577   NS_ENSURE_TRUE(colValue != (PRUint32) -1, NS_ERROR_INVALID_ARG);
 578
 579   PRBool isNull = PR_FALSE;
 580   rv = mData->GetIsNull(colValue, &isNull);
 581   NS_ENSURE_SUCCESS(rv, rv);
 582
 583   if (isNull) {
 584     mResult = fact;
 585     return NS_OK;
 586   }
 587
 588   nsCOMPtr<aaITransaction> item
 589     = do_CreateInstance(AA_TRANSACTION_CONTRACT, &rv);
 590   NS_ENSURE_SUCCESS(rv, rv);
 591
 592   rv = item->SetFact(fact);
 593   NS_ENSURE_SUCCESS(rv, rv);
 594
 595   double value;
 596   rv = mData->GetDouble(colValue, &value);
 597   NS_ENSURE_SUCCESS(rv, rv);
 598   rv = item->SetValue(value);
 599   NS_ENSURE_SUCCESS(rv, rv);
 600
 601   PRUint32 colEarnings = getColumn("earnings");
 602   NS_ENSURE_TRUE(colEarnings != (PRUint32) -1, NS_ERROR_INVALID_ARG);
 603   rv = mData->GetIsNull(colEarnings, &isNull);
 604   NS_ENSURE_SUCCESS(rv, rv);
 605   if (!isNull) {
 606     double earnings;
 607     rv = mData->GetDouble(colEarnings, &earnings);
 608     NS_ENSURE_SUCCESS(rv, rv);
 609     rv = item->SetEarnings(earnings);
 610     NS_ENSURE_SUCCESS(rv, rv);
 611   }
 612
 613   mResult = item;
 614   return NS_OK;
 615 }
 616
 617 /* aaIChartHandler */
 618 NS_IMETHODIMP
 619 aaLoadBuilder::HandleChart(aaIChart *aChart)
 620 {
 621   nsresult rv;
 622   nsCOMPtr<aaIChart> item = do_CreateInstance(AA_CHART_CONTRACT, &rv);
 623   NS_ENSURE_SUCCESS(rv, rv);
 624
 625   {
 626     aaLoadBuilder::PrefixStacker stacker(this);
 627     rv = appendPrefix("resource.");
 628     NS_ENSURE_SUCCESS(rv, rv);
 629     rv = HandleMoney(nsnull);
 630     NS_ENSURE_SUCCESS(rv, rv);
 631     nsCOMPtr<aaIMoney> resource = do_QueryInterface(mResult, &rv);
 632     NS_ENSURE_SUCCESS(rv, rv);
 633     rv = item->SetCurrency(resource);
 634     NS_ENSURE_SUCCESS(rv, rv);
 635   }
 636
 637   mResult = item;
 638   return NS_OK;
 639 }
 640
 641 NS_IMETHODIMP
 642 aaLoadBuilder::HandleBalance(aaIBalance *aBalance)
 643 {
 644   nsresult rv;
 645   nsCOMPtr<aaIBalance> item = aBalance;;
 646   if (!item) {
 647     item = do_CreateInstance(AA_STATE_CONTRACT, &rv);
 648     NS_ENSURE_SUCCESS(rv, rv);
 649   }
 650
 651   rv = HandleState(item);
 652   NS_ENSURE_SUCCESS(rv, rv);
 653
 654   double value;
 655   PRUint32 colVal = getColumn("value");
 656   NS_ENSURE_TRUE(colVal != (PRUint32) -1, NS_ERROR_UNEXPECTED);
 657   PRBool isNull = PR_FALSE;
 658   rv = mData->GetIsNull(colVal, &isNull);
 659   NS_ENSURE_SUCCESS(rv, rv);
 660   if (!isNull) {
 661     rv = mData->GetDouble(colVal, &value);
 662     NS_ENSURE_SUCCESS(rv, rv);
 663     rv = item->SetInitValue(value);
 664     NS_ENSURE_SUCCESS(rv, rv);
 665   }
 666
 667   {
 668     aaLoadBuilder::PrefixStacker stacker(this);
 669     rv = appendPrefix("quote1.");
 670     NS_ENSURE_SUCCESS(rv, rv);
 671     rv = HandleQuote(nsnull);
 672     NS_ENSURE_SUCCESS(rv, rv);
 673     if (mResult) {
 674       nsCOMPtr<aaIQuote> quote = do_QueryInterface(mResult, &rv);
 675       NS_ENSURE_SUCCESS(rv, rv);
 676       rv = item->ApplyQuote(quote);
 677       NS_ENSURE_SUCCESS(rv, rv);
 678     }
 679   }
 680
 681   {
 682     aaLoadBuilder::PrefixStacker stacker(this);
 683     rv = appendPrefix("quote0.");
 684     NS_ENSURE_SUCCESS(rv, rv);
 685     rv = HandleQuote(nsnull);
 686     NS_ENSURE_SUCCESS(rv, rv);
 687     if (mResult) {
 688       nsCOMPtr<aaIQuote> quote = do_QueryInterface(mResult, &rv);
 689       NS_ENSURE_SUCCESS(rv, rv);
 690       rv = item->ApplyQuote(quote);
 691       NS_ENSURE_SUCCESS(rv, rv);
 692     }
 693   }
 694
 695   if (!aBalance)
 696     mResult = item;
 697   return NS_OK;
 698 }
 699
 700 NS_IMETHODIMP
 701 aaLoadBuilder::HandleIncome(aaIBalance *aIncome)
 702 {
 703   nsresult rv;
 704   nsCOMPtr<aaIIncome> item = do_CreateInstance(AA_INCOME_CONTRACT, &rv);
 705   NS_ENSURE_SUCCESS(rv, rv);
 706
 707   rv = HandleBalance(item);
 708   NS_ENSURE_SUCCESS(rv, rv);
 709
 710   PRBool isNull = PR_TRUE;
 711   PRUint32 colIndex = getColumn("credit_diff");
 712   NS_ENSURE_TRUE(colIndex != (PRUint32) -1, NS_ERROR_INVALID_ARG);
 713   rv = mData->GetIsNull(colIndex, &isNull);
 714   NS_ENSURE_SUCCESS(rv, rv);
 715   if (!isNull) {
 716     double credit_diff;
 717     rv = mData->GetDouble(colIndex, &credit_diff);
 718     NS_ENSURE_SUCCESS(rv, rv);
 719     rv = item->SetCreditDiff(credit_diff);
 720     NS_ENSURE_SUCCESS(rv, rv);
 721   }
 722
 723   isNull = PR_TRUE;
 724   colIndex = getColumn("debit_diff");
 725   NS_ENSURE_TRUE(colIndex != (PRUint32) -1, NS_ERROR_INVALID_ARG);
 726   rv = mData->GetIsNull(colIndex, &isNull);
 727   NS_ENSURE_SUCCESS(rv, rv);
 728   if (!isNull) {
 729     double debit_diff;
 730     rv = mData->GetDouble(colIndex, &debit_diff);
 731     NS_ENSURE_SUCCESS(rv, rv);
 732     rv = item->SetDebitDiff(debit_diff);
 733     NS_ENSURE_SUCCESS(rv, rv);
 734   }
 735
 736   mResult = item;
 737   return NS_OK;
 738 }
 739
 740 /* Private methods */
 741 nsresult
 742 aaLoadBuilder::appendPrefix(const char *aElement)
 743 {
 744   PRUint32 len = strlen(aElement);
 745   NS_ENSURE_TRUE(mIndex + len < AA_BUILD_BUFFER_SIZE, NS_ERROR_UNEXPECTED);
 746   strcpy(&mPrefix[mIndex], aElement);
 747   mIndex += len;
 748   return NS_OK;
 749 }
 750
 751 PRUint32
 752 aaLoadBuilder::getColumn(const char *aElement)
 753 {
 754   aaLoadBuilder::PrefixStacker stacker(this);
 755   nsresult rv;
 756   PRUint32 column = -1;
 757   rv = appendPrefix(aElement);
 758   NS_ENSURE_SUCCESS(rv, -1);
 759   rv = mData->GetColumn(mPrefix, &column);
 760   NS_ENSURE_SUCCESS(rv, -1);
 761   return column;
 762 }