Grcov report - ipuz-puzzle.c

1

/* ipuz-puzzle.c

2

3

 * Copyright 2022 Jonathan Blandford <jrb@gnome.org>

4

5

 * This library is free software; you can redistribute it and/or

6

 * modify it under the terms of the GNU Lesser General Public

7

 * License as published by the Free Software Foundation; either

8

 * version 2.1 of the License, or (at your option) any later version.

9

10

 * This library is distributed in the hope that it will be useful,

11

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

12

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

13

 * Lesser General Public License for more details.

14

15

 * You should have received a copy of the GNU Lesser General Public

16

 * License along with this library; if not, write to the Free Software

17

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

18

19

 * SPDX-License-Identifier: (LGPL-2.1-or-later OR MIT)

20

*/

21

22

23

24

#include "libipuz.h"

25

#include "libipuz-enums.h"

26

#include <json-glib/json-glib.h>

27

#include "libipuz-config.h"

28

#include <glib/gi18n-lib.h>

29

#include "ipuz-magic.h"

30

#include "ipuz-misc.h"

31

#include "ipuz-puzzle-info-private.h"

32

33

// FIXME: Temporary until this is done in rust

34

6

G_DEFINE_BOXED_TYPE(IPuzCharset, ipuz_charset, ipuz_charset_ref, ipuz_charset_unref);

35

36

37

enum

38

39

  PROP_0,

40

  PROP_PUZZLE_KIND,

41

  PROP_VERSION,

42

  PROP_COPYRIGHT,

43

  PROP_PUBLISHER,

44

  PROP_PUBLICATION,

45

  PROP_URL,

46

  PROP_UNIQUEID,

47

  PROP_TITLE,

48

  PROP_INTRO,

49

  PROP_EXPLANATION,

50

  PROP_ANNOTATION,

51

  PROP_AUTHOR,

52

  PROP_EDITOR,

53

  PROP_DATE,

54

  PROP_NOTES,

55

  PROP_DIFFICULTY,

56

  PROP_CHARSET,

57

  PROP_CHARSET_STR,

58

  PROP_ORIGIN,

59

  PROP_BLOCK,

60

  PROP_EMPTY,

61

  PROP_STYLES,

62

  PROP_LICENSE,

63

  PROP_LOCALE,

64

  N_PROPS

65

};

66

static GParamSpec *obj_props[N_PROPS] = { NULL, };

67

68

struct _IPuzPuzzlePrivate

69

70

  gchar *version;

71

  gchar *copyright;

72

  gchar *publisher;

73

  gchar *publication;

74

  gchar *url;

75

  gchar *uniqueid;

76

  gchar *title;

77

  gchar *intro;

78

  gchar *explanation;

79

  gchar *annotation;

80

  gchar *author;

81

  gchar *editor;

82

  gchar *date;

83

  gchar *notes;

84

  gchar *difficulty;

85

  gchar *origin;

86

  gchar *block;

87

  gchar *empty;

88

  GHashTable *styles;

89

90

  /* Charset */

91

  IPuzCharset *charset;

92

  gchar *charset_str;

93

94

95

  /* Extenstions */

96

  gchar *license;

97

  gchar *locale;

98

99

  /* FIXME(checksum): add support for this */

100

  gchar *checksum_salt;

101

  gchar **checksums;

102

};

103

104

105

typedef struct _IPuzPuzzlePrivate IPuzPuzzlePrivate;

106

107

108

static void                ipuz_puzzle_init                (IPuzPuzzle      *self);

109

static void                ipuz_puzzle_class_init          (IPuzPuzzleClass *klass);

110

static void                ipuz_puzzle_dispose             (GObject         *object);

111

static void                ipuz_puzzle_finalize            (GObject         *object);

112

static void                ipuz_puzzle_set_property        (GObject         *object,

113

                                                            guint            prop_id,

114

                                                            const GValue    *value,

115

                                                            GParamSpec      *pspec);

116

static void                ipuz_puzzle_get_property        (GObject         *object,

117

                                                            guint            prop_id,

118

                                                            GValue          *value,

119

                                                            GParamSpec      *pspec);

120

static void                ipuz_puzzle_real_load_node      (IPuzPuzzle      *puzzle,

121

                                                            const char      *member_name,

122

                                                            JsonNode        *node);

123

static void                ipuz_puzzle_real_post_load_node (IPuzPuzzle      *puzzle,

124

                                                            const char      *member_name,

125

                                                            JsonNode        *node);

126

static void                ipuz_puzzle_real_fixup          (IPuzPuzzle      *puzzle);

127

static void                ipuz_puzzle_real_validate       (IPuzPuzzle      *puzzle);

128

static void                ipuz_puzzle_real_build          (IPuzPuzzle      *puzzle,

129

                                                            JsonBuilder     *builder);

130

static IPuzPuzzleFlags     ipuz_puzzle_real_get_flags      (IPuzPuzzle      *puzzle);

131

static void                ipuz_puzzle_real_calculate_info (IPuzPuzzle      *puzzle,

132

                                                            IPuzPuzzleInfo  *info);

133

static void                ipuz_puzzle_real_clone          (IPuzPuzzle      *src,

134

                                                            IPuzPuzzle      *dest);

135

static const char * const *ipuz_puzzle_real_get_kind_str   (IPuzPuzzle      *puzzle);

136

static void                ipuz_puzzle_real_set_style      (IPuzPuzzle      *puzzle,

137

                                                            const char      *style_name,

138

                                                            IPuzStyle       *style);

139

static gboolean            ipuz_puzzle_real_equal          (IPuzPuzzle      *puzzle_a,

140

                                                            IPuzPuzzle      *puzzle_b);

141

static void                ensure_charset                  (IPuzPuzzle      *self);

142

143

144

6

G_DEFINE_TYPE_WITH_CODE (IPuzPuzzle, ipuz_puzzle, G_TYPE_OBJECT, G_ADD_PRIVATE (IPuzPuzzle));

145

146

147

/*

148

 * Class Methods

149

*/

150

151

static void

152

39

ipuz_puzzle_init (IPuzPuzzle *puzzle)

153

154

  IPuzPuzzlePrivate *priv;

155

156

39

  priv = ipuz_puzzle_get_instance_private (puzzle);

157

158

39

  priv->version = g_strdup (_IPUZ_VERSION_2);

159

39

  priv->block = g_strdup (_IPUZ_DEFAULT_BLOCK);

160

39

  priv->empty = g_strdup (_IPUZ_DEFAULT_EMPTY);

161

162

39

  ensure_charset (puzzle);

163

39

164

165

static void

166

6

ipuz_puzzle_class_init (IPuzPuzzleClass *klass)

167

168

6

  GObjectClass *object_class = G_OBJECT_CLASS(klass);

169

170

6

  object_class->finalize = ipuz_puzzle_finalize;

171

6

  object_class->dispose = ipuz_puzzle_dispose;

172

6

  object_class->set_property = ipuz_puzzle_set_property;

173

6

  object_class->get_property = ipuz_puzzle_get_property;

174

6

  klass->load_node = ipuz_puzzle_real_load_node;

175

6

  klass->post_load_node = ipuz_puzzle_real_post_load_node;

176

6

  klass->fixup = ipuz_puzzle_real_fixup;

177

6

  klass->validate = ipuz_puzzle_real_validate;

178

6

  klass->build = ipuz_puzzle_real_build;

179

6

  klass->get_flags = ipuz_puzzle_real_get_flags;

180

6

  klass->calculate_info = ipuz_puzzle_real_calculate_info;

181

6

  klass->clone = ipuz_puzzle_real_clone;

182

6

  klass->get_kind_str = ipuz_puzzle_real_get_kind_str;

183

6

  klass->set_style = ipuz_puzzle_real_set_style;

184

6

  klass->equal = ipuz_puzzle_real_equal;

185

186

6

  obj_props[PROP_PUZZLE_KIND] = g_param_spec_enum ("puzzle-kind",

187

						   "Puzzle Kind",

188

						   "The type of puzzle",

189

						   I_TYPE_PUZ_PUZZLE_KIND,

190

						   IPUZ_PUZZLE_UNKNOWN,

191

						   G_PARAM_READABLE);

192

6

  obj_props[PROP_VERSION] = g_param_spec_string ("version",

193

						 "Version",

194

						 "Version of ipuz for this puzzle",

195

						 _IPUZ_VERSION_2,

196

                                                 G_PARAM_READWRITE);

197

6

  obj_props[PROP_COPYRIGHT] = g_param_spec_string ("copyright",

198

						   "Copyright",

199

						   "Copyright information",

200

						   NULL,

201

						   G_PARAM_READWRITE);

202

6

  obj_props[PROP_PUBLISHER] = g_param_spec_string ("publisher",

203

						   "Publisher",

204

						   "Name and/or reference for a publisher",

205

						   NULL,

206

						   G_PARAM_READWRITE);

207

6

  obj_props[PROP_PUBLICATION] = g_param_spec_string ("publication",

208

						     "Publication",

209

						     "Bibliographic reference for a published puzzle",

210

						     NULL,

211

						     G_PARAM_READWRITE);

212

6

  obj_props[PROP_URL] = g_param_spec_string ("url",

213

					     "URL",

214

					     "Permanent URL for the puzzle",

215

					     NULL,

216

					     G_PARAM_READWRITE);

217

6

  obj_props[PROP_UNIQUEID] = g_param_spec_string ("uniqueid",

218

						  "Unique ID",

219

						  "Globally unique identifier for the puzzle",

220

						  NULL,

221

						  G_PARAM_READWRITE);

222

6

  obj_props[PROP_TITLE] = g_param_spec_string ("title",

223

					       "Title",

224

					       "Title of puzzle",

225

					       NULL,

226

					       G_PARAM_READWRITE);

227

6

  obj_props[PROP_INTRO] = g_param_spec_string ("intro",

228

					       "Intro",

229

					       "Text displayed above puzzle",

230

					       NULL,

231

					       G_PARAM_READWRITE);

232

6

  obj_props[PROP_EXPLANATION] = g_param_spec_string ("explanation",

233

						     "Explanation",

234

						     "Text displayed after successful solve",

235

						     NULL,

236

						     G_PARAM_READWRITE);

237

6

  obj_props[PROP_ANNOTATION] = g_param_spec_string ("annotation",

238

						    "Annotation",

239

						    "Non-displayed annotation",

240

						    NULL,

241

						    G_PARAM_READWRITE);

242

6

  obj_props[PROP_AUTHOR] = g_param_spec_string ("author",

243

						"Author",

244

						"Author of puzzle",

245

						NULL,

246

						G_PARAM_READWRITE);

247

6

  obj_props[PROP_EDITOR] = g_param_spec_string ("editor",

248

						"Editor",

249

						"Editor of puzzle",

250

						NULL,

251

						G_PARAM_READWRITE);

252

6

  obj_props[PROP_DATE] = g_param_spec_string ("date",

253

					      "Date",

254

					      "Date of puzzle or publication date",

255

					      NULL,

256

					      G_PARAM_READWRITE);

257

6

  obj_props[PROP_NOTES] = g_param_spec_string ("notes",

258

					       "Notes",

259

					       "Notes about the puzzle",

260

					       NULL,

261

					       G_PARAM_READWRITE);

262

6

  obj_props[PROP_DIFFICULTY] = g_param_spec_string ("difficulty",

263

						    "Difficulty",

264

						    "Informational only, there is no standard for difficulty",

265

						    NULL,

266

						    G_PARAM_READWRITE);

267

6

  obj_props[PROP_CHARSET] = g_param_spec_boxed ("charset",

268

                                                "Charset",

269

                                                "Characters that can be entered in the puzzle",

270

						 IPUZ_TYPE_CHARSET,

271

						 G_PARAM_READWRITE);

272

6

  obj_props[PROP_CHARSET_STR] = g_param_spec_string ("charset-str",

273

                                                     "Charset String",

274

                                                     "Characters that can be entered in the puzzle, in string form",

275

                                                     NULL,

276

                                                     G_PARAM_READWRITE);

277

6

  obj_props[PROP_ORIGIN] = g_param_spec_string ("origin",

278

						"Origin",

279

						"Program-specific information from program that wrote this file",

280

						NULL,

281

						G_PARAM_READWRITE);

282

6

  obj_props[PROP_BLOCK] = g_param_spec_string ("block",

283

					       "Block",

284

					       "Text value which represents a block",

285

					       _IPUZ_DEFAULT_BLOCK,

286

					       G_PARAM_READWRITE);

287

6

  obj_props[PROP_EMPTY] = g_param_spec_string ("empty",

288

					       "Empty",

289

					       "Value which represents an empty cell",

290

					       _IPUZ_DEFAULT_EMPTY,

291

					       G_PARAM_READWRITE);

292

6

  obj_props[PROP_STYLES] = g_param_spec_boxed ("styles",

293

                                               "Styles",

294

                                               "Named styles for the puzzle",

295

                                               G_TYPE_HASH_TABLE,

296

                                               G_PARAM_READWRITE);

297

6

  obj_props[PROP_LICENSE] = g_param_spec_string ("license",

298

                                                 "License",

299

                                                 "License of the puzzle",

300

                                                 NULL,

301

                                                 G_PARAM_READWRITE);

302

6

  obj_props[PROP_LOCALE] = g_param_spec_string ("locale",

303

                                                "Locale",

304

                                                "Locale of the puzzle",

305

                                                _IPUZ_DEFAULT_LOCALE,

306

                                                G_PARAM_READWRITE);

307

6

  g_object_class_install_properties (object_class, N_PROPS, obj_props);

308

309

  /* I'm not sure where else to put this. */

310

6

  bindtextdomain (GETTEXT_PACKAGE, LIBIPUZ_LOCALEDIR);

311

6

  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

312

313

6

314

315

316

/* drop all refs */

317

static void

318

39

ipuz_puzzle_dispose (GObject *object)

319

320

  IPuzPuzzlePrivate *priv;

321

322

39

  priv = ipuz_puzzle_get_instance_private (IPUZ_PUZZLE (object));

323

324

39

  g_clear_pointer (&priv->styles, g_hash_table_unref);

325

39

  G_OBJECT_CLASS (ipuz_puzzle_parent_class)->dispose (object);

326

39

327

328

/* free all memory */

329

static void

330

39

ipuz_puzzle_finalize (GObject *object)

331

332

  IPuzPuzzlePrivate *priv;

333

334

39

  g_return_if_fail (object != NULL);

335

336

39

  priv = ipuz_puzzle_get_instance_private (IPUZ_PUZZLE (object));

337

338

39

  g_free (priv->version);

339

39

  g_free (priv->copyright);

340

39

  g_free (priv->publisher);

341

39

  g_free (priv->publication);

342

39

  g_free (priv->url);

343

39

  g_free (priv->uniqueid);

344

39

  g_free (priv->title);

345

39

  g_free (priv->intro);

346

39

  g_free (priv->explanation);

347

39

  g_free (priv->annotation);

348

39

  g_free (priv->author);

349

39

  g_free (priv->editor);

350

39

  g_free (priv->date);

351

39

  g_free (priv->notes);

352

39

  g_free (priv->difficulty);

353

39

  g_clear_pointer (&priv->charset, ipuz_charset_unref);

354

39

  g_free (priv->charset_str);

355

39

  g_free (priv->origin);

356

39

  g_free (priv->block);

357

39

  g_free (priv->empty);

358

39

  g_free (priv->license);

359

39

  g_free (priv->locale);

360

39

  g_free (priv->checksum_salt);

361

39

  g_strfreev (priv->checksums);

362

363

39

  if (priv->styles)

364

365

      g_hash_table_unref (priv->styles);

366

367

368

39

  G_OBJECT_CLASS (ipuz_puzzle_parent_class)->finalize (object);

369

370

371

372

static void

373

202

ipuz_puzzle_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)

374

375

  IPuzPuzzle *self;

376

  IPuzPuzzlePrivate *priv;

377

378

202

  g_return_if_fail (object != NULL);

379

380

202

  self = IPUZ_PUZZLE (object);

381

202

  priv = ipuz_puzzle_get_instance_private (self);

382

383

202

  switch (prop_id)

384

385

64

    case PROP_VERSION:

386

64

      g_free (priv->version);

387

64

      priv->version = g_value_dup_string (value);

388

64

      break;

389

    case PROP_COPYRIGHT:

390

      g_free (priv->copyright);

391

      priv->copyright = g_value_dup_string (value);

392

      break;

393

15

    case PROP_PUBLISHER:

394

15

      g_free (priv->publisher);

395

15

      priv->publisher = ipuz_html_to_markup (g_value_get_string (value));

396

15

      break;

397

    case PROP_PUBLICATION:

398

      g_free (priv->publication);

399

      priv->publication = ipuz_html_to_markup (g_value_get_string (value));

400

      break;

401

    case PROP_URL:

402

      g_free (priv->url);

403

      priv->url = g_value_dup_string (value);

404

      break;

405

    case PROP_UNIQUEID:

406

      g_free (priv->uniqueid);

407

      priv->uniqueid = g_value_dup_string (value);

408

      break;

409

26

    case PROP_TITLE:

410

26

      g_free (priv->title);

411

26

      priv->title = ipuz_html_to_markup (g_value_get_string (value));

412

26

      break;

413

8

    case PROP_INTRO:

414

8

      g_free (priv->intro);

415

8

      priv->intro = ipuz_html_to_markup (g_value_get_string (value));

416

8

      break;

417

    case PROP_EXPLANATION:

418

      g_free (priv->explanation);

419

      priv->explanation = ipuz_html_to_markup (g_value_get_string (value));

420

      break;

421

    case PROP_ANNOTATION:

422

      g_free (priv->annotation);

423

      priv->annotation = g_value_dup_string (value);

424

      break;

425

26

    case PROP_AUTHOR:

426

26

      g_free (priv->author);

427

26

      priv->author = ipuz_html_to_markup (g_value_get_string (value));

428

26

      break;

429

    case PROP_EDITOR:

430

      g_free (priv->editor);

431

      priv->editor = ipuz_html_to_markup (g_value_get_string (value));

432

      break;

433

24

    case PROP_DATE:

434

24

      g_free (priv->date);

435

24

      priv->date = g_value_dup_string (value);

436

24

      break;

437

12

    case PROP_NOTES:

438

12

      g_free (priv->notes);

439

12

      priv->notes = ipuz_html_to_markup (g_value_get_string (value));

440

12

      break;

441

    case PROP_DIFFICULTY:

442

      g_free (priv->difficulty);

443

      priv->difficulty = ipuz_html_to_markup (g_value_get_string (value));

444

      break;

445

    case PROP_CHARSET:

446

      ipuz_puzzle_set_charset (self, g_value_get_boxed (value));

447

      break;

448

2

    case PROP_CHARSET_STR:

449

2

      ipuz_puzzle_set_charset_str (self, g_value_get_string (value));

450

2

      break;

451

8

    case PROP_ORIGIN:

452

8

      g_free (priv->origin);

453

8

      priv->origin = g_value_dup_string (value);

454

8

      break;

455

8

    case PROP_BLOCK:

456

8

      g_free (priv->block);

457

8

      priv->block = g_value_dup_string (value);

458

8

      if (priv->block == NULL)

459

        priv->block = g_strdup (_IPUZ_DEFAULT_BLOCK);

460

8

      break;

461

5

    case PROP_EMPTY:

462

5

      g_free (priv->empty);

463

5

      priv->empty = g_value_dup_string(value);

464

5

      if (priv->empty == NULL)

465

        priv->empty = g_strdup (_IPUZ_DEFAULT_EMPTY);

466

5

      break;

467

    case PROP_STYLES:

468

      if (priv->styles)

469

        g_hash_table_unref (priv->styles);

470

      priv->styles = g_value_dup_boxed (value);

471

      break;

472

4

    case PROP_LICENSE:

473

4

      g_free (priv->license);

474

4

      priv->license = g_value_dup_string (value);

475

4

      break;

476

    case PROP_LOCALE:

477

      g_free (priv->locale);

478

      priv->locale = g_value_dup_string(value);

479

      if (priv->locale == NULL)

480

        priv->locale = g_strdup (_IPUZ_DEFAULT_LOCALE);

481

      break;

482

    default:

483

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

484

      break;

485

486

487

488

static void

489

276

ipuz_puzzle_get_property (GObject    *object,

490

                          guint       prop_id,

491

                          GValue     *value,

492

                          GParamSpec *pspec)

493

494

  IPuzPuzzle *self;

495

  IPuzPuzzlePrivate *priv;

496

497

276

  g_return_if_fail (object != NULL);

498

499

276

  self = IPUZ_PUZZLE (object);

500

276

  priv = ipuz_puzzle_get_instance_private (self);

501

502

276

  switch (prop_id)

503

504

    case PROP_PUZZLE_KIND:

505

      g_value_set_enum (value, ipuz_puzzle_get_puzzle_kind (self));

506

      break;

507

2

    case PROP_VERSION:

508

2

      g_value_set_string (value, priv->version);

509

2

      break;

510

6

    case PROP_COPYRIGHT:

511

6

      g_value_set_string (value, priv->copyright);

512

6

      break;

513

6

    case PROP_PUBLISHER:

514

6

      g_value_set_string (value, priv->publisher);

515

6

      break;

516

6

    case PROP_PUBLICATION:

517

6

      g_value_set_string (value, priv->publication);

518

6

      break;

519

6

    case PROP_URL:

520

6

      g_value_set_string (value, priv->url);

521

6

      break;

522

6

    case PROP_UNIQUEID:

523

6

      g_value_set_string (value, priv->uniqueid);

524

6

      break;

525

6

    case PROP_TITLE:

526

6

      g_value_set_string (value, priv->title);

527

6

      break;

528

6

    case PROP_INTRO:

529

6

      g_value_set_string (value, priv->intro);

530

6

      break;

531

6

    case PROP_EXPLANATION:

532

6

      g_value_set_string (value, priv->explanation);

533

6

      break;

534

6

    case PROP_ANNOTATION:

535

6

      g_value_set_string (value, priv->annotation);

536

6

      break;

537

6

    case PROP_AUTHOR:

538

6

      g_value_set_string (value, priv->author);

539

6

      break;

540

6

    case PROP_EDITOR:

541

6

      g_value_set_string (value, priv->editor);

542

6

      break;

543

6

    case PROP_DATE:

544

6

      g_value_set_string (value, priv->date);

545

6

      break;

546

6

    case PROP_NOTES:

547

6

      g_value_set_string (value, priv->notes);

548

6

      break;

549

6

    case PROP_DIFFICULTY:

550

6

      g_value_set_string (value, priv->difficulty);

551

6

      break;

552

    case PROP_CHARSET:

553

      g_value_set_boxed (value, ipuz_puzzle_get_charset (self));

554

      break;

555

36

    case PROP_CHARSET_STR:

556

36

      g_value_set_string (value, ipuz_puzzle_get_charset_str (self));

557

36

      break;

558

6

    case PROP_ORIGIN:

559

6

      g_value_set_string (value, priv->origin);

560

6

      break;

561

70

    case PROP_BLOCK:

562

70

      if (priv->block)

563

70

        g_value_set_string (value, priv->block);

564

      else

565

        g_value_set_string (value, _IPUZ_DEFAULT_BLOCK);

566

70

      break;

567

40

    case PROP_EMPTY:

568

40

      if (priv->empty)

569

40

        g_value_set_string (value, priv->empty);

570

      else

571

        g_value_set_string (value, _IPUZ_DEFAULT_EMPTY);

572

40

      break;

573

34

    case PROP_STYLES:

574

34

      g_value_set_boxed (value, priv->styles);

575

34

      break;

576

2

    case PROP_LICENSE:

577

2

      g_value_set_string (value, priv->license);

578

2

      break;

579

2

    case PROP_LOCALE:

580

2

      g_value_set_string (value, priv->locale);

581

2

      break;

582

    default:

583

      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

584

      break;

585

586

587

588

static GHashTable *

589

4

new_styles_hash_table (void)

590

591

4

  return g_hash_table_new_full (g_str_hash, g_str_equal,

592

                                (GDestroyNotify) g_free,

593

                                (GDestroyNotify) ipuz_style_unref);

594

595

596

static void

597

4

ipuz_puzzle_real_load_styles (IPuzPuzzle *puzzle,

598

                              JsonNode   *node)

599

600

  IPuzPuzzlePrivate *priv;

601

4

  priv = ipuz_puzzle_get_instance_private (puzzle);

602

4

  JsonObjectIter iter = {0, };

603

4

  const gchar *member_name = NULL;

604

  JsonNode *member_node;

605

606

4

  if (!JSON_NODE_HOLDS_OBJECT (node))

607

    return;

608

609

4

  if (priv->styles == NULL)

610

4

    priv->styles = new_styles_hash_table ();

611

612

4

  json_object_iter_init (&iter, json_node_get_object (node));

613

23

  while (json_object_iter_next (&iter, &member_name, &member_node))

614

615

15

      IPuzStyle *style = ipuz_style_new_from_json (member_node);

616

15

      ipuz_style_set_style_name (style, member_name);

617

15

      if (style != NULL)

618

15

        g_hash_table_insert (priv->styles, g_strdup (member_name), style);

619

620

621

622

static void

623

296

ipuz_puzzle_real_load_node (IPuzPuzzle *puzzle,

624

                            const char *member_name,

625

                            JsonNode   *node)

626

627

  GObjectClass *object_class;

628

  GParamSpec *pspec;

629

296

  GValue value = G_VALUE_INIT;

630

631

296

  object_class = G_OBJECT_GET_CLASS (puzzle);

632

633

  /* styles isn't a simple property and needs manually loading */

634

296

  if (!g_strcmp0 (member_name, "styles"))

635

636

4

      ipuz_puzzle_real_load_styles (puzzle, node);

637

296

      return;

638

639

640

  /* Handle extensions separately */

641

580

  if (!g_strcmp0 (member_name, _IPUZ_X_LICENSE_TAG) ||

642

288

      !g_strcmp0 (member_name, _IPUZ_X_GNOME_LICENSE_TAG))

643

644

4

      json_node_get_value (node, &value);

645

4

      g_object_set_property (G_OBJECT (puzzle), "license", &value);

646

4

      g_value_unset (&value);

647

4

      return;

648

649

650

576

  if (!g_strcmp0 (member_name, _IPUZ_X_LOCALE_TAG) ||

651

288

      !g_strcmp0 (member_name, _IPUZ_X_GNOME_LOCALE_TAG))

652

653

      json_node_get_value (node, &value);

654

      g_object_set_property (G_OBJECT (puzzle), "locale", &value);

655

      g_value_unset (&value);

656

      return;

657

658

659

  /* Handle charsets a little differently. The property "charset"

660

   * isn't a string, but is "charset-str" instead */

661

288

  if (!g_strcmp0 (member_name, "charset"))

662

663

2

      json_node_get_value (node, &value);

664

2

      ipuz_puzzle_set_charset_str (puzzle, g_value_get_string (&value));

665

2

      g_value_unset (&value);

666

2

      return;

667

668

669

  /* handle a standard property */

670

286

  pspec = g_object_class_find_property (object_class, member_name);

671

286

  if (pspec == NULL)

672

94

    return;

673

674

  /* We don't do as comprehensive a job as the serializable interface, just

675

   * automatically handle strings and booleans. Everything else needs a custom

676

   * parser.

677

*/

678

679

192

  switch (G_PARAM_SPEC_VALUE_TYPE (pspec))

680

681

166

    case G_TYPE_STRING:

682

166

      if (JSON_NODE_HOLDS_VALUE (node))

683

684

166

          json_node_get_value (node, &value);

685

166

          g_object_set_property (G_OBJECT (puzzle), pspec->name, &value);

686

166

          g_value_unset (&value);

687

688

166

      return;

689

26

    case G_TYPE_BOOLEAN:

690

26

      if (JSON_NODE_HOLDS_VALUE (node))

691

692

26

          g_value_init (&value, G_TYPE_BOOLEAN);

693

26

          g_value_set_boolean (&value, json_node_get_boolean (node));

694

26

          g_object_set_property (G_OBJECT (puzzle), pspec->name, &value);

695

696

26

      return;

697

    default:

698

      g_warning ("unable to convert %s", pspec->name);

699

      break;

700

701

702

703

static void

704

ipuz_puzzle_real_post_load_node (IPuzPuzzle *puzzle,

705

                                 const char *member_name,

706

                                 JsonNode   *node)

707

708

  /* Empty function. Guard against accidentally being called by a subtype. */

709

710

711

712

static void

713

32

ipuz_puzzle_real_fixup (IPuzPuzzle *puzzle)

714

715

  /* Empty function. Guard against accidentally being called by a subtype. */

716

32

717

718

static void

719

32

ipuz_puzzle_real_validate (IPuzPuzzle *puzzle)

720

721

  /* FIXME: Implement someday */

722

32

723

724

static void

725

2

build_kind (IPuzPuzzle  *puzzle,

726

            JsonBuilder *builder)

727

728

  IPuzPuzzleClass *klass;

729

2

  const gchar *const *kind_str = NULL;

730

731

2

  klass = IPUZ_PUZZLE_GET_CLASS (puzzle);

732

2

  kind_str = klass->get_kind_str (puzzle);

733

734

2

  json_builder_set_member_name (builder, "kind");

735

2

  json_builder_begin_array (builder);

736

737

2

  if (kind_str == NULL)

738

739

      json_builder_add_string_value (builder, "http://ipuz.org/crossword#1");

740

741

  else

742

743

2

      guint i = 0;

744

745

4

      while (kind_str[i] != NULL)

746

747

2

          json_builder_add_string_value (builder, kind_str[i]);

748

2

          i++;

749

750

751

2

  json_builder_end_array (builder);

752

2

753

754

static void

755

42

build_string_param (IPuzPuzzle  *puzzle,

756

                    GParamSpec  *pspec,

757

                    JsonBuilder *builder)

758

759

  const gchar *name;

760

42

  GValue value = G_VALUE_INIT;

761

762

42

  name = g_param_spec_get_name (pspec);

763

764

42

  g_value_init (&value, G_TYPE_STRING);

765

766

42

  g_object_get_property (G_OBJECT (puzzle), name, &value);

767

42

  if (g_value_get_string (&value) != NULL)

768

769

20

      if (!g_strcmp0 (name, "license"))

770

1

        name = _IPUZ_X_LICENSE_TAG;

771

19

      else if (!g_strcmp0 (name, "locale"))

772

        name = _IPUZ_X_LOCALE_TAG;

773

774

20

      json_builder_set_member_name (builder, name);

775

20

      json_builder_add_string_value (builder, g_value_get_string (&value));

776

777

42

  g_value_unset (&value);

778

42

779

780

781

static void

782

build_styles_foreach (const char  *style_name,

783

                      IPuzStyle   *style,

784

                      JsonBuilder *builder)

785

786

  g_return_if_fail (style_name != NULL);

787

  g_return_if_fail (style != NULL);

788

789

  json_builder_set_member_name (builder, style_name);

790

  ipuz_style_build (style, builder);

791

792

793

static void

794

2

build_styles (IPuzPuzzle  *puzzle,

795

              JsonBuilder *builder)

796

797

  IPuzPuzzlePrivate *priv;

798

799

2

  priv = ipuz_puzzle_get_instance_private (puzzle);

800

2

  if (priv->styles == NULL)

801

2

    return;

802

803

  json_builder_set_member_name (builder, "styles");

804

  json_builder_begin_object (builder);

805

  g_hash_table_foreach (priv->styles, (GHFunc) build_styles_foreach, builder);

806

  json_builder_end_object (builder);

807

808

809

static void

810

2

ipuz_puzzle_real_build (IPuzPuzzle  *puzzle,

811

                        JsonBuilder *builder)

812

813

  /* Print the version and kind */

814

2

  build_kind (puzzle, builder);

815

816

  /* Print the string properties */

817

  guint i;

818

50

  for (i = PROP_0 + 1; i < N_PROPS; i++)

819

820

48

      if (G_PARAM_SPEC_VALUE_TYPE (obj_props[i]) == G_TYPE_STRING)

821

42

        build_string_param (puzzle, obj_props[i], builder);

822

823

824

  /* Print puzzle-wide styles */

825

2

  build_styles (puzzle, builder);

826

827

  /* FIXME(checksum): write this */

828

  /* build_checksum (puzzle, builder); */

829

2

830

831

static IPuzPuzzleFlags

832

2

ipuz_puzzle_real_get_flags (IPuzPuzzle *puzzle)

833

834

  IPuzPuzzlePrivate *priv;

835

2

  guint flags = 0;

836

837

2

  priv = ipuz_puzzle_get_instance_private (puzzle);

838

839

2

  if (priv->checksums != NULL)

840

    flags |= IPUZ_PUZZLE_FLAG_HAS_CHECKSUM;

841

842

2

  return flags;

843

844

845

static void

846

2

ipuz_puzzle_real_calculate_info (IPuzPuzzle      *puzzle,

847

                                 IPuzPuzzleInfo  *info)

848

849

  IPuzPuzzlePrivate *priv;

850

  IPuzCharsetBuilder *builder;

851

2

  g_autofree gchar *charset_str = NULL;

852

853

2

  g_assert (IPUZ_IS_PUZZLE (puzzle));

854

2

  g_assert (IPUZ_IS_PUZZLE_INFO (info));

855

856

2

  priv = ipuz_puzzle_get_instance_private (puzzle);

857

858

2

  charset_str = ipuz_charset_serialize (ipuz_puzzle_get_charset (puzzle));

859

2

  builder = ipuz_charset_builder_new_from_text (charset_str);

860

2

  info->charset = ipuz_charset_builder_build (builder);

861

862

2

  if (priv->checksums != NULL)

863

    info->flags |= IPUZ_PUZZLE_FLAG_HAS_CHECKSUM;

864

2

865

866

static void

867

styles_copy_func (const gchar *key,

868

                  IPuzStyle   *style,

869

                  GHashTable  *dest_styles)

870

871

  IPuzStyle *new_style;

872

873

  new_style = ipuz_style_copy (style);

874

  g_hash_table_insert (dest_styles, g_strdup (key), new_style);

875

876

877

static void

878

2

ipuz_puzzle_real_clone (IPuzPuzzle *src,

879

                        IPuzPuzzle *dest)

880

881

  IPuzPuzzlePrivate *src_priv, *dest_priv;

882

883

2

  g_return_if_fail (dest != NULL);

884

885

2

  src_priv = ipuz_puzzle_get_instance_private (src);

886

2

  dest_priv = ipuz_puzzle_get_instance_private (dest);

887

888

2

  g_clear_pointer (&dest_priv->version, g_free);

889

2

  dest_priv->version = g_strdup (src_priv->version);

890

891

2

  g_clear_pointer (&dest_priv->copyright, g_free);

892

2

  dest_priv->copyright = g_strdup (src_priv->copyright);

893

894

2

  g_clear_pointer (&dest_priv->publisher, g_free);

895

2

  dest_priv->publisher = g_strdup (src_priv->publisher);

896

897

2

  g_clear_pointer (&dest_priv->publication, g_free);

898

2

  dest_priv->publication = g_strdup (src_priv->publication);

899

900

2

  g_clear_pointer (&dest_priv->url, g_free);

901

2

  dest_priv->url = g_strdup (src_priv->url);

902

903

2

  g_clear_pointer (&dest_priv->uniqueid, g_free);

904

2

  dest_priv->uniqueid = g_strdup (src_priv->uniqueid);

905

906

2

  g_clear_pointer (&dest_priv->title, g_free);

907

2

  dest_priv->title = g_strdup (src_priv->title);

908

909

2

  g_clear_pointer (&dest_priv->intro, g_free);

910

2

  dest_priv->intro = g_strdup (src_priv->intro);

911

912

2

  g_clear_pointer (&dest_priv->explanation, g_free);

913

2

  dest_priv->explanation = g_strdup (src_priv->explanation);

914

915

2

  g_clear_pointer (&dest_priv->annotation, g_free);

916

2

  dest_priv->annotation = g_strdup (src_priv->annotation);

917

918

2

  g_clear_pointer (&dest_priv->author, g_free);

919

2

  dest_priv->author = g_strdup (src_priv->author);

920

921

2

  g_clear_pointer (&dest_priv->editor, g_free);

922

2

  dest_priv->editor = g_strdup (src_priv->editor);

923

924

2

  g_clear_pointer (&dest_priv->date, g_free);

925

2

  dest_priv->date = g_strdup (src_priv->date);

926

927

2

  g_clear_pointer (&dest_priv->notes, g_free);

928

2

  dest_priv->notes = g_strdup (src_priv->notes);

929

930

2

  g_clear_pointer (&dest_priv->difficulty, g_free);

931

2

  dest_priv->difficulty = g_strdup (src_priv->difficulty);

932

933

2

  g_clear_pointer (&dest_priv->charset_str, g_free);

934

2

  dest_priv->charset_str = g_strdup (src_priv->charset_str);

935

936

2

  g_clear_pointer (&dest_priv->origin, g_free);

937

2

  dest_priv->origin = g_strdup (src_priv->origin);

938

939

2

  g_clear_pointer (&dest_priv->block, g_free);

940

2

  dest_priv->block = g_strdup (src_priv->block);

941

942

2

  g_clear_pointer (&dest_priv->empty, g_free);

943

2

  dest_priv->empty = g_strdup (src_priv->empty);

944

945

2

  g_clear_pointer (&dest_priv->styles, g_hash_table_unref);

946

2

  if (src_priv->styles)

947

948

      dest_priv->styles = new_styles_hash_table ();

949

      g_hash_table_foreach (src_priv->styles, (GHFunc) styles_copy_func, dest_priv->styles);

950

951

952

2

  g_clear_pointer (&dest_priv->license, g_free);

953

2

  dest_priv->license = g_strdup (src_priv->license);

954

955

2

  g_clear_pointer (&dest_priv->locale, g_free);

956

2

  dest_priv->locale = g_strdup (src_priv->locale);

957

958

2

  g_clear_pointer (&dest_priv->checksum_salt, g_free);

959

2

  dest_priv->checksum_salt = g_strdup (src_priv->checksum_salt);

960

961

2

  g_clear_pointer (&dest_priv->checksums, g_strfreev);

962

2

  dest_priv->checksums = g_strdupv (src_priv->checksums);

963

964

2

  ensure_charset (dest);

965

966

967

static const char * const *

968

ipuz_puzzle_real_get_kind_str (IPuzPuzzle *puzzle)

969

970

  return NULL;

971

972

973

static void

974

3

ipuz_puzzle_real_set_style (IPuzPuzzle *puzzle,

975

                            const char *style_name,

976

                            IPuzStyle  *style)

977

978

  IPuzPuzzlePrivate *priv;

979

980

3

  g_return_if_fail (IPUZ_IS_PUZZLE (puzzle));

981

982

3

  priv = ipuz_puzzle_get_instance_private (puzzle);

983

984

3

  if (priv->styles == NULL)

985

    priv->styles = new_styles_hash_table ();

986

987

3

  if (style == NULL)

988

    g_hash_table_remove (priv->styles, style_name);

989

  else

990

3

    g_hash_table_replace (priv->styles, g_strdup (style_name), ipuz_style_ref (style));

991

992

993

static gboolean

994

3

ipuz_puzzle_real_equal (IPuzPuzzle *puzzle_a,

995

                        IPuzPuzzle *puzzle_b)

996

997

  IPuzPuzzlePrivate *priv_a, *priv_b;

998

3

  priv_a = ipuz_puzzle_get_instance_private (puzzle_a);

999

3

  priv_b = ipuz_puzzle_get_instance_private (puzzle_b);

1000

1001

3

  if (priv_a->checksums)

1002

1003

      if (priv_b->checksums == NULL)

1004

        return FALSE;

1005

1006

      for (int i = 0; priv_a->checksums[i] != NULL; i++)

1007

1008

          if (g_strcmp0 (priv_a->checksums[i], priv_b->checksums[i]) != 0)

1009

            return FALSE;

1010

1011

1012

3

  else if (priv_b->checksums)

1013

    return FALSE;

1014

1015

3

  if (priv_a->styles)

1016

1017

      if (priv_b->styles == NULL)

1018

        return FALSE;

1019

1020

      GHashTableIter iter;

1021

      gpointer key, value;

1022

1023

      g_hash_table_iter_init (&iter, priv_a->styles);

1024

1025

      while (g_hash_table_iter_next (&iter, &key, &value))

1026

1027

          if (! ipuz_style_equal (g_hash_table_lookup (priv_b->styles, key), value))

1028

            return FALSE;

1029

1030

1031

3

  else if (priv_b->styles)

1032

    return FALSE;

1033

1034

3

  return (!g_strcmp0 (priv_a->version, priv_b->version)

1035

3

          && !g_strcmp0 (priv_a->copyright, priv_b->copyright)

1036

3

          && !g_strcmp0 (priv_a->publisher, priv_b->publisher)

1037

3

          && !g_strcmp0 (priv_a->publication, priv_b->publication)

1038

3

          && !g_strcmp0 (priv_a->url, priv_b->url)

1039

3

          && !g_strcmp0 (priv_a->uniqueid, priv_b->uniqueid)

1040

3

          && !g_strcmp0 (priv_a->title, priv_b->title)

1041

3

          && !g_strcmp0 (priv_a->intro, priv_b->intro)

1042

3

          && !g_strcmp0 (priv_a->explanation, priv_b->explanation)

1043

3

          && !g_strcmp0 (priv_a->annotation, priv_b->annotation)

1044

3

          && !g_strcmp0 (priv_a->author, priv_b->author)

1045

3

          && !g_strcmp0 (priv_a->editor, priv_b->editor)

1046

3

          && !g_strcmp0 (priv_a->date, priv_b->date)

1047

3

          && !g_strcmp0 (priv_a->notes, priv_b->notes)

1048

3

          && !g_strcmp0 (priv_a->difficulty, priv_b->difficulty)

1049

3

          && !g_strcmp0 (priv_a->charset_str, priv_b->charset_str)

1050

3

          && !g_strcmp0 (priv_a->origin, priv_b->origin)

1051

3

          && !g_strcmp0 (priv_a->block, priv_b->block)

1052

3

          && !g_strcmp0 (priv_a->empty, priv_b->empty)

1053

3

          && !g_strcmp0 (priv_a->license, priv_b->license)

1054

3

          && !g_strcmp0 (priv_a->locale, priv_b->locale)

1055

6

          && !g_strcmp0 (priv_a->checksum_salt, priv_b->checksum_salt));

1056

1057

1058

/*

1059

 * Helper functions

1060

*/

1061

1062

/**

1063

 * Confirm that the version is one we can support.

1064

*/

1065

static const gchar *

1066

32

ipuz_puzzle_valid_puzzle_version (JsonNode  *root,

1067

                                  GError   **error)

1068

1069

32

  g_return_val_if_fail (error !=NULL && *error == NULL, NULL);

1070

1071

64

  g_autoptr (JsonPath) path = json_path_new ();

1072

32

  json_path_compile (path, "$.version", NULL);

1073

64

  g_autoptr (JsonNode) result = json_path_match (path, root);

1074

1075

32

  if (result == NULL)

1076

1077

      *error = g_error_new (IPUZ_ERROR, IPUZ_ERROR_INVALID_FILE, _("Missing version tag."));

1078

      return NULL;

1079

1080

1081

32

  JsonArray *arr = json_node_get_array (result);

1082

32

  JsonNode *element = json_array_get_element (arr, 0);

1083

32

  const gchar *str = json_node_get_string (element);

1084

1085

  /* I don't know what version 1 really is, but we see them in the

1086

   * wild occasionally and they seem to load fine */

1087

32

  if (g_strcmp0 (str, _IPUZ_VERSION_1) == 0)

1088

    return _IPUZ_VERSION_1;

1089

32

  else if (g_strcmp0 (str, _IPUZ_VERSION_2) == 0)

1090

32

    return _IPUZ_VERSION_2;

1091

1092

  *error = g_error_new (IPUZ_ERROR, IPUZ_ERROR_WRONG_VERSION, _("Unhandled version: %s"), str);

1093

  return NULL;

1094

1095

1096

gboolean

1097

219

check_kind_version (const gchar *str,

1098

                    const gchar *prefix,

1099

                    gint         version)

1100

1101

  size_t len;

1102

1103

219

  g_return_val_if_fail (str != NULL, FALSE);

1104

219

  g_return_val_if_fail (prefix != NULL, FALSE);

1105

1106

219

  len = strlen (prefix);

1107

219

  if (strncmp (str, prefix, len) == 0)

1108

1109

42

      if (str[len] == '#') /* Check for an optional version */

1110

1111

42

          guint64 puz_version = g_ascii_strtoull (str + (len + 1), NULL, 10);

1112

42

          if ((gint) puz_version <= version)

1113

42

            return TRUE;

1114

1115

      else if (! str[len]) /* We support unversioned puzzles */

1116

        return TRUE;

1117

1118

1119

177

  return FALSE;

1120

1121

1122

/**

1123

 * Figure out what kind of puzzle

1124

*/

1125

static IPuzPuzzleKind

1126

32

ipuz_puzzle_parse_kind (JsonNode  *root,

1127

                        GError   **error)

1128

1129

32

  g_autoptr (JsonPath) path = NULL;

1130

32

  g_autoptr (JsonNode) result = NULL;

1131

  JsonArray *array;

1132

32

  IPuzPuzzleKind kind = IPUZ_PUZZLE_UNKNOWN;

1133

1134

  /* We use json path as we're not ready to walk the tree yet */

1135

32

  path = json_path_new ();

1136

32

  json_path_compile (path, "$.kind[*]", NULL);

1137

32

  result = json_path_match (path, root);

1138

1139

32

  if (result == NULL)

1140

1141

      *error = g_error_new (IPUZ_ERROR, IPUZ_ERROR_INVALID_FILE, _("Missing the kind tag. This doesn't look like an ipuz file."));

1142

      return IPUZ_PUZZLE_UNKNOWN;

1143

1144

1145

32

  array = json_node_get_array (result);

1146

74

  for (guint i = 0; i < json_array_get_length (array); i++)

1147

1148

      JsonNode *element;

1149

      const gchar *str;

1150

1151

42

      element = json_array_get_element (array, i);

1152

42

      if (!JSON_NODE_HOLDS_VALUE (element))

1153

        continue;

1154

42

      str = json_node_get_string (element);

1155

42

      if (str == NULL)

1156

        continue;

1157

1158

42

      if (check_kind_version (str, _IPUZ_ARROWWORD_PREFIX, _IPUZ_ARROWWORD_VERSION))

1159

1160

          if (kind == IPUZ_PUZZLE_UNKNOWN ||

1161

              kind == IPUZ_PUZZLE_CROSSWORD)

1162

            kind = IPUZ_PUZZLE_ARROWWORD;

1163

          continue;

1164

1165

42

      else if (check_kind_version (str, _IPUZ_BARRED_PREFIX, _IPUZ_BARRED_VERSION))

1166

1167

3

          if (kind == IPUZ_PUZZLE_UNKNOWN ||

1168

              kind == IPUZ_PUZZLE_CROSSWORD)

1169

3

            kind = IPUZ_PUZZLE_BARRED;

1170

3

          continue;

1171

1172

39

      else if (check_kind_version (str, _IPUZ_FILIPPINE_PREFIX, _IPUZ_FILIPPINE_VERSION))

1173

1174

          if (kind == IPUZ_PUZZLE_UNKNOWN ||

1175

              kind == IPUZ_PUZZLE_CROSSWORD)

1176

            kind = IPUZ_PUZZLE_FILIPPINE;

1177

          continue;

1178

1179

39

      else if (check_kind_version (str, _IPUZ_CRYPTIC_PREFIX, _IPUZ_CRYPTIC_VERSION))

1180

1181

7

          if (kind == IPUZ_PUZZLE_UNKNOWN ||

1182

              kind == IPUZ_PUZZLE_CROSSWORD)

1183

7

            kind = IPUZ_PUZZLE_CRYPTIC;

1184

7

          continue;

1185

1186

32

      else if (check_kind_version (str, _IPUZ_ACROSTIC_PREFIX, _IPUZ_ACROSTIC_VERSION))

1187

1188

7

          if (kind == IPUZ_PUZZLE_UNKNOWN ||

1189

	      kind == IPUZ_PUZZLE_CROSSWORD)

1190

7

            kind = IPUZ_PUZZLE_ACROSTIC;

1191

7

          continue;

1192

1193

25

      else if (check_kind_version (str, _IPUZ_CROSSWORD_PREFIX, _IPUZ_CROSSWORD_VERSION))

1194

1195

25

          if (kind == IPUZ_PUZZLE_UNKNOWN)

1196

25

            kind = IPUZ_PUZZLE_CROSSWORD;

1197

25

          continue;

1198

1199

1200

32

  return kind;

1201

1202

1203

1204

static void

1205

358

ipuz_puzzle_new_foreach (JsonObject  *object,

1206

                         const gchar *member_name,

1207

                         JsonNode    *member_node,

1208

                         IPuzPuzzle  *puzzle)

1209

1210

  IPuzPuzzleClass *klass;

1211

1212

358

  klass = IPUZ_PUZZLE_GET_CLASS (puzzle);

1213

358

  g_return_if_fail (klass->load_node != NULL);

1214

1215

358

  klass->load_node (puzzle, member_name, member_node);

1216

1217

1218

static void

1219

358

ipuz_puzzle_new_foreach_post (JsonObject  *object,

1220

                              const gchar *member_name,

1221

                              JsonNode    *member_node,

1222

                              IPuzPuzzle  *puzzle)

1223

1224

  IPuzPuzzleClass *klass;

1225

1226

358

  klass = IPUZ_PUZZLE_GET_CLASS (puzzle);

1227

1228

358

  if (klass->post_load_node)

1229

358

    klass->post_load_node (puzzle, member_name, member_node);

1230

358

1231

1232

IPuzPuzzle *

1233

32

ipuz_puzzle_new_from_json (JsonNode  *root,

1234

                           GError   **error)

1235

1236

32

  GError *tmp_error = NULL;

1237

32

  IPuzPuzzle *puzzle = NULL;

1238

  IPuzPuzzleKind kind;

1239

  const gchar *ipuz_version;

1240

1241

32

  g_return_val_if_fail (root != NULL, NULL);

1242

1243

32

  if (!JSON_NODE_HOLDS_OBJECT (root))

1244

1245

      if (error)

1246

        *error = g_error_new (IPUZ_ERROR, IPUZ_ERROR_INVALID_FILE, "The first element isn't an object");

1247

      return NULL;

1248

1249

1250

32

  ipuz_version = ipuz_puzzle_valid_puzzle_version (root, &tmp_error);

1251

32

  if (tmp_error != NULL)

1252

1253

      g_propagate_error (error, tmp_error);

1254

      return NULL;

1255

1256

1257

32

  kind = ipuz_puzzle_parse_kind (root, &tmp_error);

1258

32

  if (tmp_error != NULL)

1259

1260

      g_propagate_error (error, tmp_error);

1261

      return NULL;

1262

1263

1264

32

  if (kind == IPUZ_PUZZLE_UNKNOWN)

1265

1266

      if (error)

1267

        *error = g_error_new (IPUZ_ERROR, IPUZ_ERROR_INVALID_FILE, "Unknown puzzle type");

1268

      return NULL;

1269

1270

1271

32

  switch (kind)

1272

1273

15

    case IPUZ_PUZZLE_CROSSWORD:

1274

15

      puzzle = g_object_new (IPUZ_TYPE_CROSSWORD,

1275

                             "version", ipuz_version,

1276

                             NULL);

1277

15

      break;

1278

    case IPUZ_PUZZLE_ARROWWORD:

1279

      puzzle = g_object_new (IPUZ_TYPE_ARROWWORD,

1280

                             "version", ipuz_version,

1281

                             NULL);

1282

      break;

1283

3

    case IPUZ_PUZZLE_BARRED:

1284

3

      puzzle = g_object_new (IPUZ_TYPE_BARRED,

1285

                             "version", ipuz_version,

1286

                             NULL);

1287

3

      break;

1288

7

    case IPUZ_PUZZLE_CRYPTIC:

1289

7

      puzzle = g_object_new (IPUZ_TYPE_CRYPTIC,

1290

                             "version", ipuz_version,

1291

                             NULL);

1292

7

      break;

1293

    case IPUZ_PUZZLE_FILIPPINE:

1294

      puzzle = g_object_new (IPUZ_TYPE_FILIPPINE,

1295

                             "version", ipuz_version,

1296

                             NULL);

1297

      break;

1298

7

    case IPUZ_PUZZLE_ACROSTIC:

1299

7

      puzzle = g_object_new (IPUZ_TYPE_ACROSTIC,

1300

                             "version", ipuz_version,

1301

                             NULL);

1302

7

      break;

1303

    default:

1304

      g_assert_not_reached ();

1305

1306

1307

  /* Load the puzzle as best as we can */

1308

32

  IPuzPuzzleClass *klass = IPUZ_PUZZLE_GET_CLASS (puzzle);

1309

32

  JsonObject *object = json_node_get_object (root);

1310

32

  g_object_freeze_notify (G_OBJECT (puzzle));

1311

1312

  /* We do a multi-pass parse. See parsing-strategy.md for more information */

1313

32

  json_object_foreach_member (object, (JsonObjectForeach) ipuz_puzzle_new_foreach, puzzle);

1314

32

  json_object_foreach_member (object, (JsonObjectForeach) ipuz_puzzle_new_foreach_post, puzzle);

1315

32

  klass->fixup (puzzle);

1316

32

  klass->validate (puzzle);

1317

1318

32

  g_object_thaw_notify (G_OBJECT (puzzle));

1319

1320

32

  return puzzle;

1321

1322

1323

IPuzPuzzle *

1324

30

ipuz_puzzle_new_from_file (const char  *filename,

1325

                           GError     **error)

1326

1327

30

  GError *tmp_error = NULL;

1328

30

  g_autoptr(JsonParser) parser = NULL;

1329

1330

30

  g_return_val_if_fail (filename != NULL, NULL);

1331

1332

30

  parser = json_parser_new ();

1333

30

  json_parser_load_from_file (parser, filename, &tmp_error);

1334

30

  if (tmp_error != NULL)

1335

1336

      g_propagate_error (error, tmp_error);

1337

      return NULL;

1338

1339

1340

30

  return ipuz_puzzle_new_from_json (json_parser_get_root (parser), error);

1341

1342

1343

IPuzPuzzle *

1344

ipuz_puzzle_new_from_stream (GInputStream  *stream,

1345

                             GCancellable  *cancellable,

1346

                             GError       **error)

1347

1348

  GError *tmp_error = NULL;

1349

  g_autoptr(JsonParser) parser = NULL;

1350

1351

  g_return_val_if_fail (G_IS_INPUT_STREAM (stream), NULL);

1352

1353

  parser = json_parser_new ();

1354

  json_parser_load_from_stream (parser, stream, cancellable, &tmp_error);

1355

  if (tmp_error != NULL)

1356

1357

      g_propagate_error (error, tmp_error);

1358

      return NULL;

1359

1360

1361

  return ipuz_puzzle_new_from_json (json_parser_get_root (parser), error);

1362

1363

1364

IPuzPuzzle *

1365

2

ipuz_puzzle_new_from_data (const gchar   *data,

1366

                           gsize          length,

1367

                           GError       **error)

1368

1369

2

  GError *tmp_error = NULL;

1370

2

  g_autoptr(JsonParser) parser = NULL;

1371

1372

2

  g_return_val_if_fail (data != NULL, NULL);

1373

1374

2

  parser = json_parser_new ();

1375

2

  json_parser_load_from_data (parser, data, length, &tmp_error);

1376

2

  if (tmp_error != NULL)

1377

1378

      g_propagate_error (error, tmp_error);

1379

      return NULL;

1380

1381

1382

2

  return ipuz_puzzle_new_from_json (json_parser_get_root (parser), error);

1383

1384

1385

1386

1387

static JsonGenerator *

1388

2

ipuz_puzzle_get_generator (IPuzPuzzle *puzzle)

1389

1390

2

  g_autoptr (JsonBuilder) builder = NULL;

1391

  JsonGenerator *generator;

1392

  IPuzPuzzleClass *klass;

1393

4

  g_autoptr (JsonNode) root = NULL;

1394

1395

1396

2

  klass = IPUZ_PUZZLE_GET_CLASS (puzzle);

1397

1398

2

  builder = json_builder_new ();

1399

2

  json_builder_begin_object (builder);

1400

1401

2

  generator = json_generator_new ();

1402

2

  json_generator_set_pretty (generator, TRUE);

1403

1404

2

  if (klass->build)

1405

2

    klass->build (puzzle, builder);

1406

1407

2

  json_builder_end_object (builder);

1408

2

  root = json_builder_get_root (builder);

1409

2

  json_generator_set_root (generator, root);

1410

1411

2

  return generator;

1412

1413

1414

1415

gboolean

1416

ipuz_puzzle_save_to_file (IPuzPuzzle  *puzzle,

1417

                          const char  *filename,

1418

                          GError     **error)

1419

1420

  g_autoptr (JsonGenerator) generator = NULL;

1421

1422

  g_return_val_if_fail (IPUZ_IS_PUZZLE (puzzle), FALSE);

1423

1424

  generator = ipuz_puzzle_get_generator (puzzle);

1425

  return json_generator_to_file (generator, filename, error);

1426

1427

1428

gboolean

1429

ipuz_puzzle_save_to_stream (IPuzPuzzle     *puzzle,

1430

                            GOutputStream  *stream,

1431

                            GCancellable   *cancellable,

1432

                            GError        **error)

1433

1434

  g_autoptr (JsonGenerator) generator = NULL;

1435

1436

  g_return_val_if_fail (IPUZ_IS_PUZZLE (puzzle), FALSE);

1437

  g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream), FALSE);

1438

1439

  generator = ipuz_puzzle_get_generator (puzzle);

1440

  return json_generator_to_stream (generator, stream, cancellable, error);

1441

1442

1443

1444

gchar *

1445

2

ipuz_puzzle_save_to_data (IPuzPuzzle *puzzle,

1446

                          gsize      *length)

1447

1448

2

  g_autoptr (JsonGenerator) generator = NULL;

1449

1450

2

  g_return_val_if_fail (IPUZ_IS_PUZZLE (puzzle), NULL);

1451

1452

2

  generator = ipuz_puzzle_get_generator (puzzle);

1453

1454

2

  return json_generator_to_data (generator, length);

1455

1456

1457

/**

1458

 * ipuz_puzzle_get_puzzle_kind:

1459

 * @self: An #IPuzPuzzle

1460

1461

 * Returns the type of puzzle of @self. This can be more useful than

1462

 * the GType for switch statements or other conditionals.

1463

1464

 * Note, this only returns the more specific type. So a cryptic

1465

 * crossword will return #IPUZ_PUZZLE_CRYPTIC and not

1466

 * #IPUZ_PUZZLE_CROSSWORD.

1467

1468

 * Returns: The puzzle kind

1469

**/

1470

IPuzPuzzleKind

1471

ipuz_puzzle_get_puzzle_kind (IPuzPuzzle *self)

1472

1473

  g_return_val_if_fail (IPUZ_IS_PUZZLE (self), IPUZ_PUZZLE_UNKNOWN);

1474

1475

  if (IPUZ_IS_ACROSTIC (self))

1476

    return IPUZ_PUZZLE_ACROSTIC;

1477

  else if (IPUZ_IS_ARROWWORD (self))

1478

    return IPUZ_PUZZLE_ARROWWORD;

1479

  else if (IPUZ_IS_BARRED (self))

1480

    return IPUZ_PUZZLE_BARRED;

1481

  else if (IPUZ_IS_CRYPTIC (self))

1482

    return IPUZ_PUZZLE_CRYPTIC;

1483

  else if (IPUZ_IS_FILIPPINE (self))

1484

    return IPUZ_PUZZLE_FILIPPINE;

1485

  /* Crossword has to be last otherwise the ones that inherit from it

1486

   * will trigger this boolean */

1487

  else if (IPUZ_IS_CROSSWORD (self))

1488

    return IPUZ_PUZZLE_CROSSWORD;

1489

1490

  return IPUZ_PUZZLE_UNKNOWN;

1491

1492

1493

/**

1494

 * ipuz_puzzle_get_flags:

1495

 * @puzzle: An `IPuzPuzzle`

1496

1497

 * Indicates static properties about the puzzle at load time.

1498

1499

 * Returns: flags, with properties about the puzzle

1500

**/

1501

IPuzPuzzleFlags

1502

2

ipuz_puzzle_get_flags (IPuzPuzzle *puzzle)

1503

1504

  IPuzPuzzleClass *klass;

1505

1506

2

  g_return_val_if_fail (IPUZ_IS_PUZZLE (puzzle), 0);

1507

1508

2

  klass = IPUZ_PUZZLE_GET_CLASS (puzzle);

1509

1510

2

  return klass->get_flags (puzzle);

1511

1512

1513

/**

1514

 * ipuz_puzzle_get_info:

1515

 * @puzzle: An `IPuzPuzzle`

1516

1517

 * Calculates information about the current state of @puzzle. This

1518

 * information is not kept in sync with the puzzle, so if there are

1519

 * any changes to it it will have to be recalculated.

1520

1521

 * Returns: a newly allocated `IPuzPuzzleInfo` object

1522

**/

1523

IPuzPuzzleInfo *

1524

2

ipuz_puzzle_get_info (IPuzPuzzle *puzzle)

1525

1526

  IPuzPuzzleClass *klass;

1527

  IPuzPuzzleInfo *info;

1528

1529

2

  g_return_val_if_fail (IPUZ_IS_PUZZLE (puzzle), 0);

1530

1531

2

  klass = IPUZ_PUZZLE_GET_CLASS (puzzle);

1532

2

  info = g_object_new (IPUZ_TYPE_PUZZLE_INFO, NULL);

1533

1534

2

  klass->calculate_info (puzzle, info);

1535

1536

2

  return info;

1537

1538

1539

IPuzPuzzle *

1540

2

ipuz_puzzle_deep_copy (IPuzPuzzle *src)

1541

1542

  IPuzPuzzle *dest;

1543

  IPuzPuzzleClass *klass;

1544

1545

  /* We allow NULL puzzles to return */

1546

2

  if (src == NULL)

1547

    return NULL;

1548

2

  g_return_val_if_fail (IPUZ_IS_PUZZLE (src), NULL);

1549

1550

2

  dest = g_object_new (G_TYPE_FROM_INSTANCE (src), NULL);

1551

1552

2

  klass = IPUZ_PUZZLE_GET_CLASS (src);

1553

2

  klass->clone (src, dest);

1554

1555

2

  return dest;

1556

1557

1558

gboolean

1559

3

ipuz_puzzle_equal (IPuzPuzzle *puzzle_a,

1560

                   IPuzPuzzle *puzzle_b)

1561

1562

  IPuzPuzzleClass *klass;

1563

1564

3

  g_return_val_if_fail (IPUZ_IS_PUZZLE (puzzle_a), FALSE);

1565

3

  g_return_val_if_fail (IPUZ_IS_PUZZLE (puzzle_b), FALSE);

1566

1567

3

  klass = IPUZ_PUZZLE_GET_CLASS (puzzle_a);

1568

1569

3

  return klass->equal (puzzle_a, puzzle_b);

1570

1571

1572

/* Getters and Setters */

1573

1574

1575

static void

1576

403

ensure_charset (IPuzPuzzle *self)

1577

1578

  IPuzPuzzlePrivate *priv;

1579

403

  IPuzCharsetBuilder *builder = NULL;

1580

1581

403

  priv = ipuz_puzzle_get_instance_private (self);

1582

1583

403

  if (priv->charset && priv->charset_str)

1584

364

    return;

1585

1586

39

  if (priv->charset == NULL)

1587

1588

39

      if (priv->charset_str)

1589

        builder = ipuz_charset_builder_new_from_text (priv->charset_str);

1590

39

      else if (priv->locale)

1591

        builder = ipuz_charset_builder_new_for_language (priv->locale);

1592

      else

1593

39

        builder = ipuz_charset_builder_new_for_language ("C");

1594

1595

39

      priv->charset = ipuz_charset_builder_build (builder);

1596

1597

1598

39

  if (priv->charset_str == NULL)

1599

39

    priv->charset_str = ipuz_charset_serialize (priv->charset);

1600

1601

1602

IPuzCharset *

1603

326

ipuz_puzzle_get_charset (IPuzPuzzle *self)

1604

1605

  IPuzPuzzlePrivate *priv;

1606

1607

326

  g_return_val_if_fail (IPUZ_IS_PUZZLE (self), NULL);

1608

1609

326

  priv = ipuz_puzzle_get_instance_private (self);

1610

326

  ensure_charset (self);

1611

1612

326

  return priv->charset;

1613

1614

1615

void

1616

ipuz_puzzle_set_charset (IPuzPuzzle  *self,

1617

                         IPuzCharset *charset)

1618

1619

  IPuzPuzzlePrivate *priv;

1620

1621

  g_return_if_fail (IPUZ_IS_PUZZLE (self));

1622

1623

  priv = ipuz_puzzle_get_instance_private (self);

1624

1625

  g_clear_pointer (&priv->charset_str, g_free);

1626

  g_clear_pointer (&priv->charset, ipuz_charset_unref);

1627

1628

  priv->charset = ipuz_charset_ref (charset);

1629

  ensure_charset (self);

1630

1631

1632

const gchar *

1633

36

ipuz_puzzle_get_charset_str (IPuzPuzzle *self)

1634

1635

  IPuzPuzzlePrivate *priv;

1636

1637

36

  g_return_val_if_fail (IPUZ_IS_PUZZLE (self), NULL);

1638

1639

36

  priv = ipuz_puzzle_get_instance_private (self);

1640

36

  ensure_charset (self);

1641

1642

36

  return priv->charset_str;

1643

1644

1645

1646

void

1647

4

ipuz_puzzle_set_charset_str (IPuzPuzzle  *self,

1648

                             const gchar *charset_str)

1649

1650

  IPuzPuzzlePrivate *priv;

1651

1652

4

  g_return_if_fail (IPUZ_IS_PUZZLE (self));

1653

1654

4

  priv = ipuz_puzzle_get_instance_private (self);

1655

1656

4

  if (!g_strcmp0 (priv->charset_str, charset_str))

1657

4

    return;

1658

1659

  g_clear_pointer (&priv->charset_str, g_free);

1660

  g_clear_pointer (&priv->charset, ipuz_charset_unref);

1661

1662

  priv->charset_str = g_strdup (charset_str);

1663

  ensure_charset (self);

1664

1665

1666

IPuzStyle *

1667

102

ipuz_puzzle_get_style (IPuzPuzzle  *self,

1668

                       const gchar *style_name)

1669

1670

  IPuzPuzzlePrivate *priv;

1671

1672

102

  g_return_val_if_fail (IPUZ_IS_PUZZLE (self), NULL);

1673

1674

102

  priv = ipuz_puzzle_get_instance_private (self);

1675

1676

102

  if (priv->styles)

1677

102

    return (IPuzStyle *) g_hash_table_lookup (priv->styles, style_name);

1678

1679

  return NULL;

1680

1681

1682

void

1683

3

ipuz_puzzle_set_style (IPuzPuzzle  *self,

1684

                       const gchar *style_name,

1685

                       IPuzStyle   *style)

1686

1687

  IPuzPuzzleClass *klass;

1688

1689

3

  g_return_if_fail (IPUZ_IS_PUZZLE (self));

1690

1691

3

  klass = IPUZ_PUZZLE_GET_CLASS (self);

1692

1693

3

  klass->set_style (self, style_name, style);

1694

1695

1696

void

1697

5

ipuz_puzzle_style_foreach (IPuzPuzzle           *self,

1698

                           IPuzStyleForeachFunc  func,

1699

                           gpointer              user_data)

1700

1701

  IPuzPuzzlePrivate *priv;

1702

1703

5

  g_return_if_fail (IPUZ_IS_PUZZLE (self));

1704

1705

5

  priv = ipuz_puzzle_get_instance_private (self);

1706

1707

5

  if (priv->styles)

1708

5

    g_hash_table_foreach (priv->styles, (GHFunc) func, user_data);

1709

1710