~ubuntu-branches/ubuntu/precise/folks/precise

gboolean tracker_test_backend_update_contact (TrackerTestBackend* self, const gchar* contact_urn, const gchar* predicate, const gchar* literal_subject);

107

static gboolean _tracker_test_backend_do_update_query (TrackerTestBackend* self, const gchar* query);

108

gboolean tracker_test_backend_update_favourite (TrackerTestBackend* self, const gchar* contact_urn, gboolean is_favourite);

109

gboolean tracker_test_backend_remove_contact (TrackerTestBackend* self, const gchar* tracker_id);

110

gboolean tracker_test_backend_remove_triplet (TrackerTestBackend* self, const gchar* subject_urn, const gchar* pred, const gchar* object_urn);

111

gboolean tracker_test_backend_insert_triplet (TrackerTestBackend* self, const gchar* subject_iri, const gchar* pred, const gchar* object_iri, const gchar* pred_b, const gchar* obj_literal_b, const gchar* pred_c, const gchar* obj_literal_c);

112

gboolean tracker_test_backend_get_debug (TrackerTestBackend* self);

113

static gchar* _tracker_test_backend_get_insert_query (TrackerTestBackend* self, GeeHashMap* contact);

114

static GeeHashMap* _tracker_test_backend_parse_addrs (TrackerTestBackend* self, const gchar* addr_s);

115

static gchar* _tracker_test_backend_build_relation (TrackerTestBackend* self, const gchar* predicate, gchar** objects, int objects_length1);

116

static void tracker_test_backend_finalize (TrackerTestBackend* obj);

117

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);

118

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);

119

static gint _vala_array_length (gpointer array);

120

121

122

GQuark tracker_test_backend_setup_error_quark (void) {

123

return g_quark_from_static_string ("tracker_test_backend_setup_error-quark");

124

}

125

126

127

static void _g_object_unref0_ (gpointer var) {

128

(var == NULL) ? NULL : (var = (g_object_unref (var), NULL));

129

}

130

131

132

static void _g_list_free__g_object_unref0_ (GList* self) {

133

g_list_foreach (self, (GFunc) _g_object_unref0_, NULL);

134

g_list_free (self);

135

}

136

137

138

TrackerTestBackend* tracker_test_backend_construct (GType object_type) {

139

TrackerTestBackend* self = NULL;

140

self = (TrackerTestBackend*) g_type_create_instance (object_type);

141

tracker_test_backend_set_debug (self, FALSE);

142

__g_list_free__g_object_unref0_0 (self->priv->_contacts);

143

self->priv->_contacts = NULL;

144

return self;

145

}

146

147

148

TrackerTestBackend* tracker_test_backend_new (void) {

149

return tracker_test_backend_construct (TRACKER_TEST_TYPE_BACKEND);

150

}

151

152

153

static gpointer _g_object_ref0 (gpointer self) {

154

return self ? g_object_ref (self) : NULL;

155

}

156

157

158

void tracker_test_backend_add_contact (TrackerTestBackend* self, GeeHashMap* c) {

159

GeeHashMap* _tmp0_ = NULL;

160

GeeHashMap* contact;

161

GeeHashMap* _tmp1_;

162

g_return_if_fail (self != NULL);

163

g_return_if_fail (c != NULL);

164

_tmp0_ = _tracker_test_backend_copy_hash_map (self, c);

165

contact = _tmp0_;

166

_tmp1_ = _g_object_ref0 (contact);

167

self->priv->_contacts = g_list_prepend (self->priv->_contacts, _tmp1_);

168

_g_object_unref0 (contact);

169

}

170

171

172

void tracker_test_backend_tear_down (TrackerTestBackend* self) {

173

g_return_if_fail (self != NULL);

174

}

175

176

177

void tracker_test_backend_reset (TrackerTestBackend* self) {

178

g_return_if_fail (self != NULL);

179

__g_list_free__g_object_unref0_0 (self->priv->_contacts);

180

self->priv->_contacts = NULL;

181

}

182

183

184

void tracker_test_backend_set_up (TrackerTestBackend* self) {

185

GError * _inner_error_ = NULL;

186

g_return_if_fail (self != NULL);

187

_tracker_test_backend_setup_connection (self, &_inner_error_);

188

if (_inner_error_ != NULL) {

189

if (_inner_error_->domain == TRACKER_TEST_BACKEND_SETUP_ERROR) {

190

goto __catch0_tracker_test_backend_setup_error;

191

}

192

g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

193

g_clear_error (&_inner_error_);

194

return;

195

}

196

_tracker_test_backend_add_contacts (self, &_inner_error_);

197

if (_inner_error_ != NULL) {

198

if (_inner_error_->domain == TRACKER_TEST_BACKEND_SETUP_ERROR) {

199

goto __catch0_tracker_test_backend_setup_error;

200

}

201

g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

202

g_clear_error (&_inner_error_);

203

return;

204

}

205

goto __finally0;

206

__catch0_tracker_test_backend_setup_error:

207

{

208

GError * e;

209

e = _inner_error_;

210

_inner_error_ = NULL;

211

g_warning ("backend.vala:71: unable to create test data: %s\n", e->message);

212

_g_error_free0 (e);

213

}

214

__finally0:

215

if (_inner_error_ != NULL) {

216

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

217

g_clear_error (&_inner_error_);

218

return;

219

}

220

}

221

222

223

gboolean tracker_test_backend_update_contact (TrackerTestBackend* self, const gchar* contact_urn, const gchar* predicate, const gchar* literal_subject) {

224

gboolean result = FALSE;

225

static const char delete_query_t[] = "DELETE { %s %s ?a } WHERE " "{ ?p a nco:PersonContact " " ; %s ?a . FILTER(?p = %s ) } ";

226

static const char update_query_t[] = "INSERT { %s %s '%s' } ";

227

gchar* _tmp0_ = NULL;

228

gchar* delete_query;

229

gboolean _tmp1_;

230

gchar* _tmp2_ = NULL;

231

gchar* update_query;

232

gboolean _tmp3_;

233

g_return_val_if_fail (self != NULL, FALSE);

234

g_return_val_if_fail (contact_urn != NULL, FALSE);

235

g_return_val_if_fail (predicate != NULL, FALSE);

236

g_return_val_if_fail (literal_subject != NULL, FALSE);

237

_tmp0_ = g_strdup_printf (delete_query_t, contact_urn, predicate, predicate, contact_urn);

238

delete_query = _tmp0_;

239

_tmp1_ = _tracker_test_backend_do_update_query (self, delete_query);

240

if (_tmp1_ == FALSE) {

241

g_warning ("backend.vala:87: Couldn't delete the old triplet");

242

result = FALSE;

243

_g_free0 (delete_query);

244

return result;

245

}

246

_tmp2_ = g_strdup_printf (update_query_t, contact_urn, predicate, literal_subject);

247

update_query = _tmp2_;

248

_tmp3_ = _tracker_test_backend_do_update_query (self, update_query);

249

if (_tmp3_ == FALSE) {

250

g_warning ("backend.vala:95: Couldn't insert the triplet");

251

result = FALSE;

252

_g_free0 (update_query);

253

_g_free0 (delete_query);

254

return result;

255

}

256

result = TRUE;

257

_g_free0 (update_query);

258

_g_free0 (delete_query);

259

return result;

260

}

261

262

263

gboolean tracker_test_backend_update_favourite (TrackerTestBackend* self, const gchar* contact_urn, gboolean is_favourite) {

264

gboolean result = FALSE;

265

gchar* _tmp0_;

266

gchar* q;

267

gchar* _tmp3_;

268

gchar* _tmp4_;

269

gchar* _tmp5_;

270

gboolean _tmp6_;

271

g_return_val_if_fail (self != NULL, FALSE);

272

g_return_val_if_fail (contact_urn != NULL, FALSE);

273

_tmp0_ = g_strdup ("");

274

q = _tmp0_;

275

if (is_favourite) {

276

gchar* _tmp1_;

277

_tmp1_ = g_strconcat (q, "INSERT { ", NULL);

278

_g_free0 (q);

279

q = _tmp1_;

280

} else {

281

gchar* _tmp2_;

282

_tmp2_ = g_strconcat (q, "DELETE { ", NULL);

283

_g_free0 (q);

284

q = _tmp2_;

285

}

286

_tmp3_ = g_strconcat (contact_urn, " nao:hasTag nao:predefined-tag-favorite } ", NULL);

287

_tmp4_ = _tmp3_;

288

_tmp5_ = g_strconcat (q, _tmp4_, NULL);

289

_g_free0 (q);

290

q = _tmp5_;

291

_g_free0 (_tmp4_);

292

_tmp6_ = _tracker_test_backend_do_update_query (self, q);

293

if (_tmp6_ == FALSE) {

294

g_warning ("backend.vala:118: Couldn't change favourite status");

295

result = FALSE;

296

_g_free0 (q);

297

return result;

298

}

299

result = TRUE;

300

_g_free0 (q);

301

return result;

302

}

303

304

305

gboolean tracker_test_backend_remove_contact (TrackerTestBackend* self, const gchar* tracker_id) {

306

gboolean result = FALSE;

307

gchar* _tmp0_;

308

gchar* delete_query;

309

gchar* _tmp1_;

310

gchar* _tmp2_;

311

gchar* _tmp3_;

312

gchar* _tmp4_;

313

gchar* _tmp5_;

314

gchar* _tmp6_;

315

gboolean _tmp7_;

316

g_return_val_if_fail (self != NULL, FALSE);

317

g_return_val_if_fail (tracker_id != NULL, FALSE);

318

_tmp0_ = g_strdup ("DELETE { ?p a nco:PersonContact } ");

319

delete_query = _tmp0_;

320

_tmp1_ = g_strconcat (delete_query, "WHERE { ?p a nco:PersonContact . FILTER(tracker:id(?p) ", NULL);

321

_g_free0 (delete_query);

322

delete_query = _tmp1_;

323

_tmp2_ = g_strconcat ("= ", tracker_id, NULL);

324

_tmp3_ = _tmp2_;

325

_tmp4_ = g_strconcat (_tmp3_, ") } ", NULL);

326

_tmp5_ = _tmp4_;

327

_tmp6_ = g_strconcat (delete_query, _tmp5_, NULL);

328

_g_free0 (delete_query);

329

delete_query = _tmp6_;

330

_g_free0 (_tmp5_);

331

_g_free0 (_tmp3_);

332

_tmp7_ = _tracker_test_backend_do_update_query (self, delete_query);

333

if (_tmp7_ == FALSE) {

334

g_warning ("backend.vala:133: Couldn't delete the contact");

335

result = FALSE;

336

_g_free0 (delete_query);

337

return result;

338

}

339

result = TRUE;

340

_g_free0 (delete_query);

341

return result;

342

}

343

344

345

gboolean tracker_test_backend_remove_triplet (TrackerTestBackend* self, const gchar* subject_urn, const gchar* pred, const gchar* object_urn) {

346

gboolean result = FALSE;

347

TrackerSparqlBuilder* _tmp0_ = NULL;

348

TrackerSparqlBuilder* builder;

349

const gchar* _tmp1_ = NULL;

350

gboolean _tmp2_;

351

g_return_val_if_fail (self != NULL, FALSE);

352

g_return_val_if_fail (subject_urn != NULL, FALSE);

353

g_return_val_if_fail (pred != NULL, FALSE);

354

g_return_val_if_fail (object_urn != NULL, FALSE);

355

_tmp0_ = tracker_sparql_builder_new_update ();

356

builder = _tmp0_;

357

tracker_sparql_builder_delete_open (builder, NULL);

358

tracker_sparql_builder_subject (builder, subject_urn);

359

tracker_sparql_builder_predicate (builder, pred);

360

tracker_sparql_builder_object (builder, object_urn);

361

tracker_sparql_builder_delete_close (builder);

362

_tmp1_ = tracker_sparql_builder_get_result (builder);

363

_tmp2_ = _tracker_test_backend_do_update_query (self, _tmp1_);

364

if (_tmp2_ == FALSE) {

365

const gchar* _tmp3_ = NULL;

366

_tmp3_ = tracker_sparql_builder_get_result (builder);

367

g_warning ("backend.vala:152: Couldn't delete triplet with query: %s\n", _tmp3_);

368

result = FALSE;

369

_g_object_unref0 (builder);

370

return result;

371

}

372

result = TRUE;

373

_g_object_unref0 (builder);

374

return result;

375

}

376

377

378

379

gboolean result = FALSE;

380

TrackerSparqlBuilder* _tmp0_ = NULL;

381

TrackerSparqlBuilder* builder;

382

const gchar* _tmp1_ = NULL;

383

gboolean _tmp2_;

384

g_return_val_if_fail (self != NULL, FALSE);

385

g_return_val_if_fail (subject_iri != NULL, FALSE);

386

g_return_val_if_fail (pred != NULL, FALSE);

387

g_return_val_if_fail (object_iri != NULL, FALSE);

388

_tmp0_ = tracker_sparql_builder_new_update ();

389

builder = _tmp0_;

390

tracker_sparql_builder_insert_open (builder, NULL);

391

tracker_sparql_builder_subject (builder, subject_iri);

392

tracker_sparql_builder_predicate (builder, pred);

393

tracker_sparql_builder_object (builder, object_iri);

394

if (pred_b != NULL) {

395

tracker_sparql_builder_predicate (builder, pred_b);

396

tracker_sparql_builder_object_string (builder, obj_literal_b);

397

}

398

if (pred_c != NULL) {

399

tracker_sparql_builder_predicate (builder, pred_c);

400

tracker_sparql_builder_object_string (builder, obj_literal_c);

401

}

402

tracker_sparql_builder_insert_close (builder);

403

_tmp1_ = tracker_sparql_builder_get_result (builder);

404

_tmp2_ = _tracker_test_backend_do_update_query (self, _tmp1_);

405

if (_tmp2_ == FALSE) {

406

const gchar* _tmp3_ = NULL;

407

_tmp3_ = tracker_sparql_builder_get_result (builder);

408

g_warning ("backend.vala:187: Couldn't insert triplet with query: %s\n", _tmp3_);

409

result = FALSE;

410

_g_object_unref0 (builder);

411

return result;

412

}

413

result = TRUE;

414

_g_object_unref0 (builder);

415

return result;

416

}

417

418

419

static gboolean _tracker_test_backend_do_update_query (TrackerTestBackend* self, const gchar* query) {

420

gboolean result = FALSE;

421

gboolean ret;

422

GError * _inner_error_ = NULL;

423

g_return_val_if_fail (self != NULL, FALSE);

424

g_return_val_if_fail (query != NULL, FALSE);

425

ret = FALSE;

426

if (self->priv->_debug) {

427

fprintf (stdout, "_do_update_query : %s\n", query);

428

}

429

tracker_sparql_connection_update (self->priv->_connection, query, G_PRIORITY_DEFAULT, NULL, &_inner_error_);

430

if (_inner_error_ != NULL) {

431

if (_inner_error_->domain == TRACKER_SPARQL_ERROR) {

432

goto __catch1_tracker_sparql_error;

433

}

434

if (_inner_error_->domain == G_IO_ERROR) {

435

goto __catch1_g_io_error;

436

}

437

if (_inner_error_->domain == G_DBUS_ERROR) {

438

goto __catch1_g_dbus_error;

439

}

440

g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

441

g_clear_error (&_inner_error_);

442

return FALSE;

443

}

444

ret = TRUE;

445

goto __finally1;

446

__catch1_tracker_sparql_error:

447

{

448

GError * e1;

449

e1 = _inner_error_;

450

_inner_error_ = NULL;

451

g_warning ("backend.vala:211: Problem getting connection : %s\n", e1->message);

452

_g_error_free0 (e1);

453

}

454

goto __finally1;

455

__catch1_g_io_error:

456

{

457

GError * e2;

458

e2 = _inner_error_;

459

_inner_error_ = NULL;

460

g_warning ("backend.vala:215: Problem saving data : %s\n", e2->message);

461

_g_error_free0 (e2);

462

}

463

goto __finally1;

464

__catch1_g_dbus_error:

465

{

466

GError * e3;

467

e3 = _inner_error_;

468

_inner_error_ = NULL;

469

g_warning ("backend.vala:219: Problem with the D-Bus connection : %s\n", e3->message);

470

_g_error_free0 (e3);

471

}

472

__finally1:

473

if (_inner_error_ != NULL) {

474

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

475

g_clear_error (&_inner_error_);

476

return FALSE;

477

}

478

result = ret;

479

return result;

480

}

481

482

483

static GeeHashMap* _tracker_test_backend_copy_hash_map (TrackerTestBackend* self, GeeHashMap* orig) {

484

GeeHashMap* result = NULL;

485

GeeHashMap* _tmp0_ = NULL;

486

GeeHashMap* copy;

487

g_return_val_if_fail (self != NULL, NULL);

488

g_return_val_if_fail (orig != NULL, NULL);

489

_tmp0_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);

490

copy = _tmp0_;

491

{

492

GeeSet* _tmp1_ = NULL;

493

GeeSet* _tmp2_;

494

GeeIterator* _tmp3_ = NULL;

495

GeeIterator* _tmp4_;

496

GeeIterator* _k_it;

497

_tmp1_ = gee_map_get_keys ((GeeMap*) orig);

498

_tmp2_ = _tmp1_;

499

_tmp3_ = gee_iterable_iterator ((GeeIterable*) _tmp2_);

500

_tmp4_ = _tmp3_;

501

_g_object_unref0 (_tmp2_);

502

_k_it = _tmp4_;

503

while (TRUE) {

504

gboolean _tmp5_;

505

gpointer _tmp6_ = NULL;

506

gchar* k;

507

gpointer _tmp7_ = NULL;

508

gchar* v;

509

gchar* _tmp8_ = NULL;

510

gchar* _tmp9_;

511

gchar* _tmp10_ = NULL;

512

gchar* _tmp11_;

513

_tmp5_ = gee_iterator_next (_k_it);

514

if (!_tmp5_) {

515

break;

516

}

517

_tmp6_ = gee_iterator_get (_k_it);

518

k = (gchar*) _tmp6_;

519

_tmp7_ = gee_abstract_map_get ((GeeAbstractMap*) orig, k);

520

v = (gchar*) _tmp7_;

521

_tmp8_ = g_strdup (k);

522

_tmp9_ = _tmp8_;

523

_tmp10_ = g_strdup (v);

524

_tmp11_ = _tmp10_;

525

gee_abstract_map_set ((GeeAbstractMap*) copy, _tmp9_, _tmp11_);

526

_g_free0 (_tmp11_);

527

_g_free0 (_tmp9_);

528

_g_free0 (v);

529

_g_free0 (k);

530

}

531

_g_object_unref0 (_k_it);

532

}

533

result = copy;

534

return result;

535

}

536

537

538

static void _tracker_test_backend_setup_connection (TrackerTestBackend* self, GError** error) {

539

TrackerSparqlConnection* _tmp0_ = NULL;

540

TrackerSparqlConnection* _tmp1_;

541

GError * _inner_error_ = NULL;

542

g_return_if_fail (self != NULL);

543

_tmp0_ = tracker_sparql_connection_get (NULL, &_inner_error_);

544

_tmp1_ = _tmp0_;

545

if (_inner_error_ != NULL) {

546

if (_inner_error_->domain == G_IO_ERROR) {

547

goto __catch2_g_io_error;

548

}

549

if (_inner_error_->domain == TRACKER_SPARQL_ERROR) {

550

goto __catch2_tracker_sparql_error;

551

}

552

if (_inner_error_->domain == G_DBUS_ERROR) {

553

goto __catch2_g_dbus_error;

554

}

555

g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

556

g_clear_error (&_inner_error_);

557

return;

558

}

559

_g_object_unref0 (self->priv->_connection);

560

self->priv->_connection = _tmp1_;

561

goto __finally2;

562

__catch2_g_io_error:

563

{

564

GError * e1;

565

GError* _tmp2_ = NULL;

566

e1 = _inner_error_;

567

_inner_error_ = NULL;

568

_tmp2_ = g_error_new (TRACKER_TEST_BACKEND_SETUP_ERROR, TRACKER_TEST_BACKEND_SETUP_ERROR_ADD_CONTACT_FAILED, "Could not connect to D-Bus service : %s\n", e1->message);

569

_inner_error_ = _tmp2_;

570

_g_error_free0 (e1);

571

goto __finally2;

572

}

573

goto __finally2;

574

__catch2_tracker_sparql_error:

575

{

576

GError * e2;

577

GError* _tmp3_ = NULL;

578

e2 = _inner_error_;

579

_inner_error_ = NULL;

580

_tmp3_ = g_error_new (TRACKER_TEST_BACKEND_SETUP_ERROR, TRACKER_TEST_BACKEND_SETUP_ERROR_ADD_CONTACT_FAILED, "Error fetching SPARQL connection handler : %s\n", e2->message);

581

_inner_error_ = _tmp3_;

582

_g_error_free0 (e2);

583

goto __finally2;

584

}

585

goto __finally2;

586

__catch2_g_dbus_error:

587

{

588

GError * e3;

589

GError* _tmp4_ = NULL;

590

e3 = _inner_error_;

591

_inner_error_ = NULL;

592

_tmp4_ = g_error_new (TRACKER_TEST_BACKEND_SETUP_ERROR, TRACKER_TEST_BACKEND_SETUP_ERROR_ADD_CONTACT_FAILED, "Error fetching SPARQL connection handler : %s\n", e3->message);

593

_inner_error_ = _tmp4_;

594

_g_error_free0 (e3);

595

goto __finally2;

596

}

597

__finally2:

598

if (_inner_error_ != NULL) {

599

if (_inner_error_->domain == TRACKER_TEST_BACKEND_SETUP_ERROR) {

600

g_propagate_error (error, _inner_error_);

601

return;

602

} else {

603

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

604

g_clear_error (&_inner_error_);

605

return;

606

}

607

}

608

}

609

610

611

static void _tracker_test_backend_add_contacts (TrackerTestBackend* self, GError** error) {

612

gchar* _tmp0_;

613

gchar* query;

614

GError * _inner_error_ = NULL;

615

g_return_if_fail (self != NULL);

616

_tmp0_ = g_strdup ("");

617

query = _tmp0_;

618

self->priv->_contacts = g_list_reverse (self->priv->_contacts);

619

{

620

GList* c_collection;

621

GList* c_it;

622

c_collection = self->priv->_contacts;

623

for (c_it = c_collection; c_it != NULL; c_it = c_it->next) {

624

GeeHashMap* _tmp1_;

625

GeeHashMap* c;

626

_tmp1_ = _g_object_ref0 ((GeeHashMap*) c_it->data);

627

c = _tmp1_;

628

{

629

gchar* _tmp2_;

630

gchar* _tmp3_;

631

gchar* _tmp4_ = NULL;

632

gchar* _tmp5_;

633

gchar* _tmp6_;

634

_tmp2_ = g_strconcat (query, "\n", NULL);

635

_tmp3_ = _tmp2_;

636

_tmp4_ = _tracker_test_backend_get_insert_query (self, c);

637

_tmp5_ = _tmp4_;

638

_tmp6_ = g_strconcat (_tmp3_, _tmp5_, NULL);

639

_g_free0 (query);

640

query = _tmp6_;

641

_g_free0 (_tmp5_);

642

_g_free0 (_tmp3_);

643

_g_object_unref0 (c);

644

}

645

}

646

}

647

tracker_sparql_connection_update (self->priv->_connection, query, G_PRIORITY_DEFAULT, NULL, &_inner_error_);

648

if (_inner_error_ != NULL) {

649

if (_inner_error_->domain == TRACKER_SPARQL_ERROR) {

650

goto __catch3_tracker_sparql_error;

651

}

652

if (_inner_error_->domain == G_IO_ERROR) {

653

goto __catch3_g_io_error;

654

}

655

if (_inner_error_->domain == G_DBUS_ERROR) {

656

goto __catch3_g_dbus_error;

657

}

658

_g_free0 (query);

659

g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

660

g_clear_error (&_inner_error_);

661

return;

662

}

663

goto __finally3;

664

__catch3_tracker_sparql_error:

665

{

666

GError * e1;

667

GError* _tmp7_ = NULL;

668

e1 = _inner_error_;

669

_inner_error_ = NULL;

670

_tmp7_ = g_error_new (TRACKER_TEST_BACKEND_SETUP_ERROR, TRACKER_TEST_BACKEND_SETUP_ERROR_ADD_CONTACT_FAILED, "Problem getting connection : %s\n", e1->message);

671

_inner_error_ = _tmp7_;

672

_g_error_free0 (e1);

673

goto __finally3;

674

}

675

goto __finally3;

676

__catch3_g_io_error:

677

{

678

GError * e2;

679

GError* _tmp8_ = NULL;

680

e2 = _inner_error_;

681

_inner_error_ = NULL;

682

_tmp8_ = g_error_new (TRACKER_TEST_BACKEND_SETUP_ERROR, TRACKER_TEST_BACKEND_SETUP_ERROR_ADD_CONTACT_FAILED, "Error fetching SPARQL connection handler : %s\n", e2->message);

683

_inner_error_ = _tmp8_;

684

_g_error_free0 (e2);

685

goto __finally3;

686

}

687

goto __finally3;

688

__catch3_g_dbus_error:

689

{

690

GError * e3;

691

GError* _tmp9_ = NULL;

692

e3 = _inner_error_;

693

_inner_error_ = NULL;

694

_tmp9_ = g_error_new (TRACKER_TEST_BACKEND_SETUP_ERROR, TRACKER_TEST_BACKEND_SETUP_ERROR_ADD_CONTACT_FAILED, "Could not connect to D-Bus service : %s\n", e3->message);

695

_inner_error_ = _tmp9_;

696

_g_error_free0 (e3);

697

goto __finally3;

698

}

699

__finally3:

700

if (_inner_error_ != NULL) {

701

if (_inner_error_->domain == TRACKER_TEST_BACKEND_SETUP_ERROR) {

702

g_propagate_error (error, _inner_error_);

703

_g_free0 (query);

704

return;

705

} else {

706

_g_free0 (query);

707

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

708

g_clear_error (&_inner_error_);

709

return;

710

}

711

}

712

_g_free0 (query);

713

}

714

715

716

static gchar* _tracker_test_backend_get_insert_query (TrackerTestBackend* self, GeeHashMap* contact) {

717

gchar* result = NULL;

718

static const char q_photo_uri_t[] = " . <%s> a nfo:Image, " "nie:DataObject ; nie:url '%s' ; nie:title '%s' ";

719

static const char im_addr_t[] = " . <%s> a nco:IMAddress, " "nie:InformationElement; nco:imProtocol " "'%s' ; nco:imID '%s'; " "nco:imNickname '%s'; " "nco:imPresence nco:presence-status-available " " . <%smyimaccount> a nco:IMAccount; " "nco:imDisplayName '%s'; nco:hasIMContact " "<%s> ";

720

static const char affl_t[] = " . <%smyaffiliation> a nco:Affiliation " " . <%smyaffiliation> nco:hasIMAddress " " <%s> ";

721

static const char af_t[] = " . <affl:001> a nco:Affiliation; " "nco:role '%s'; nco:department '%s' ";

722

static const char postal_t[] = " . <affl:001> a nco:Affiliation ; " "nco:hasPostalAddress <postal:001> . " " <postal:001> a nco:PostalAddress ; " "nco:pobox '%s'; " "nco:district '%s'; " "nco:county '%s'; " "nco:locality '%s'; " "nco:postalcode '%s'; " "nco:streetAddress '%s'; " "nco:addressLocation '%s'; " "nco:extendedAddress '%s'; " "nco:country '%s'; " "nco:region '%s' ";

723

gchar* urn_contact = NULL;

724

gpointer _tmp0_ = NULL;

725

gboolean _tmp1_;

726

gchar* _tmp3_;

727

gchar* photo_uri;

728

gchar* _tmp4_;

729

gchar* _tmp5_;

730

gchar* _tmp6_;

731

gchar* _tmp7_;

732

gchar* q;

733

GeeHashMap* addresses;

734

gchar** phones;

735

gint phones_length1;

736

gint _phones_size_;

737

gchar** emails;

738

gint emails_length1;

739

gint _emails_size_;

740

gchar** urls;

741

gint urls_length1;

742

gint _urls_size_;

743

gchar* _tmp8_;

744

gchar* affiliation;

745

gchar* _tmp9_;

746

gchar* postal_address;

747

gboolean _tmp68_ = FALSE;

748

gboolean _tmp82_ = FALSE;

749

gboolean _tmp86_ = FALSE;

750

gboolean _tmp90_ = FALSE;

751

gchar* _tmp107_;

752

g_return_val_if_fail (self != NULL, NULL);

753

g_return_val_if_fail (contact != NULL, NULL);

754

_tmp1_ = gee_abstract_map_unset ((GeeAbstractMap*) contact, TRACKER_TEST_BACKEND_URN, &_tmp0_);

755

_g_free0 (urn_contact);

756

urn_contact = _tmp0_;

757

if (_tmp1_ == FALSE) {

758

gchar* _tmp2_;

759

_tmp2_ = g_strdup ("_:x");

760

_g_free0 (urn_contact);

761

urn_contact = _tmp2_;

762

}

763

_tmp3_ = g_strdup ("");

764

photo_uri = _tmp3_;

765

_tmp4_ = g_strconcat ("INSERT { ", urn_contact, NULL);

766

_tmp5_ = _tmp4_;

767

_tmp6_ = g_strconcat (_tmp5_, " a nco:PersonContact ", NULL);

768

_tmp7_ = _tmp6_;

769

_g_free0 (_tmp5_);

770

q = _tmp7_;

771

addresses = NULL;

772

phones = NULL;

773

phones_length1 = 0;

774

_phones_size_ = 0;

775

emails = NULL;

776

emails_length1 = 0;

777

_emails_size_ = 0;

778

urls = NULL;

779

urls_length1 = 0;

780

_urls_size_ = 0;

781

_tmp8_ = g_strdup ("");

782

affiliation = _tmp8_;

783

_tmp9_ = g_strdup ("");

784

postal_address = _tmp9_;

785

{

786

GeeSet* _tmp10_ = NULL;

787

GeeSet* _tmp11_;

788

GeeIterator* _tmp12_ = NULL;

789

GeeIterator* _tmp13_;

790

GeeIterator* _k_it;

791

_tmp10_ = gee_map_get_keys ((GeeMap*) contact);

792

_tmp11_ = _tmp10_;

793

_tmp12_ = gee_iterable_iterator ((GeeIterable*) _tmp11_);

794

_tmp13_ = _tmp12_;

795

_g_object_unref0 (_tmp11_);

796

_k_it = _tmp13_;

797

while (TRUE) {

798

gboolean _tmp14_;

799

gpointer _tmp15_ = NULL;

800

gchar* k;

801

gpointer _tmp16_ = NULL;

802

gchar* v;

803

gchar* _tmp59_;

804

gchar* _tmp60_;

805

gchar* _tmp61_;

806

gchar* _tmp62_;

807

gchar* _tmp63_;

808

gchar* s;

809

gchar* _tmp64_;

810

_tmp14_ = gee_iterator_next (_k_it);

811

if (!_tmp14_) {

812

break;

813

}

814

_tmp15_ = gee_iterator_get (_k_it);

815

k = (gchar*) _tmp15_;

816

_tmp16_ = gee_abstract_map_get ((GeeAbstractMap*) contact, k);

817

v = (gchar*) _tmp16_;

818

if (g_strcmp0 (k, TRF_ONTOLOGY_DEFS_NCO_PHOTO) == 0) {

819

gchar* _tmp17_;

820

gchar* _tmp18_;

821

gchar* _tmp19_;

822

gchar* _tmp20_;

823

_tmp17_ = g_strdup (v);

824

_g_free0 (photo_uri);

825

photo_uri = _tmp17_;

826

_tmp18_ = g_strconcat ("<", v, NULL);

827

_tmp19_ = _tmp18_;

828

_tmp20_ = g_strconcat (_tmp19_, ">", NULL);

829

_g_free0 (v);

830

v = _tmp20_;

831

_g_free0 (_tmp19_);

832

} else {

833

if (g_strcmp0 (k, TRF_ONTOLOGY_DEFS_NCO_IMADDRESS) == 0) {

834

GeeHashMap* _tmp21_ = NULL;

835

gchar* _tmp22_;

836

gchar* _tmp23_;

837

_tmp21_ = _tracker_test_backend_parse_addrs (self, v);

838

_g_object_unref0 (addresses);

839

addresses = _tmp21_;

840

_tmp22_ = g_strdup ("");

841

_g_free0 (k);

842

k = _tmp22_;

843

_tmp23_ = g_strdup ("");

844

_g_free0 (v);

845

v = _tmp23_;

846

{

847

GeeSet* _tmp24_ = NULL;

848

GeeSet* _tmp25_;

849

GeeIterator* _tmp26_ = NULL;

850

GeeIterator* _tmp27_;

851

GeeIterator* _addr_it;

852

_tmp24_ = gee_map_get_keys ((GeeMap*) addresses);

853

_tmp25_ = _tmp24_;

854

_tmp26_ = gee_iterable_iterator ((GeeIterable*) _tmp25_);

855

_tmp27_ = _tmp26_;

856

_g_object_unref0 (_tmp25_);

857

_addr_it = _tmp27_;

858

while (TRUE) {

859

gboolean _tmp28_;

860

gpointer _tmp29_ = NULL;

861

gchar* addr;

862

gchar* vtemp = NULL;

863

gchar* _tmp30_;

864

gchar* _tmp31_;

865

gchar* _tmp32_;

866

gchar* _tmp33_;

867

gchar* _tmp34_;

868

gchar* _tmp35_;

869

gchar* _tmp37_;

870

_tmp28_ = gee_iterator_next (_addr_it);

871

if (!_tmp28_) {

872

break;

873

}

874

_tmp29_ = gee_iterator_get (_addr_it);

875

addr = (gchar*) _tmp29_;

876

_tmp30_ = g_strdup (" nco:hasAffiliation [ a nco:Affiliation ; ");

877

_g_free0 (vtemp);

878

vtemp = _tmp30_;

879

_tmp31_ = g_strconcat ("nco:hasIMAddress <", addr, NULL);

880

_tmp32_ = _tmp31_;

881

_tmp33_ = g_strconcat (_tmp32_, "> ] ", NULL);

882

_tmp34_ = _tmp33_;

883

_tmp35_ = g_strconcat (vtemp, _tmp34_, NULL);

884

_g_free0 (vtemp);

885

vtemp = _tmp35_;

886

_g_free0 (_tmp34_);

887

_g_free0 (_tmp32_);

888

if (g_strcmp0 (v, "") != 0) {

889

gchar* _tmp36_;

890

_tmp36_ = g_strconcat (v, "; ", NULL);

891

_g_free0 (v);

892

v = _tmp36_;

893

}

894

_tmp37_ = g_strconcat (v, vtemp, NULL);

895

_g_free0 (v);

896

v = _tmp37_;

897

_g_free0 (vtemp);

898

_g_free0 (addr);

899

}

900

_g_object_unref0 (_addr_it);

901

}

902

} else {

903

if (g_strcmp0 (k, TRF_ONTOLOGY_DEFS_NCO_PHONE_PROP) == 0) {

904

gchar** _tmp38_;

905

gchar** _tmp39_ = NULL;

906

gchar* _tmp40_;

907

gchar* _tmp41_ = NULL;

908

_tmp39_ = _tmp38_ = g_strsplit (v, ",", 0);

909

phones = (_vala_array_free (phones, phones_length1, (GDestroyNotify) g_free), NULL);

910

phones = _tmp39_;

911

phones_length1 = _vala_array_length (_tmp38_);

912

_phones_size_ = _vala_array_length (_tmp38_);

913

_tmp40_ = g_strdup ("");

914

_g_free0 (k);

915

k = _tmp40_;

916

_tmp41_ = _tracker_test_backend_build_relation (self, TRF_ONTOLOGY_DEFS_NCO_HAS_AFFILIATION, phones, phones_length1);

917

_g_free0 (v);

918

v = _tmp41_;

919

} else {

920

if (g_strcmp0 (k, TRF_ONTOLOGY_DEFS_NCO_EMAIL_PROP) == 0) {

921

gchar** _tmp42_;

922

gchar** _tmp43_ = NULL;

923

gchar* _tmp44_;

924

gchar* _tmp45_ = NULL;

925

_tmp43_ = _tmp42_ = g_strsplit (v, ",", 0);

926

emails = (_vala_array_free (emails, emails_length1, (GDestroyNotify) g_free), NULL);

927

emails = _tmp43_;

928

emails_length1 = _vala_array_length (_tmp42_);

929

_emails_size_ = _vala_array_length (_tmp42_);

930

_tmp44_ = g_strdup ("");

931

_g_free0 (k);

932

k = _tmp44_;

933

_tmp45_ = _tracker_test_backend_build_relation (self, TRF_ONTOLOGY_DEFS_NCO_HAS_AFFILIATION, emails, emails_length1);

934

_g_free0 (v);

935

v = _tmp45_;

936

} else {

937

if (g_strcmp0 (k, TRACKER_TEST_BACKEND_URLS) == 0) {

938

gchar** _tmp46_;

939

gchar** _tmp47_ = NULL;

940

gchar* _tmp48_;

941

gchar* _tmp49_ = NULL;

942

_tmp47_ = _tmp46_ = g_strsplit (v, ",", 0);

943

urls = (_vala_array_free (urls, urls_length1, (GDestroyNotify) g_free), NULL);

944

urls = _tmp47_;

945

urls_length1 = _vala_array_length (_tmp46_);

946

_urls_size_ = _vala_array_length (_tmp46_);

947

_tmp48_ = g_strdup ("");

948

_g_free0 (k);

949

k = _tmp48_;

950

_tmp49_ = _tracker_test_backend_build_relation (self, TRF_ONTOLOGY_DEFS_NCO_HAS_AFFILIATION, urls, urls_length1);

951

_g_free0 (v);

952

v = _tmp49_;

953

} else {

954

if (g_strcmp0 (k, TRF_ONTOLOGY_DEFS_NAO_TAG) == 0) {

955

gchar* _tmp50_;

956

_tmp50_ = g_strdup (TRF_ONTOLOGY_DEFS_NAO_FAVORITE);

957

_g_free0 (v);

958

v = _tmp50_;

959

} else {

960

if (g_strcmp0 (k, TRF_ONTOLOGY_DEFS_NCO_HAS_AFFILIATION) == 0) {

961

gchar* _tmp51_;

962

gchar* _tmp52_;

963

_tmp51_ = g_strdup (v);

964

_g_free0 (affiliation);

965

affiliation = _tmp51_;

966

_tmp52_ = g_strdup ("<affl:001>");

967

_g_free0 (v);

968

v = _tmp52_;

969

} else {

970

if (g_strcmp0 (k, TRF_ONTOLOGY_DEFS_NCO_GENDER) == 0) {

971

} else {

972

if (g_strcmp0 (k, TRF_ONTOLOGY_DEFS_NCO_POSTAL_ADDRESS) == 0) {

973

gchar* _tmp53_;

974

gchar* _tmp54_;

975

gchar* _tmp55_;

976

_tmp53_ = g_strdup (v);

977

_g_free0 (postal_address);

978

postal_address = _tmp53_;

979

_tmp54_ = g_strdup (TRF_ONTOLOGY_DEFS_NCO_HAS_AFFILIATION);

980

_g_free0 (k);

981

k = _tmp54_;

982

_tmp55_ = g_strdup ("<affl:001>");

983

_g_free0 (v);

984

v = _tmp55_;

985

} else {

986

gchar* _tmp56_;

987

gchar* _tmp57_;

988

gchar* _tmp58_;

989

_tmp56_ = g_strconcat ("'", v, NULL);

990

_tmp57_ = _tmp56_;

991

_tmp58_ = g_strconcat (_tmp57_, "'", NULL);

992

_g_free0 (v);

993

v = _tmp58_;

994

_g_free0 (_tmp57_);

995

}

996

}

997

}

998

}

999

}

1000

}

1001

}

1002

}

1003

}

1004

_tmp59_ = g_strconcat (q, "; ", NULL);

1005

_g_free0 (q);

1006

q = _tmp59_;

1007

_tmp60_ = g_strconcat (k, " ", NULL);

1008

_tmp61_ = _tmp60_;

1009

_tmp62_ = g_strconcat (_tmp61_, v, NULL);

1010

_tmp63_ = _tmp62_;

1011

_g_free0 (_tmp61_);

1012

s = _tmp63_;

1013

_tmp64_ = g_strconcat (q, s, NULL);

1014

_g_free0 (q);

1015

q = _tmp64_;

1016

_g_free0 (s);

1017

_g_free0 (v);

1018

_g_free0 (k);

1019

}

1020

_g_object_unref0 (_k_it);

1021

}

1022

if (g_strcmp0 (photo_uri, "") != 0) {

1023

gchar* _tmp65_ = NULL;

1024

gchar* _tmp66_;

1025

gchar* _tmp67_;

1026

_tmp65_ = g_strdup_printf (q_photo_uri_t, photo_uri, photo_uri, photo_uri);

1027

_tmp66_ = _tmp65_;

1028

_tmp67_ = g_strconcat (q, _tmp66_, NULL);

1029

_g_free0 (q);

1030

q = _tmp67_;

1031

_g_free0 (_tmp66_);

1032

}

1033

if (addresses != NULL) {

1034

gint _tmp69_;

1035

_tmp69_ = gee_map_get_size ((GeeMap*) addresses);

1036

_tmp68_ = _tmp69_ > 0;

1037

} else {

1038

_tmp68_ = FALSE;

1039

}

1040

if (_tmp68_) {

1041

{

1042

GeeSet* _tmp70_ = NULL;

1043

GeeSet* _tmp71_;

1044

GeeIterator* _tmp72_ = NULL;

1045

GeeIterator* _tmp73_;

1046

GeeIterator* _addr_it;

1047

_tmp70_ = gee_map_get_keys ((GeeMap*) addresses);

1048

_tmp71_ = _tmp70_;

1049

_tmp72_ = gee_iterable_iterator ((GeeIterable*) _tmp71_);

1050

_tmp73_ = _tmp72_;

1051

_g_object_unref0 (_tmp71_);

1052

_addr_it = _tmp73_;

1053

while (TRUE) {

1054

gboolean _tmp74_;

1055

gpointer _tmp75_ = NULL;

1056

gchar* addr;

1057

gpointer _tmp76_ = NULL;

1058

gchar* proto;

1059

gchar* _tmp77_ = NULL;

1060

gchar* q1;

1061

gchar* _tmp78_ = NULL;

1062

gchar* q2;

1063

gchar* _tmp79_ = NULL;

1064

gchar* _tmp80_;

1065

gchar* _tmp81_;

1066

_tmp74_ = gee_iterator_next (_addr_it);

1067

if (!_tmp74_) {

1068

break;

1069

}

1070

_tmp75_ = gee_iterator_get (_addr_it);

1071

addr = (gchar*) _tmp75_;

1072

_tmp76_ = gee_abstract_map_get ((GeeAbstractMap*) addresses, addr);

1073

proto = (gchar*) _tmp76_;

1074

_tmp77_ = g_strdup_printf (im_addr_t, addr, proto, addr, addr, addr, addr, addr);

1075

q1 = _tmp77_;

1076

_tmp78_ = g_strdup_printf (affl_t, addr, addr, addr);

1077

q2 = _tmp78_;

1078

_tmp79_ = g_strdup_printf ("%s%s", q1, q2);

1079

_tmp80_ = _tmp79_;

1080

_tmp81_ = g_strconcat (q, _tmp80_, NULL);

1081

_g_free0 (q);

1082

q = _tmp81_;

1083

_g_free0 (_tmp80_);

1084

_g_free0 (q2);

1085

_g_free0 (q1);

1086

_g_free0 (proto);

1087

_g_free0 (addr);

1088

}

1089

_g_object_unref0 (_addr_it);

1090

}

1091

}

1092

if (phones != NULL) {

1093

_tmp82_ = phones_length1 > 0;

1094

} else {

1095

_tmp82_ = FALSE;

1096

}

1097

if (_tmp82_) {

1098

{

1099

gchar** p_collection;

1100

int p_collection_length1;

1101

int p_it;

1102

p_collection = phones;

1103

p_collection_length1 = phones_length1;

1104

for (p_it = 0; p_it < phones_length1; p_it = p_it + 1) {

1105

gchar* _tmp83_;

1106

gchar* p;

1107

_tmp83_ = g_strdup (p_collection[p_it]);

1108

p = _tmp83_;

1109

{

1110

gchar* _tmp84_ = NULL;

1111

gchar* phone_urn;

1112

gchar* _tmp85_ = NULL;

1113

gchar* affl;

1114

_tmp84_ = g_strdup_printf ("<phone:%s>", p);

1115

phone_urn = _tmp84_;

1116

_tmp85_ = g_strdup_printf ("<%s>", p);

1117

affl = _tmp85_;

1118

tracker_test_backend_insert_triplet (self, phone_urn, "a", TRF_ONTOLOGY_DEFS_NCO_PHONE, TRF_ONTOLOGY_DEFS_NCO_PHONE_PROP, p, NULL, NULL);

1119

tracker_test_backend_insert_triplet (self, affl, "a", TRF_ONTOLOGY_DEFS_NCO_AFFILIATION, NULL, NULL, NULL, NULL);

1120

tracker_test_backend_insert_triplet (self, affl, TRF_ONTOLOGY_DEFS_NCO_HAS_PHONE, phone_urn, NULL, NULL, NULL, NULL);

1121

_g_free0 (affl);

1122

_g_free0 (phone_urn);

1123

_g_free0 (p);

1124

}

1125

}

1126

}

1127

}

1128

if (emails != NULL) {

1129

_tmp86_ = emails_length1 > 0;

1130

} else {

1131

_tmp86_ = FALSE;

1132

}

1133

if (_tmp86_) {

1134

{

1135

gchar** p_collection;

1136

int p_collection_length1;

1137

int p_it;

1138

p_collection = emails;

1139

p_collection_length1 = emails_length1;

1140

for (p_it = 0; p_it < emails_length1; p_it = p_it + 1) {

1141

gchar* _tmp87_;

1142

gchar* p;

1143

_tmp87_ = g_strdup (p_collection[p_it]);

1144

p = _tmp87_;

1145

{

1146

gchar* _tmp88_ = NULL;

1147

gchar* email_urn;

1148

gchar* _tmp89_ = NULL;

1149

gchar* affl;

1150

_tmp88_ = g_strdup_printf ("<email:%s>", p);

1151

email_urn = _tmp88_;

1152

_tmp89_ = g_strdup_printf ("<%s>", p);

1153

affl = _tmp89_;

1154

tracker_test_backend_insert_triplet (self, email_urn, "a", TRF_ONTOLOGY_DEFS_NCO_EMAIL, TRF_ONTOLOGY_DEFS_NCO_EMAIL_PROP, p, NULL, NULL);

1155

tracker_test_backend_insert_triplet (self, affl, "a", TRF_ONTOLOGY_DEFS_NCO_AFFILIATION, NULL, NULL, NULL, NULL);

1156

tracker_test_backend_insert_triplet (self, affl, TRF_ONTOLOGY_DEFS_NCO_HAS_EMAIL, email_urn, NULL, NULL, NULL, NULL);

1157

_g_free0 (affl);

1158

_g_free0 (email_urn);

1159

_g_free0 (p);

1160

}

1161

}

1162

}

1163

}

1164

if (urls != NULL) {

1165

_tmp90_ = urls_length1 > 0;

1166

} else {

1167

_tmp90_ = FALSE;

1168

}

1169

if (_tmp90_) {

1170

gint i;

1171

i = 0;

1172

{

1173

gchar** p_collection;

1174

int p_collection_length1;

1175

int p_it;

1176

p_collection = urls;

1177

p_collection_length1 = urls_length1;

1178

for (p_it = 0; p_it < urls_length1; p_it = p_it + 1) {

1179

gchar* _tmp91_;

1180

gchar* p;

1181

_tmp91_ = g_strdup (p_collection[p_it]);

1182

p = _tmp91_;

1183

{

1184

gchar* _tmp92_;

1185

gchar* website_type;

1186

gchar* _tmp93_ = NULL;

1187

gchar* affl;

1188

_tmp92_ = g_strdup ("");

1189

website_type = _tmp92_;

1190

_tmp93_ = g_strdup_printf ("<%s>", p);

1191

affl = _tmp93_;

1192

switch (i % 3) {

1193

case 0:

1194

{

1195

gchar* _tmp94_;

1196

_tmp94_ = g_strdup (TRF_ONTOLOGY_DEFS_NCO_WEBSITE);

1197

_g_free0 (website_type);

1198

website_type = _tmp94_;

1199

break;

1200

}

1201

case 1:

1202

{

1203

gchar* _tmp95_;

1204

_tmp95_ = g_strdup (TRF_ONTOLOGY_DEFS_NCO_BLOG);

1205

_g_free0 (website_type);

1206

website_type = _tmp95_;

1207

break;

1208

}

1209

case 2:

1210

{

1211

gchar* _tmp96_;

1212

_tmp96_ = g_strdup ("nco:url");

1213

_g_free0 (website_type);

1214

website_type = _tmp96_;

1215

break;

1216

}

1217

default:

1218

break;

1219

}

1220

tracker_test_backend_insert_triplet (self, affl, "a", TRF_ONTOLOGY_DEFS_NCO_AFFILIATION, website_type, p, NULL, NULL);

1221

i++;

1222

_g_free0 (affl);

1223

_g_free0 (website_type);

1224

_g_free0 (p);

1225

}

1226

}

1227

}

1228

}

1229

if (g_strcmp0 (affiliation, "") != 0) {

1230

gchar** _tmp97_;

1231

gchar** _tmp98_ = NULL;

1232

gchar** role_info;

1233

gint role_info_length1;

1234

gint _role_info_size_;

1235

gchar* _tmp99_ = NULL;

1236

gchar* _tmp100_;

1237

gchar* _tmp101_;

1238

_tmp98_ = _tmp97_ = g_strsplit (affiliation, ",", 0);

1239

role_info = _tmp98_;

1240

role_info_length1 = _vala_array_length (_tmp97_);

1241

_role_info_size_ = _vala_array_length (_tmp97_);

1242

_tmp99_ = g_strdup_printf (af_t, role_info[0], role_info[1]);

1243

_tmp100_ = _tmp99_;

1244

_tmp101_ = g_strconcat (q, _tmp100_, NULL);

1245

_g_free0 (q);

1246

q = _tmp101_;

1247

_g_free0 (_tmp100_);

1248

role_info = (_vala_array_free (role_info, role_info_length1, (GDestroyNotify) g_free), NULL);

1249

}

1250

if (g_strcmp0 (postal_address, "") != 0) {

1251

gchar** _tmp102_;

1252

gchar** _tmp103_ = NULL;

1253

gchar** postal_info;

1254

gint postal_info_length1;

1255

gint _postal_info_size_;

1256

gchar* _tmp104_ = NULL;

1257

gchar* _tmp105_;

1258

gchar* _tmp106_;

1259

_tmp103_ = _tmp102_ = g_strsplit (postal_address, ":", 0);

1260

postal_info = _tmp103_;

1261

postal_info_length1 = _vala_array_length (_tmp102_);

1262

_postal_info_size_ = _vala_array_length (_tmp102_);

1263

_tmp104_ = g_strdup_printf (postal_t, postal_info[0], postal_info[1], postal_info[2], postal_info[3], postal_info[4], postal_info[5], postal_info[6], postal_info[7], postal_info[8], postal_info[9]);

1264

_tmp105_ = _tmp104_;

1265

_tmp106_ = g_strconcat (q, _tmp105_, NULL);

1266

_g_free0 (q);

1267

q = _tmp106_;

1268

_g_free0 (_tmp105_);

1269

postal_info = (_vala_array_free (postal_info, postal_info_length1, (GDestroyNotify) g_free), NULL);

1270

}

1271

_tmp107_ = g_strconcat (q, " . }", NULL);

1272

_g_free0 (q);

1273

q = _tmp107_;

1274

if (self->priv->_debug) {

1275

fprintf (stdout, "_get_insert_query : %s\n", q);

1276

}

1277

result = q;

1278

_g_free0 (postal_address);

1279

_g_free0 (affiliation);

1280

urls = (_vala_array_free (urls, urls_length1, (GDestroyNotify) g_free), NULL);

1281

emails = (_vala_array_free (emails, emails_length1, (GDestroyNotify) g_free), NULL);

1282

phones = (_vala_array_free (phones, phones_length1, (GDestroyNotify) g_free), NULL);

1283

_g_object_unref0 (addresses);

1284

_g_free0 (photo_uri);

1285

_g_free0 (urn_contact);

1286

return result;

1287

}

1288

1289

1290

static GeeHashMap* _tracker_test_backend_parse_addrs (TrackerTestBackend* self, const gchar* addr_s) {

1291

GeeHashMap* result = NULL;

1292

GeeHashMap* _tmp0_ = NULL;

1293

GeeHashMap* ret;

1294

gchar** _tmp1_;

1295

gchar** _tmp2_ = NULL;

1296

gchar** im_addrs;

1297

gint im_addrs_length1;

1298

gint _im_addrs_size_;

1299

g_return_val_if_fail (self != NULL, NULL);

1300

g_return_val_if_fail (addr_s != NULL, NULL);

1301

_tmp0_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);

1302

ret = _tmp0_;

1303

_tmp2_ = _tmp1_ = g_strsplit (addr_s, ",", 0);

1304

im_addrs = _tmp2_;

1305

im_addrs_length1 = _vala_array_length (_tmp1_);

1306

_im_addrs_size_ = _vala_array_length (_tmp1_);

1307

{

1308

gchar** a_collection;

1309

int a_collection_length1;

1310

int a_it;

1311

a_collection = im_addrs;

1312

a_collection_length1 = im_addrs_length1;

1313

for (a_it = 0; a_it < im_addrs_length1; a_it = a_it + 1) {

1314

gchar* _tmp3_;

1315

gchar* a;

1316

_tmp3_ = g_strdup (a_collection[a_it]);

1317

a = _tmp3_;

1318

{

1319

gchar** _tmp4_;

1320

gchar** _tmp5_ = NULL;

1321

gchar** info;

1322

gint info_length1;

1323

gint _info_size_;

1324

gchar* _tmp6_;

1325

gchar* proto;

1326

gchar* _tmp7_;

1327

gchar* addr;

1328

gchar* _tmp8_;

1329

gchar* _tmp9_;

1330

gchar* _tmp10_;

1331

gchar* _tmp11_;

1332

_tmp5_ = _tmp4_ = g_strsplit (a, "#", 0);

1333

info = _tmp5_;

1334

info_length1 = _vala_array_length (_tmp4_);

1335

_info_size_ = _vala_array_length (_tmp4_);

1336

_tmp6_ = g_strdup (info[0]);

1337

proto = _tmp6_;

1338

_tmp7_ = g_strdup (info[1]);

1339

addr = _tmp7_;

1340

_tmp8_ = addr;

1341

addr = NULL;

1342

_tmp9_ = _tmp8_;

1343

_tmp10_ = proto;

1344

proto = NULL;

1345

_tmp11_ = _tmp10_;

1346

gee_abstract_map_set ((GeeAbstractMap*) ret, _tmp9_, _tmp11_);

1347

_g_free0 (_tmp11_);

1348

_g_free0 (_tmp9_);

1349

_g_free0 (addr);

1350

_g_free0 (proto);

1351

info = (_vala_array_free (info, info_length1, (GDestroyNotify) g_free), NULL);

1352

_g_free0 (a);

1353

}

1354

}

1355

}

1356

result = ret;

1357

im_addrs = (_vala_array_free (im_addrs, im_addrs_length1, (GDestroyNotify) g_free), NULL);

1358

return result;

1359

}

1360

1361

1362

static gchar* _tracker_test_backend_build_relation (TrackerTestBackend* self, const gchar* predicate, gchar** objects, int objects_length1) {

1363

gchar* result = NULL;

1364

gchar* _tmp0_;

1365

gchar* ret;

1366

g_return_val_if_fail (self != NULL, NULL);

1367

g_return_val_if_fail (predicate != NULL, NULL);

1368

_tmp0_ = g_strdup ("");

1369

ret = _tmp0_;

1370

{

1371

gchar** obj_collection;

1372

int obj_collection_length1;

1373

int obj_it;

1374

obj_collection = objects;

1375

obj_collection_length1 = objects_length1;

1376

for (obj_it = 0; obj_it < objects_length1; obj_it = obj_it + 1) {

1377

gchar* _tmp1_;

1378

gchar* obj;

1379

_tmp1_ = g_strdup (obj_collection[obj_it]);

1380

obj = _tmp1_;

1381

{

1382

gchar* vtemp1 = NULL;

1383

gchar* _tmp2_;

1384

gchar* _tmp3_;

1385

gchar* _tmp4_;

1386

gchar* _tmp5_;

1387

gchar* _tmp6_;

1388

gchar* _tmp7_;

1389

gchar* _tmp8_;

1390

gchar* _tmp10_;

1391

_tmp2_ = g_strconcat (" ", predicate, NULL);

1392

_tmp3_ = _tmp2_;

1393

_tmp4_ = g_strconcat (_tmp3_, " <", NULL);

1394

_tmp5_ = _tmp4_;

1395

_tmp6_ = g_strconcat (_tmp5_, obj, NULL);

1396

_tmp7_ = _tmp6_;

1397

_tmp8_ = g_strconcat (_tmp7_, "> ", NULL);

1398

_g_free0 (vtemp1);

1399

vtemp1 = _tmp8_;

1400

_g_free0 (_tmp7_);

1401

_g_free0 (_tmp5_);

1402

_g_free0 (_tmp3_);

1403

if (g_strcmp0 (ret, "") != 0) {

1404

gchar* _tmp9_;

1405

_tmp9_ = g_strconcat (ret, "; ", NULL);

1406

_g_free0 (ret);

1407

ret = _tmp9_;

1408

}

1409

_tmp10_ = g_strconcat (ret, vtemp1, NULL);

1410

_g_free0 (ret);

1411

ret = _tmp10_;

1412

_g_free0 (vtemp1);

1413

_g_free0 (obj);

1414

}

1415

}

1416

}

1417

result = ret;

1418

return result;

1419

}

1420

1421

1422

gboolean tracker_test_backend_get_debug (TrackerTestBackend* self) {

1423

gboolean result;

1424

g_return_val_if_fail (self != NULL, FALSE);

1425

result = self->priv->_debug;

1426

return result;

1427

}

1428

1429

1430

void tracker_test_backend_set_debug (TrackerTestBackend* self, gboolean value) {

1431

g_return_if_fail (self != NULL);

1432

self->priv->_debug = value;

1433

}

1434

1435

1436

static void tracker_test_value_backend_init (GValue* value) {

1437

value->data[0].v_pointer = NULL;

1438

}

1439

1440

1441

static void tracker_test_value_backend_free_value (GValue* value) {

1442

if (value->data[0].v_pointer) {

1443

tracker_test_backend_unref (value->data[0].v_pointer);

1444

}

1445

}

1446

1447

1448

static void tracker_test_value_backend_copy_value (const GValue* src_value, GValue* dest_value) {

1449

if (src_value->data[0].v_pointer) {

1450

dest_value->data[0].v_pointer = tracker_test_backend_ref (src_value->data[0].v_pointer);

1451

} else {

1452

dest_value->data[0].v_pointer = NULL;

1453

}

1454

}

1455

1456

1457

static gpointer tracker_test_value_backend_peek_pointer (const GValue* value) {

1458

return value->data[0].v_pointer;

1459

}

1460

1461

1462

static gchar* tracker_test_value_backend_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1463

if (collect_values[0].v_pointer) {

1464

TrackerTestBackend* object;

1465

object = collect_values[0].v_pointer;

1466

if (object->parent_instance.g_class == NULL) {

1467

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1468

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

1469

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1470

}

1471

value->data[0].v_pointer = tracker_test_backend_ref (object);

1472

} else {

1473

value->data[0].v_pointer = NULL;

1474

}

1475

return NULL;

1476

}

1477

1478

1479

static gchar* tracker_test_value_backend_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1480

TrackerTestBackend** object_p;

1481

object_p = collect_values[0].v_pointer;

1482

if (!object_p) {

1483

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

1484

}

1485

if (!value->data[0].v_pointer) {

1486

*object_p = NULL;

1487

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

1488

*object_p = value->data[0].v_pointer;

1489

} else {

1490

*object_p = tracker_test_backend_ref (value->data[0].v_pointer);

1491

}

1492

return NULL;

1493

}

1494

1495

1496

GParamSpec* tracker_test_param_spec_backend (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

1497

TrackerTestParamSpecBackend* spec;

1498

g_return_val_if_fail (g_type_is_a (object_type, TRACKER_TEST_TYPE_BACKEND), NULL);

1499

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

1500

G_PARAM_SPEC (spec)->value_type = object_type;

1501

return G_PARAM_SPEC (spec);

1502

}

1503

1504

1505

gpointer tracker_test_value_get_backend (const GValue* value) {

1506

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TRACKER_TEST_TYPE_BACKEND), NULL);

1507

return value->data[0].v_pointer;

1508

}

1509

1510

1511

void tracker_test_value_set_backend (GValue* value, gpointer v_object) {

1512

TrackerTestBackend* old;

1513

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TRACKER_TEST_TYPE_BACKEND));

1514

old = value->data[0].v_pointer;

1515

if (v_object) {

1516

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TRACKER_TEST_TYPE_BACKEND));

1517

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1518

value->data[0].v_pointer = v_object;

1519

tracker_test_backend_ref (value->data[0].v_pointer);

1520

} else {

1521

value->data[0].v_pointer = NULL;

1522

}

1523

if (old) {

1524

tracker_test_backend_unref (old);

1525

}

1526

}

1527

1528

1529

void tracker_test_value_take_backend (GValue* value, gpointer v_object) {

1530

TrackerTestBackend* old;

1531

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TRACKER_TEST_TYPE_BACKEND));

1532

old = value->data[0].v_pointer;

1533

if (v_object) {

1534

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TRACKER_TEST_TYPE_BACKEND));

1535

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1536

value->data[0].v_pointer = v_object;

1537

} else {

1538

value->data[0].v_pointer = NULL;

1539

}

1540

if (old) {

1541

tracker_test_backend_unref (old);

1542

}

1543

}

1544

1545

1546

static void tracker_test_backend_class_init (TrackerTestBackendClass * klass) {

1547

tracker_test_backend_parent_class = g_type_class_peek_parent (klass);

1548

TRACKER_TEST_BACKEND_CLASS (klass)->finalize = tracker_test_backend_finalize;

1549

g_type_class_add_private (klass, sizeof (TrackerTestBackendPrivate));

1550

}

1551

1552

1553

static void tracker_test_backend_instance_init (TrackerTestBackend * self) {

1554

self->priv = TRACKER_TEST_BACKEND_GET_PRIVATE (self);

1555

self->ref_count = 1;

1556

}

1557

1558

1559

static void tracker_test_backend_finalize (TrackerTestBackend* obj) {

1560

TrackerTestBackend * self;

1561

self = TRACKER_TEST_BACKEND (obj);

1562

__g_list_free__g_object_unref0_0 (self->priv->_contacts);

1563

_g_object_unref0 (self->priv->_connection);

1564

}

1565

1566

1567

GType tracker_test_backend_get_type (void) {

1568

static volatile gsize tracker_test_backend_type_id__volatile = 0;

1569

if (g_once_init_enter (&tracker_test_backend_type_id__volatile)) {

1570

static const GTypeValueTable g_define_type_value_table = { tracker_test_value_backend_init, tracker_test_value_backend_free_value, tracker_test_value_backend_copy_value, tracker_test_value_backend_peek_pointer, "p", tracker_test_value_backend_collect_value, "p", tracker_test_value_backend_lcopy_value };

1571

static const GTypeInfo g_define_type_info = { sizeof (TrackerTestBackendClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) tracker_test_backend_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TrackerTestBackend), 0, (GInstanceInitFunc) tracker_test_backend_instance_init, &g_define_type_value_table };

1572

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

1573

GType tracker_test_backend_type_id;

1574

tracker_test_backend_type_id = g_type_register_fundamental (g_type_fundamental_next (), "TrackerTestBackend", &g_define_type_info, &g_define_type_fundamental_info, 0);

1575

g_once_init_leave (&tracker_test_backend_type_id__volatile, tracker_test_backend_type_id);

1576

}

1577

return tracker_test_backend_type_id__volatile;

1578

}

1579

1580

1581

gpointer tracker_test_backend_ref (gpointer instance) {

1582

TrackerTestBackend* self;

1583

self = instance;

1584

g_atomic_int_inc (&self->ref_count);

1585

return instance;

1586

}

1587

1588

1589

void tracker_test_backend_unref (gpointer instance) {

1590

TrackerTestBackend* self;

1591

self = instance;

1592

if (g_atomic_int_dec_and_test (&self->ref_count)) {

1593

TRACKER_TEST_BACKEND_GET_CLASS (self)->finalize (self);

1594

g_type_free_instance ((GTypeInstance *) self);

1595

}

1596

}

1597

1598

1599

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {

1600

if ((array != NULL) && (destroy_func != NULL)) {

1601

int i;

1602

for (i = 0; i < array_length; i = i + 1) {

1603

if (((gpointer*) array)[i] != NULL) {

1604

destroy_func (((gpointer*) array)[i]);

1605

}

1606

}

1607

}

1608

}

1609

1610

1611

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {

1612

_vala_array_destroy (array, array_length, destroy_func);

1613

g_free (array);

1614

}

1615

1616

1617

static gint _vala_array_length (gpointer array) {

1618

int length;

1619

length = 0;

1620

if (array) {

1621

while (((gpointer*) array)[length]) {

1622

length++;

1623

}

1624

}

1625

return length;

1626

}

1627

1628

1629

Older »