src/apps/haikudepot/server/StandardMetaDataJsonEventListener.cpp

   1 /*
   2  * Copyright 2017, Andrew Lindesay <apl@lindesay.co.nz>.
   3  * All rights reserved. Distributed under the terms of the MIT License.
   4  */
   5
   6 #include "StandardMetaDataJsonEventListener.h"
   7
   8 #include "stdio.h"
   9
  10 #define KEY_CREATE_TIMESTAMP "createTimestamp"
  11 #define KEY_DATA_MODIFIED_TIMESTAMP "dataModifiedTimestamp"
  12
  13
  14 class SmdStackedEventListener : public BJsonEventListener {
  15 public:
  16                                                                 SmdStackedEventListener(
  17                                                                         StandardMetaDataJsonEventListener*
  18                                                                                 mainListener,
  19                                                                         SmdStackedEventListener* parent);
  20                                                                 ~SmdStackedEventListener();
  21
  22                                 void                    HandleError(status_t status, int32 line,
  23                                                                         const char* message);
  24                                 void                    Complete();
  25
  26                                 status_t                ErrorStatus();
  27
  28                                 SmdStackedEventListener*
  29                                                                 Parent();
  30                                 StandardMetaData*
  31                                                                 MetaData();
  32
  33 protected:
  34                                 void                    SetStackedListenerMainListener(
  35                                                                         SmdStackedEventListener* stackedListener);
  36
  37                         StandardMetaDataJsonEventListener*
  38                                                                 fMainListener;
  39                         SmdStackedEventListener*
  40                                                                 fParent;
  41 };
  42
  43
  44 class SmdStackedArrayEventListener : public SmdStackedEventListener {
  45 public:
  46                                                                 SmdStackedArrayEventListener(
  47                                                                         StandardMetaDataJsonEventListener*
  48                                                                                 mainListener,
  49                                                                         SmdStackedEventListener* parent);
  50                                                                 ~SmdStackedArrayEventListener();
  51
  52                                 bool                    Handle(const BJsonEvent& event);
  53
  54 };
  55
  56
  57 class SmdStackedObjectMessageEventListener : public SmdStackedEventListener {
  58 public:
  59                                                                 SmdStackedObjectMessageEventListener(
  60                                                                         BStringList* jsonPathObjectNames,
  61                                                                         StandardMetaDataJsonEventListener*
  62                                                                                 mainListener,
  63                                                                         SmdStackedEventListener* parent);
  64                                                                 ~SmdStackedObjectMessageEventListener();
  65
  66                                 bool                    Handle(const BJsonEvent& event);
  67
  68 private:
  69                         BStringList*            fJsonPathObjectNames;
  70                         BString                         fNextItemName;
  71 };
  72
  73
  74 // #pragma mark - SmdStackedEventListener
  75
  76 SmdStackedEventListener::SmdStackedEventListener(
  77         StandardMetaDataJsonEventListener* mainListener,
  78         SmdStackedEventListener* parent)
  79 {
  80         fMainListener = mainListener;
  81         fParent = parent;
  82 }
  83
  84
  85 SmdStackedEventListener::~SmdStackedEventListener()
  86 {
  87 }
  88
  89
  90 void
  91 SmdStackedEventListener::HandleError(status_t status, int32 line,
  92         const char* message)
  93 {
  94         fMainListener->HandleError(status, line, message);
  95 }
  96
  97
  98 void
  99 SmdStackedEventListener::Complete()
 100 {
 101         fMainListener->Complete();
 102 }
 103
 104
 105 status_t
 106 SmdStackedEventListener::ErrorStatus()
 107 {
 108         return fMainListener->ErrorStatus();
 109 }
 110
 111
 112 StandardMetaData*
 113 SmdStackedEventListener::MetaData()
 114 {
 115         return fMainListener->MetaData();
 116 }
 117
 118
 119 SmdStackedEventListener*
 120 SmdStackedEventListener::Parent()
 121 {
 122         return fParent;
 123 }
 124
 125
 126 void
 127 SmdStackedEventListener::SetStackedListenerMainListener(
 128         SmdStackedEventListener* stackedListener)
 129 {
 130         fMainListener->SetStackedListener(stackedListener);
 131 }
 132
 133
 134 // #pragma mark - SmdStackedArrayEventListener
 135
 136
 137 SmdStackedArrayEventListener::SmdStackedArrayEventListener(
 138         StandardMetaDataJsonEventListener* mainListener,
 139         SmdStackedEventListener* parent)
 140         :
 141         SmdStackedEventListener(mainListener, parent)
 142 {
 143 }
 144
 145
 146 SmdStackedArrayEventListener::~SmdStackedArrayEventListener()
 147 {
 148 }
 149
 150
 151 bool
 152 SmdStackedArrayEventListener::Handle(const BJsonEvent& event)
 153 {
 154         if (ErrorStatus() != B_OK)
 155                 return false;
 156
 157         switch (event.EventType()) {
 158
 159                 case B_JSON_NUMBER:
 160                 case B_JSON_STRING:
 161                 case B_JSON_TRUE:
 162                 case B_JSON_FALSE:
 163                 case B_JSON_NULL:
 164                         // ignore these atomic types in an array.
 165                         break;
 166
 167                 case B_JSON_OBJECT_START:
 168                         SetStackedListenerMainListener(
 169                                 new SmdStackedObjectMessageEventListener(NULL, fMainListener,
 170                                         this));
 171                         break;
 172
 173                 case B_JSON_ARRAY_START:
 174                         SetStackedListenerMainListener(new SmdStackedArrayEventListener(
 175                                 fMainListener, this));
 176                         break;
 177
 178                 case B_JSON_ARRAY_END:
 179                         SetStackedListenerMainListener(fParent);
 180                         delete this;
 181                         break;
 182
 183                 case B_JSON_OBJECT_END:
 184                 case B_JSON_OBJECT_NAME:
 185                         HandleError(B_NOT_ALLOWED, JSON_EVENT_LISTENER_ANY_LINE,
 186                                 "illegal state when processing events in an array");
 187                         return false;
 188         }
 189
 190         return true;
 191 }
 192
 193
 194 // #pragma mark - SmdStackedObjectMessageEventListener
 195
 196 SmdStackedObjectMessageEventListener::SmdStackedObjectMessageEventListener(
 197         BStringList* jsonPathObjectNames,
 198         StandardMetaDataJsonEventListener* mainListener,
 199         SmdStackedEventListener* parent)
 200         :
 201         SmdStackedEventListener(mainListener, parent)
 202 {
 203         fJsonPathObjectNames = jsonPathObjectNames;
 204 }
 205
 206
 207 SmdStackedObjectMessageEventListener::~SmdStackedObjectMessageEventListener()
 208 {
 209         if (fJsonPathObjectNames != NULL)
 210                 delete fJsonPathObjectNames;
 211 }
 212
 213
 214 bool
 215 SmdStackedObjectMessageEventListener::Handle(const BJsonEvent& event)
 216 {
 217         if (ErrorStatus() != B_OK)
 218                 return false;
 219
 220         switch (event.EventType()) {
 221
 222                 case B_JSON_OBJECT_NAME:
 223                         fNextItemName = event.Content();
 224                         break;
 225
 226                 case B_JSON_NUMBER:
 227                         if (fJsonPathObjectNames != NULL
 228                                 && fJsonPathObjectNames->IsEmpty()) {
 229
 230                                 if (fNextItemName == KEY_CREATE_TIMESTAMP) {
 231                                         MetaData()->SetCreateTimestamp(
 232                                                 event.ContentInteger());
 233                                 }
 234
 235                                 if (fNextItemName == KEY_DATA_MODIFIED_TIMESTAMP) {
 236                                         MetaData()->SetDataModifiedTimestamp(
 237                                                 event.ContentInteger());
 238                                 }
 239                         }
 240                         break;
 241
 242                 case B_JSON_STRING:
 243                 case B_JSON_TRUE:
 244                 case B_JSON_FALSE:
 245                 case B_JSON_NULL:
 246                         // ignore these atomic types as they are not required to fill the
 247                         // data structure.
 248                         break;
 249
 250                 case B_JSON_OBJECT_START:
 251                 {
 252                         BStringList* nextJsonPathObjectNames = NULL;
 253
 254                         // if this next object is on the path then remove it from the
 255                         // path and carry on down.  If it's not on the path then just
 256                         // drop the path from the next object.
 257
 258                         if (fJsonPathObjectNames != NULL
 259                                 && !fJsonPathObjectNames->IsEmpty()
 260                                 && fNextItemName == fJsonPathObjectNames->StringAt(0)) {
 261                                 nextJsonPathObjectNames = new BStringList(*fJsonPathObjectNames);
 262                                 nextJsonPathObjectNames->Remove(0);
 263                         }
 264
 265                         SetStackedListenerMainListener(
 266                                 new SmdStackedObjectMessageEventListener(nextJsonPathObjectNames,
 267                                         fMainListener, this));
 268                         break;
 269                 }
 270
 271                 case B_JSON_ARRAY_START:
 272                         SetStackedListenerMainListener(new SmdStackedArrayEventListener(
 273                                 fMainListener, this));
 274                         break;
 275
 276                 case B_JSON_OBJECT_END:
 277                         SetStackedListenerMainListener(fParent);
 278                         delete this;
 279                         break;
 280
 281                 case B_JSON_ARRAY_END:
 282                         HandleError(B_NOT_ALLOWED, JSON_EVENT_LISTENER_ANY_LINE,
 283                                 "illegal state when processing events in an array");
 284                         return false;
 285         }
 286
 287         return true;
 288 }
 289
 290
 291 // #pragma mark - StandardMetaDataJsonEventListener
 292
 293
 294 StandardMetaDataJsonEventListener::StandardMetaDataJsonEventListener(
 295         const BString& jsonPath,
 296         StandardMetaData& metaData)
 297 {
 298         fMetaData = &metaData;
 299         SetJsonPath(jsonPath);
 300         fErrorStatus = B_OK;
 301         fStackedListener = NULL;
 302 }
 303
 304
 305 StandardMetaDataJsonEventListener::~StandardMetaDataJsonEventListener()
 306 {
 307         if (fStackedListener != NULL)
 308                 delete fStackedListener;
 309 }
 310
 311
 312 void
 313 StandardMetaDataJsonEventListener::SetJsonPath(const BString& jsonPath)
 314 {
 315         jsonPath.Split(".", true, fJsonPathObjectNames);
 316
 317         if (fJsonPathObjectNames.IsEmpty()) {
 318                 HandleError(B_BAD_VALUE, JSON_EVENT_LISTENER_ANY_LINE,
 319                         "json path required");
 320         } else {
 321                 if (fJsonPathObjectNames.First() != "$") {
 322                         HandleError(B_BAD_VALUE, JSON_EVENT_LISTENER_ANY_LINE,
 323                                 "illegal json path; should start with '$");
 324                 }
 325         }
 326 }
 327
 328
 329 void
 330 StandardMetaDataJsonEventListener::SetStackedListener(
 331         SmdStackedEventListener *listener)
 332 {
 333         fStackedListener = listener;
 334 }
 335
 336
 337 bool
 338 StandardMetaDataJsonEventListener::Handle(const BJsonEvent& event)
 339 {
 340         if (fErrorStatus != B_OK)
 341                 return false;
 342
 343                 // best to exit early if the parsing has obtained all of the required
 344                 // data already.
 345
 346         if (fMetaData->IsPopulated())
 347                 return false;
 348
 349         if (fStackedListener != NULL)
 350                 return fStackedListener->Handle(event);
 351
 352                 // the first thing that comes in must be an object container.  It is
 353                 // bad data if it does not start with an object container.
 354
 355         switch (event.EventType()) {
 356
 357                 case B_JSON_OBJECT_START:
 358                 {
 359                         BStringList* jsonPathObjectNames = new BStringList(
 360                                 fJsonPathObjectNames);
 361                         jsonPathObjectNames->Remove(0);
 362
 363                         SetStackedListener(
 364                                 new SmdStackedObjectMessageEventListener(
 365                                         jsonPathObjectNames, this, NULL)
 366                         );
 367                 }
 368                 break;
 369
 370                 default:
 371                         HandleError(B_BAD_DATA, JSON_EVENT_LISTENER_ANY_LINE,
 372                                 "the top level element must be an object");
 373                         return false;
 374
 375         }
 376
 377         return true;
 378 }
 379
 380
 381 void
 382 StandardMetaDataJsonEventListener::HandleError(status_t status, int32 line,
 383         const char* message)
 384 {
 385         fprintf(stderr, "an error has arisen processing the standard "
 386                 "meta data; %s\n", message);
 387         fErrorStatus = status;
 388 }
 389
 390
 391 void
 392 StandardMetaDataJsonEventListener::Complete()
 393 {
 394 }
 395
 396
 397 status_t
 398 StandardMetaDataJsonEventListener::ErrorStatus()
 399 {
 400         return fErrorStatus;
 401 }
 402
 403
 404 StandardMetaData*
 405 StandardMetaDataJsonEventListener::MetaData()
 406 {
 407         return fMetaData;
 408 }