Parent

Included Modules

Files

Class Index [+]

Quicksearch

Evernote::EDAM::NoteStore::NoteStore::Processor

Public Instance Methods

process_authenticateToSharedNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1784
1784:                       def process_authenticateToSharedNotebook(seqid, iprot, oprot)
1785:                         args = read_args(iprot, AuthenticateToSharedNotebook_args)
1786:                         result = AuthenticateToSharedNotebook_result.new()
1787:                         begin
1788:                           result.success = @handler.authenticateToSharedNotebook(args.shareKey, args.authenticationToken)
1789:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1790:                           result.userException = userException
1791:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1792:                           result.notFoundException = notFoundException
1793:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1794:                           result.systemException = systemException
1795:                         end
1796:                         write_result(result, oprot, 'authenticateToSharedNotebook', seqid)
1797:                       end
process_copyNote(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1477
1477:                       def process_copyNote(seqid, iprot, oprot)
1478:                         args = read_args(iprot, CopyNote_args)
1479:                         result = CopyNote_result.new()
1480:                         begin
1481:                           result.success = @handler.copyNote(args.authenticationToken, args.noteGuid, args.toNotebookGuid)
1482:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1483:                           result.userException = userException
1484:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1485:                           result.systemException = systemException
1486:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1487:                           result.notFoundException = notFoundException
1488:                         end
1489:                         write_result(result, oprot, 'copyNote', seqid)
1490:                       end
process_createLinkedNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1724
1724:                       def process_createLinkedNotebook(seqid, iprot, oprot)
1725:                         args = read_args(iprot, CreateLinkedNotebook_args)
1726:                         result = CreateLinkedNotebook_result.new()
1727:                         begin
1728:                           result.success = @handler.createLinkedNotebook(args.authenticationToken, args.linkedNotebook)
1729:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1730:                           result.userException = userException
1731:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1732:                           result.notFoundException = notFoundException
1733:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1734:                           result.systemException = systemException
1735:                         end
1736:                         write_result(result, oprot, 'createLinkedNotebook', seqid)
1737:                       end
process_createNote(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1389
1389:                       def process_createNote(seqid, iprot, oprot)
1390:                         args = read_args(iprot, CreateNote_args)
1391:                         result = CreateNote_result.new()
1392:                         begin
1393:                           result.success = @handler.createNote(args.authenticationToken, args.note)
1394:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1395:                           result.userException = userException
1396:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1397:                           result.systemException = systemException
1398:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1399:                           result.notFoundException = notFoundException
1400:                         end
1401:                         write_result(result, oprot, 'createNote', seqid)
1402:                       end
process_createNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1082
1082:                       def process_createNotebook(seqid, iprot, oprot)
1083:                         args = read_args(iprot, CreateNotebook_args)
1084:                         result = CreateNotebook_result.new()
1085:                         begin
1086:                           result.success = @handler.createNotebook(args.authenticationToken, args.notebook)
1087:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1088:                           result.userException = userException
1089:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1090:                           result.systemException = systemException
1091:                         end
1092:                         write_result(result, oprot, 'createNotebook', seqid)
1093:                       end
process_createSearch(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1256
1256:                       def process_createSearch(seqid, iprot, oprot)
1257:                         args = read_args(iprot, CreateSearch_args)
1258:                         result = CreateSearch_result.new()
1259:                         begin
1260:                           result.success = @handler.createSearch(args.authenticationToken, args.search)
1261:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1262:                           result.userException = userException
1263:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1264:                           result.systemException = systemException
1265:                         end
1266:                         write_result(result, oprot, 'createSearch', seqid)
1267:                       end
process_createSharedNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1679
1679:                       def process_createSharedNotebook(seqid, iprot, oprot)
1680:                         args = read_args(iprot, CreateSharedNotebook_args)
1681:                         result = CreateSharedNotebook_result.new()
1682:                         begin
1683:                           result.success = @handler.createSharedNotebook(args.authenticationToken, args.sharedNotebook)
1684:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1685:                           result.userException = userException
1686:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1687:                           result.notFoundException = notFoundException
1688:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1689:                           result.systemException = systemException
1690:                         end
1691:                         write_result(result, oprot, 'createSharedNotebook', seqid)
1692:                       end
process_createTag(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1168
1168:                       def process_createTag(seqid, iprot, oprot)
1169:                         args = read_args(iprot, CreateTag_args)
1170:                         result = CreateTag_result.new()
1171:                         begin
1172:                           result.success = @handler.createTag(args.authenticationToken, args.tag)
1173:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1174:                           result.userException = userException
1175:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1176:                           result.systemException = systemException
1177:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1178:                           result.notFoundException = notFoundException
1179:                         end
1180:                         write_result(result, oprot, 'createTag', seqid)
1181:                       end
process_deleteNote(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1419
1419:                       def process_deleteNote(seqid, iprot, oprot)
1420:                         args = read_args(iprot, DeleteNote_args)
1421:                         result = DeleteNote_result.new()
1422:                         begin
1423:                           result.success = @handler.deleteNote(args.authenticationToken, args.guid)
1424:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1425:                           result.userException = userException
1426:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1427:                           result.systemException = systemException
1428:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1429:                           result.notFoundException = notFoundException
1430:                         end
1431:                         write_result(result, oprot, 'deleteNote', seqid)
1432:                       end
process_emailNote(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1814
1814:                       def process_emailNote(seqid, iprot, oprot)
1815:                         args = read_args(iprot, EmailNote_args)
1816:                         result = EmailNote_result.new()
1817:                         begin
1818:                           @handler.emailNote(args.authenticationToken, args.parameters)
1819:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1820:                           result.userException = userException
1821:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1822:                           result.notFoundException = notFoundException
1823:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1824:                           result.systemException = systemException
1825:                         end
1826:                         write_result(result, oprot, 'emailNote', seqid)
1827:                       end
process_expungeInactiveNotes(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1464
1464:                       def process_expungeInactiveNotes(seqid, iprot, oprot)
1465:                         args = read_args(iprot, ExpungeInactiveNotes_args)
1466:                         result = ExpungeInactiveNotes_result.new()
1467:                         begin
1468:                           result.success = @handler.expungeInactiveNotes(args.authenticationToken)
1469:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1470:                           result.userException = userException
1471:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1472:                           result.systemException = systemException
1473:                         end
1474:                         write_result(result, oprot, 'expungeInactiveNotes', seqid)
1475:                       end
process_expungeLinkedNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1769
1769:                       def process_expungeLinkedNotebook(seqid, iprot, oprot)
1770:                         args = read_args(iprot, ExpungeLinkedNotebook_args)
1771:                         result = ExpungeLinkedNotebook_result.new()
1772:                         begin
1773:                           result.success = @handler.expungeLinkedNotebook(args.authenticationToken, args.linkedNotebookId)
1774:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1775:                           result.userException = userException
1776:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1777:                           result.notFoundException = notFoundException
1778:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1779:                           result.systemException = systemException
1780:                         end
1781:                         write_result(result, oprot, 'expungeLinkedNotebook', seqid)
1782:                       end
process_expungeNote(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1434
1434:                       def process_expungeNote(seqid, iprot, oprot)
1435:                         args = read_args(iprot, ExpungeNote_args)
1436:                         result = ExpungeNote_result.new()
1437:                         begin
1438:                           result.success = @handler.expungeNote(args.authenticationToken, args.guid)
1439:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1440:                           result.userException = userException
1441:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1442:                           result.systemException = systemException
1443:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1444:                           result.notFoundException = notFoundException
1445:                         end
1446:                         write_result(result, oprot, 'expungeNote', seqid)
1447:                       end
process_expungeNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1110
1110:                       def process_expungeNotebook(seqid, iprot, oprot)
1111:                         args = read_args(iprot, ExpungeNotebook_args)
1112:                         result = ExpungeNotebook_result.new()
1113:                         begin
1114:                           result.success = @handler.expungeNotebook(args.authenticationToken, args.guid)
1115:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1116:                           result.userException = userException
1117:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1118:                           result.systemException = systemException
1119:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1120:                           result.notFoundException = notFoundException
1121:                         end
1122:                         write_result(result, oprot, 'expungeNotebook', seqid)
1123:                       end
process_expungeNotes(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1449
1449:                       def process_expungeNotes(seqid, iprot, oprot)
1450:                         args = read_args(iprot, ExpungeNotes_args)
1451:                         result = ExpungeNotes_result.new()
1452:                         begin
1453:                           result.success = @handler.expungeNotes(args.authenticationToken, args.noteGuids)
1454:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1455:                           result.userException = userException
1456:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1457:                           result.systemException = systemException
1458:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1459:                           result.notFoundException = notFoundException
1460:                         end
1461:                         write_result(result, oprot, 'expungeNotes', seqid)
1462:                       end
process_expungeSearch(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1284
1284:                       def process_expungeSearch(seqid, iprot, oprot)
1285:                         args = read_args(iprot, ExpungeSearch_args)
1286:                         result = ExpungeSearch_result.new()
1287:                         begin
1288:                           result.success = @handler.expungeSearch(args.authenticationToken, args.guid)
1289:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1290:                           result.userException = userException
1291:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1292:                           result.systemException = systemException
1293:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1294:                           result.notFoundException = notFoundException
1295:                         end
1296:                         write_result(result, oprot, 'expungeSearch', seqid)
1297:                       end
process_expungeSharedNotebooks(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1709
1709:                       def process_expungeSharedNotebooks(seqid, iprot, oprot)
1710:                         args = read_args(iprot, ExpungeSharedNotebooks_args)
1711:                         result = ExpungeSharedNotebooks_result.new()
1712:                         begin
1713:                           result.success = @handler.expungeSharedNotebooks(args.authenticationToken, args.sharedNotebookIds)
1714:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1715:                           result.userException = userException
1716:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1717:                           result.notFoundException = notFoundException
1718:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1719:                           result.systemException = systemException
1720:                         end
1721:                         write_result(result, oprot, 'expungeSharedNotebooks', seqid)
1722:                       end
process_expungeTag(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1213
1213:                       def process_expungeTag(seqid, iprot, oprot)
1214:                         args = read_args(iprot, ExpungeTag_args)
1215:                         result = ExpungeTag_result.new()
1216:                         begin
1217:                           result.success = @handler.expungeTag(args.authenticationToken, args.guid)
1218:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1219:                           result.userException = userException
1220:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1221:                           result.systemException = systemException
1222:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1223:                           result.notFoundException = notFoundException
1224:                         end
1225:                         write_result(result, oprot, 'expungeTag', seqid)
1226:                       end
process_findNoteCounts(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1314
1314:                       def process_findNoteCounts(seqid, iprot, oprot)
1315:                         args = read_args(iprot, FindNoteCounts_args)
1316:                         result = FindNoteCounts_result.new()
1317:                         begin
1318:                           result.success = @handler.findNoteCounts(args.authenticationToken, args.filter, args.withTrash)
1319:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1320:                           result.userException = userException
1321:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1322:                           result.systemException = systemException
1323:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1324:                           result.notFoundException = notFoundException
1325:                         end
1326:                         write_result(result, oprot, 'findNoteCounts', seqid)
1327:                       end
process_findNotes(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1299
1299:                       def process_findNotes(seqid, iprot, oprot)
1300:                         args = read_args(iprot, FindNotes_args)
1301:                         result = FindNotes_result.new()
1302:                         begin
1303:                           result.success = @handler.findNotes(args.authenticationToken, args.filter, args.offset, args.maxNotes)
1304:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1305:                           result.userException = userException
1306:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1307:                           result.systemException = systemException
1308:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1309:                           result.notFoundException = notFoundException
1310:                         end
1311:                         write_result(result, oprot, 'findNotes', seqid)
1312:                       end
process_getAccountSize(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1627
1627:                       def process_getAccountSize(seqid, iprot, oprot)
1628:                         args = read_args(iprot, GetAccountSize_args)
1629:                         result = GetAccountSize_result.new()
1630:                         begin
1631:                           result.success = @handler.getAccountSize(args.authenticationToken)
1632:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1633:                           result.userException = userException
1634:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1635:                           result.systemException = systemException
1636:                         end
1637:                         write_result(result, oprot, 'getAccountSize', seqid)
1638:                       end
process_getAds(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1640
1640:                       def process_getAds(seqid, iprot, oprot)
1641:                         args = read_args(iprot, GetAds_args)
1642:                         result = GetAds_result.new()
1643:                         begin
1644:                           result.success = @handler.getAds(args.authenticationToken, args.adParameters)
1645:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1646:                           result.userException = userException
1647:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1648:                           result.systemException = systemException
1649:                         end
1650:                         write_result(result, oprot, 'getAds', seqid)
1651:                       end
process_getDefaultNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1069
1069:                       def process_getDefaultNotebook(seqid, iprot, oprot)
1070:                         args = read_args(iprot, GetDefaultNotebook_args)
1071:                         result = GetDefaultNotebook_result.new()
1072:                         begin
1073:                           result.success = @handler.getDefaultNotebook(args.authenticationToken)
1074:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1075:                           result.userException = userException
1076:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1077:                           result.systemException = systemException
1078:                         end
1079:                         write_result(result, oprot, 'getDefaultNotebook', seqid)
1080:                       end
process_getNote(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1329
1329:                       def process_getNote(seqid, iprot, oprot)
1330:                         args = read_args(iprot, GetNote_args)
1331:                         result = GetNote_result.new()
1332:                         begin
1333:                           result.success = @handler.getNote(args.authenticationToken, args.guid, args.withContent, args.withResourcesData, args.withResourcesRecognition, args.withResourcesAlternateData)
1334:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1335:                           result.userException = userException
1336:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1337:                           result.systemException = systemException
1338:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1339:                           result.notFoundException = notFoundException
1340:                         end
1341:                         write_result(result, oprot, 'getNote', seqid)
1342:                       end
process_getNoteContent(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1344
1344:                       def process_getNoteContent(seqid, iprot, oprot)
1345:                         args = read_args(iprot, GetNoteContent_args)
1346:                         result = GetNoteContent_result.new()
1347:                         begin
1348:                           result.success = @handler.getNoteContent(args.authenticationToken, args.guid)
1349:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1350:                           result.userException = userException
1351:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1352:                           result.systemException = systemException
1353:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1354:                           result.notFoundException = notFoundException
1355:                         end
1356:                         write_result(result, oprot, 'getNoteContent', seqid)
1357:                       end
process_getNoteSearchText(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1359
1359:                       def process_getNoteSearchText(seqid, iprot, oprot)
1360:                         args = read_args(iprot, GetNoteSearchText_args)
1361:                         result = GetNoteSearchText_result.new()
1362:                         begin
1363:                           result.success = @handler.getNoteSearchText(args.authenticationToken, args.guid)
1364:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1365:                           result.userException = userException
1366:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1367:                           result.systemException = systemException
1368:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1369:                           result.notFoundException = notFoundException
1370:                         end
1371:                         write_result(result, oprot, 'getNoteSearchText', seqid)
1372:                       end
process_getNoteTagNames(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1374
1374:                       def process_getNoteTagNames(seqid, iprot, oprot)
1375:                         args = read_args(iprot, GetNoteTagNames_args)
1376:                         result = GetNoteTagNames_result.new()
1377:                         begin
1378:                           result.success = @handler.getNoteTagNames(args.authenticationToken, args.guid)
1379:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1380:                           result.userException = userException
1381:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1382:                           result.systemException = systemException
1383:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1384:                           result.notFoundException = notFoundException
1385:                         end
1386:                         write_result(result, oprot, 'getNoteTagNames', seqid)
1387:                       end
process_getNoteVersion(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1507
1507:                       def process_getNoteVersion(seqid, iprot, oprot)
1508:                         args = read_args(iprot, GetNoteVersion_args)
1509:                         result = GetNoteVersion_result.new()
1510:                         begin
1511:                           result.success = @handler.getNoteVersion(args.authenticationToken, args.noteGuid, args.updateSequenceNum, args.withResourcesData, args.withResourcesRecognition, args.withResourcesAlternateData)
1512:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1513:                           result.userException = userException
1514:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1515:                           result.systemException = systemException
1516:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1517:                           result.notFoundException = notFoundException
1518:                         end
1519:                         write_result(result, oprot, 'getNoteVersion', seqid)
1520:                       end
process_getNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1054
1054:                       def process_getNotebook(seqid, iprot, oprot)
1055:                         args = read_args(iprot, GetNotebook_args)
1056:                         result = GetNotebook_result.new()
1057:                         begin
1058:                           result.success = @handler.getNotebook(args.authenticationToken, args.guid)
1059:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1060:                           result.userException = userException
1061:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1062:                           result.systemException = systemException
1063:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1064:                           result.notFoundException = notFoundException
1065:                         end
1066:                         write_result(result, oprot, 'getNotebook', seqid)
1067:                       end
process_getPublicNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1666
1666:                       def process_getPublicNotebook(seqid, iprot, oprot)
1667:                         args = read_args(iprot, GetPublicNotebook_args)
1668:                         result = GetPublicNotebook_result.new()
1669:                         begin
1670:                           result.success = @handler.getPublicNotebook(args.userId, args.publicUri)
1671:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1672:                           result.systemException = systemException
1673:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1674:                           result.notFoundException = notFoundException
1675:                         end
1676:                         write_result(result, oprot, 'getPublicNotebook', seqid)
1677:                       end
process_getRandomAd(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1653
1653:                       def process_getRandomAd(seqid, iprot, oprot)
1654:                         args = read_args(iprot, GetRandomAd_args)
1655:                         result = GetRandomAd_result.new()
1656:                         begin
1657:                           result.success = @handler.getRandomAd(args.authenticationToken, args.adParameters)
1658:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1659:                           result.userException = userException
1660:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1661:                           result.systemException = systemException
1662:                         end
1663:                         write_result(result, oprot, 'getRandomAd', seqid)
1664:                       end
process_getResource(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1522
1522:                       def process_getResource(seqid, iprot, oprot)
1523:                         args = read_args(iprot, GetResource_args)
1524:                         result = GetResource_result.new()
1525:                         begin
1526:                           result.success = @handler.getResource(args.authenticationToken, args.guid, args.withData, args.withRecognition, args.withAttributes, args.withAlternateData)
1527:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1528:                           result.userException = userException
1529:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1530:                           result.systemException = systemException
1531:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1532:                           result.notFoundException = notFoundException
1533:                         end
1534:                         write_result(result, oprot, 'getResource', seqid)
1535:                       end
process_getResourceAlternateData(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1597
1597:                       def process_getResourceAlternateData(seqid, iprot, oprot)
1598:                         args = read_args(iprot, GetResourceAlternateData_args)
1599:                         result = GetResourceAlternateData_result.new()
1600:                         begin
1601:                           result.success = @handler.getResourceAlternateData(args.authenticationToken, args.guid)
1602:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1603:                           result.userException = userException
1604:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1605:                           result.systemException = systemException
1606:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1607:                           result.notFoundException = notFoundException
1608:                         end
1609:                         write_result(result, oprot, 'getResourceAlternateData', seqid)
1610:                       end
process_getResourceAttributes(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1612
1612:                       def process_getResourceAttributes(seqid, iprot, oprot)
1613:                         args = read_args(iprot, GetResourceAttributes_args)
1614:                         result = GetResourceAttributes_result.new()
1615:                         begin
1616:                           result.success = @handler.getResourceAttributes(args.authenticationToken, args.guid)
1617:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1618:                           result.userException = userException
1619:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1620:                           result.systemException = systemException
1621:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1622:                           result.notFoundException = notFoundException
1623:                         end
1624:                         write_result(result, oprot, 'getResourceAttributes', seqid)
1625:                       end
process_getResourceByHash(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1567
1567:                       def process_getResourceByHash(seqid, iprot, oprot)
1568:                         args = read_args(iprot, GetResourceByHash_args)
1569:                         result = GetResourceByHash_result.new()
1570:                         begin
1571:                           result.success = @handler.getResourceByHash(args.authenticationToken, args.noteGuid, args.contentHash, args.withData, args.withRecognition, args.withAlternateData)
1572:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1573:                           result.userException = userException
1574:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1575:                           result.systemException = systemException
1576:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1577:                           result.notFoundException = notFoundException
1578:                         end
1579:                         write_result(result, oprot, 'getResourceByHash', seqid)
1580:                       end
process_getResourceData(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1552
1552:                       def process_getResourceData(seqid, iprot, oprot)
1553:                         args = read_args(iprot, GetResourceData_args)
1554:                         result = GetResourceData_result.new()
1555:                         begin
1556:                           result.success = @handler.getResourceData(args.authenticationToken, args.guid)
1557:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1558:                           result.userException = userException
1559:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1560:                           result.systemException = systemException
1561:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1562:                           result.notFoundException = notFoundException
1563:                         end
1564:                         write_result(result, oprot, 'getResourceData', seqid)
1565:                       end
process_getResourceRecognition(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1582
1582:                       def process_getResourceRecognition(seqid, iprot, oprot)
1583:                         args = read_args(iprot, GetResourceRecognition_args)
1584:                         result = GetResourceRecognition_result.new()
1585:                         begin
1586:                           result.success = @handler.getResourceRecognition(args.authenticationToken, args.guid)
1587:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1588:                           result.userException = userException
1589:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1590:                           result.systemException = systemException
1591:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1592:                           result.notFoundException = notFoundException
1593:                         end
1594:                         write_result(result, oprot, 'getResourceRecognition', seqid)
1595:                       end
process_getSearch(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1241
1241:                       def process_getSearch(seqid, iprot, oprot)
1242:                         args = read_args(iprot, GetSearch_args)
1243:                         result = GetSearch_result.new()
1244:                         begin
1245:                           result.success = @handler.getSearch(args.authenticationToken, args.guid)
1246:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1247:                           result.userException = userException
1248:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1249:                           result.systemException = systemException
1250:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1251:                           result.notFoundException = notFoundException
1252:                         end
1253:                         write_result(result, oprot, 'getSearch', seqid)
1254:                       end
process_getSharedNotebookByAuth(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1799
1799:                       def process_getSharedNotebookByAuth(seqid, iprot, oprot)
1800:                         args = read_args(iprot, GetSharedNotebookByAuth_args)
1801:                         result = GetSharedNotebookByAuth_result.new()
1802:                         begin
1803:                           result.success = @handler.getSharedNotebookByAuth(args.authenticationToken)
1804:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1805:                           result.userException = userException
1806:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1807:                           result.notFoundException = notFoundException
1808:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1809:                           result.systemException = systemException
1810:                         end
1811:                         write_result(result, oprot, 'getSharedNotebookByAuth', seqid)
1812:                       end
process_getSyncChunk(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1028
1028:                       def process_getSyncChunk(seqid, iprot, oprot)
1029:                         args = read_args(iprot, GetSyncChunk_args)
1030:                         result = GetSyncChunk_result.new()
1031:                         begin
1032:                           result.success = @handler.getSyncChunk(args.authenticationToken, args.afterUSN, args.maxEntries, args.fullSyncOnly)
1033:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1034:                           result.userException = userException
1035:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1036:                           result.systemException = systemException
1037:                         end
1038:                         write_result(result, oprot, 'getSyncChunk', seqid)
1039:                       end
process_getSyncState(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1015
1015:                       def process_getSyncState(seqid, iprot, oprot)
1016:                         args = read_args(iprot, GetSyncState_args)
1017:                         result = GetSyncState_result.new()
1018:                         begin
1019:                           result.success = @handler.getSyncState(args.authenticationToken)
1020:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1021:                           result.userException = userException
1022:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1023:                           result.systemException = systemException
1024:                         end
1025:                         write_result(result, oprot, 'getSyncState', seqid)
1026:                       end
process_getTag(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1153
1153:                       def process_getTag(seqid, iprot, oprot)
1154:                         args = read_args(iprot, GetTag_args)
1155:                         result = GetTag_result.new()
1156:                         begin
1157:                           result.success = @handler.getTag(args.authenticationToken, args.guid)
1158:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1159:                           result.userException = userException
1160:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1161:                           result.systemException = systemException
1162:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1163:                           result.notFoundException = notFoundException
1164:                         end
1165:                         write_result(result, oprot, 'getTag', seqid)
1166:                       end
process_listLinkedNotebooks(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1754
1754:                       def process_listLinkedNotebooks(seqid, iprot, oprot)
1755:                         args = read_args(iprot, ListLinkedNotebooks_args)
1756:                         result = ListLinkedNotebooks_result.new()
1757:                         begin
1758:                           result.success = @handler.listLinkedNotebooks(args.authenticationToken)
1759:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1760:                           result.userException = userException
1761:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1762:                           result.notFoundException = notFoundException
1763:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1764:                           result.systemException = systemException
1765:                         end
1766:                         write_result(result, oprot, 'listLinkedNotebooks', seqid)
1767:                       end
process_listNoteVersions(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1492
1492:                       def process_listNoteVersions(seqid, iprot, oprot)
1493:                         args = read_args(iprot, ListNoteVersions_args)
1494:                         result = ListNoteVersions_result.new()
1495:                         begin
1496:                           result.success = @handler.listNoteVersions(args.authenticationToken, args.noteGuid)
1497:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1498:                           result.userException = userException
1499:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1500:                           result.systemException = systemException
1501:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1502:                           result.notFoundException = notFoundException
1503:                         end
1504:                         write_result(result, oprot, 'listNoteVersions', seqid)
1505:                       end
process_listNotebooks(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1041
1041:                       def process_listNotebooks(seqid, iprot, oprot)
1042:                         args = read_args(iprot, ListNotebooks_args)
1043:                         result = ListNotebooks_result.new()
1044:                         begin
1045:                           result.success = @handler.listNotebooks(args.authenticationToken)
1046:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1047:                           result.userException = userException
1048:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1049:                           result.systemException = systemException
1050:                         end
1051:                         write_result(result, oprot, 'listNotebooks', seqid)
1052:                       end
process_listSearches(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1228
1228:                       def process_listSearches(seqid, iprot, oprot)
1229:                         args = read_args(iprot, ListSearches_args)
1230:                         result = ListSearches_result.new()
1231:                         begin
1232:                           result.success = @handler.listSearches(args.authenticationToken)
1233:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1234:                           result.userException = userException
1235:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1236:                           result.systemException = systemException
1237:                         end
1238:                         write_result(result, oprot, 'listSearches', seqid)
1239:                       end
process_listSharedNotebooks(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1694
1694:                       def process_listSharedNotebooks(seqid, iprot, oprot)
1695:                         args = read_args(iprot, ListSharedNotebooks_args)
1696:                         result = ListSharedNotebooks_result.new()
1697:                         begin
1698:                           result.success = @handler.listSharedNotebooks(args.authenticationToken)
1699:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1700:                           result.userException = userException
1701:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1702:                           result.notFoundException = notFoundException
1703:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1704:                           result.systemException = systemException
1705:                         end
1706:                         write_result(result, oprot, 'listSharedNotebooks', seqid)
1707:                       end
process_listTags(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1125
1125:                       def process_listTags(seqid, iprot, oprot)
1126:                         args = read_args(iprot, ListTags_args)
1127:                         result = ListTags_result.new()
1128:                         begin
1129:                           result.success = @handler.listTags(args.authenticationToken)
1130:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1131:                           result.userException = userException
1132:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1133:                           result.systemException = systemException
1134:                         end
1135:                         write_result(result, oprot, 'listTags', seqid)
1136:                       end
process_listTagsByNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1138
1138:                       def process_listTagsByNotebook(seqid, iprot, oprot)
1139:                         args = read_args(iprot, ListTagsByNotebook_args)
1140:                         result = ListTagsByNotebook_result.new()
1141:                         begin
1142:                           result.success = @handler.listTagsByNotebook(args.authenticationToken, args.notebookGuid)
1143:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1144:                           result.userException = userException
1145:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1146:                           result.systemException = systemException
1147:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1148:                           result.notFoundException = notFoundException
1149:                         end
1150:                         write_result(result, oprot, 'listTagsByNotebook', seqid)
1151:                       end
process_untagAll(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1198
1198:                       def process_untagAll(seqid, iprot, oprot)
1199:                         args = read_args(iprot, UntagAll_args)
1200:                         result = UntagAll_result.new()
1201:                         begin
1202:                           @handler.untagAll(args.authenticationToken, args.guid)
1203:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1204:                           result.userException = userException
1205:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1206:                           result.systemException = systemException
1207:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1208:                           result.notFoundException = notFoundException
1209:                         end
1210:                         write_result(result, oprot, 'untagAll', seqid)
1211:                       end
process_updateLinkedNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1739
1739:                       def process_updateLinkedNotebook(seqid, iprot, oprot)
1740:                         args = read_args(iprot, UpdateLinkedNotebook_args)
1741:                         result = UpdateLinkedNotebook_result.new()
1742:                         begin
1743:                           result.success = @handler.updateLinkedNotebook(args.authenticationToken, args.linkedNotebook)
1744:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1745:                           result.userException = userException
1746:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1747:                           result.notFoundException = notFoundException
1748:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1749:                           result.systemException = systemException
1750:                         end
1751:                         write_result(result, oprot, 'updateLinkedNotebook', seqid)
1752:                       end
process_updateNote(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1404
1404:                       def process_updateNote(seqid, iprot, oprot)
1405:                         args = read_args(iprot, UpdateNote_args)
1406:                         result = UpdateNote_result.new()
1407:                         begin
1408:                           result.success = @handler.updateNote(args.authenticationToken, args.note)
1409:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1410:                           result.userException = userException
1411:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1412:                           result.systemException = systemException
1413:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1414:                           result.notFoundException = notFoundException
1415:                         end
1416:                         write_result(result, oprot, 'updateNote', seqid)
1417:                       end
process_updateNotebook(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1095
1095:                       def process_updateNotebook(seqid, iprot, oprot)
1096:                         args = read_args(iprot, UpdateNotebook_args)
1097:                         result = UpdateNotebook_result.new()
1098:                         begin
1099:                           result.success = @handler.updateNotebook(args.authenticationToken, args.notebook)
1100:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1101:                           result.userException = userException
1102:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1103:                           result.systemException = systemException
1104:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1105:                           result.notFoundException = notFoundException
1106:                         end
1107:                         write_result(result, oprot, 'updateNotebook', seqid)
1108:                       end
process_updateResource(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1537
1537:                       def process_updateResource(seqid, iprot, oprot)
1538:                         args = read_args(iprot, UpdateResource_args)
1539:                         result = UpdateResource_result.new()
1540:                         begin
1541:                           result.success = @handler.updateResource(args.authenticationToken, args.resource)
1542:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1543:                           result.userException = userException
1544:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1545:                           result.systemException = systemException
1546:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1547:                           result.notFoundException = notFoundException
1548:                         end
1549:                         write_result(result, oprot, 'updateResource', seqid)
1550:                       end
process_updateSearch(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1269
1269:                       def process_updateSearch(seqid, iprot, oprot)
1270:                         args = read_args(iprot, UpdateSearch_args)
1271:                         result = UpdateSearch_result.new()
1272:                         begin
1273:                           result.success = @handler.updateSearch(args.authenticationToken, args.search)
1274:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1275:                           result.userException = userException
1276:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1277:                           result.systemException = systemException
1278:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1279:                           result.notFoundException = notFoundException
1280:                         end
1281:                         write_result(result, oprot, 'updateSearch', seqid)
1282:                       end
process_updateTag(seqid, iprot, oprot) click to toggle source
      # File /tmp/buildd/evernote-mode-0.10/ruby/lib/Evernote/EDAM/note_store.rb, line 1183
1183:                       def process_updateTag(seqid, iprot, oprot)
1184:                         args = read_args(iprot, UpdateTag_args)
1185:                         result = UpdateTag_result.new()
1186:                         begin
1187:                           result.success = @handler.updateTag(args.authenticationToken, args.tag)
1188:                         rescue Evernote::EDAM::Error::EDAMUserException => userException
1189:                           result.userException = userException
1190:                         rescue Evernote::EDAM::Error::EDAMSystemException => systemException
1191:                           result.systemException = systemException
1192:                         rescue Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
1193:                           result.notFoundException = notFoundException
1194:                         end
1195:                         write_result(result, oprot, 'updateTag', seqid)
1196:                       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.