experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp - Issue 18179007: refactor folders to make prepare for native pdf parser

Side by Side Diff: experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp

Issue 18179007: refactor folders to make prepare for native pdf parser (Closed) Base URL: http://skia.googlecode.com/svn/trunk/

Patch Set: Created 7 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

« no previous file with comments | « experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.h ('k') | experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 #include "SkPdfPodofoMapper_autogen.h"

2 bool mapObject(const SkPdfObject& in, SkPdfObject** out) {

3 return mapObject(in.doc(), in.podofo(), out);

4 }

5

6 bool mapObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPd fObject** out) {

7 if (!isObject(podofoDoc, podofoObj)) return false;

8

9 if (mapArray(podofoDoc, podofoObj, (SkPdfArray**)out)) return true;

10 if (mapBoolean(podofoDoc, podofoObj, (SkPdfBoolean**)out)) return true;

11 if (mapDictionary(podofoDoc, podofoObj, (SkPdfDictionary**)out)) return true;

12 if (mapInteger(podofoDoc, podofoObj, (SkPdfInteger**)out)) return true;

13 if (mapName(podofoDoc, podofoObj, (SkPdfName**)out)) return true;

14 if (mapNull(podofoDoc, podofoObj, (SkPdfNull**)out)) return true;

15 if (mapReference(podofoDoc, podofoObj, (SkPdfReference**)out)) return true;

16 if (mapString(podofoDoc, podofoObj, (SkPdfString**)out)) return true;

17 if (mapStream(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;

18

19 *out = new SkPdfObject(&podofoDoc, &podofoObj);

20 return true;

21 }

22

23 bool mapNull(const SkPdfObject& in, SkPdfNull** out) {

24 return mapNull(in.doc(), in.podofo(), out);

25 }

26

27 bool mapNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfN ull** out) {

28 if (!isNull(podofoDoc, podofoObj)) return false;

29

30

31 *out = new SkPdfNull(&podofoDoc, &podofoObj);

32 return true;

33 }

34

35 bool mapBoolean(const SkPdfObject& in, SkPdfBoolean** out) {

36 return mapBoolean(in.doc(), in.podofo(), out);

37 }

38

39 bool mapBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkP dfBoolean** out) {

40 if (!isBoolean(podofoDoc, podofoObj)) return false;

41

42

43 *out = new SkPdfBoolean(&podofoDoc, &podofoObj);

44 return true;

45 }

46

47 bool mapInteger(const SkPdfObject& in, SkPdfInteger** out) {

48 return mapInteger(in.doc(), in.podofo(), out);

49 }

50

51 bool mapInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkP dfInteger** out) {

52 if (!isInteger(podofoDoc, podofoObj)) return false;

53

54 if (mapNumber(podofoDoc, podofoObj, (SkPdfNumber**)out)) return true;

55

56 *out = new SkPdfInteger(&podofoDoc, &podofoObj);

57 return true;

58 }

59

60 bool mapNumber(const SkPdfObject& in, SkPdfNumber** out) {

61 return mapNumber(in.doc(), in.podofo(), out);

62 }

63

64 bool mapNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPd fNumber** out) {

65 if (!isNumber(podofoDoc, podofoObj)) return false;

66

67

68 *out = new SkPdfNumber(&podofoDoc, &podofoObj);

69 return true;

70 }

71

72 bool mapName(const SkPdfObject& in, SkPdfName** out) {

73 return mapName(in.doc(), in.podofo(), out);

74 }

75

76 bool mapName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfN ame** out) {

77 if (!isName(podofoDoc, podofoObj)) return false;

78

79

80 *out = new SkPdfName(&podofoDoc, &podofoObj);

81 return true;

82 }

83

84 bool mapReference(const SkPdfObject& in, SkPdfReference** out) {

85 return mapReference(in.doc(), in.podofo(), out);

86 }

87

88 bool mapReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S kPdfReference** out) {

89 if (!isReference(podofoDoc, podofoObj)) return false;

90

91

92 *out = new SkPdfReference(&podofoDoc, &podofoObj);

93 return true;

94 }

95

96 bool mapArray(const SkPdfObject& in, SkPdfArray** out) {

97 return mapArray(in.doc(), in.podofo(), out);

98 }

99

100 bool mapArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf Array** out) {

101 if (!isArray(podofoDoc, podofoObj)) return false;

102

103

104 *out = new SkPdfArray(&podofoDoc, &podofoObj);

105 return true;

106 }

107

108 bool mapString(const SkPdfObject& in, SkPdfString** out) {

109 return mapString(in.doc(), in.podofo(), out);

110 }

111

112 bool mapString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPd fString** out) {

113 if (!isString(podofoDoc, podofoObj)) return false;

114

115 if (mapHexString(podofoDoc, podofoObj, (SkPdfHexString**)out)) return true;

116

117 *out = new SkPdfString(&podofoDoc, &podofoObj);

118 return true;

119 }

120

121 bool mapHexString(const SkPdfObject& in, SkPdfHexString** out) {

122 return mapHexString(in.doc(), in.podofo(), out);

123 }

124

125 bool mapHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, S kPdfHexString** out) {

126 if (!isHexString(podofoDoc, podofoObj)) return false;

127

128

129 *out = new SkPdfHexString(&podofoDoc, &podofoObj);

130 return true;

131 }

132

133 bool mapDictionary(const SkPdfObject& in, SkPdfDictionary** out) {

134 return mapDictionary(in.doc(), in.podofo(), out);

135 }

136

137 bool mapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDictionary** out) {

138 if (!isDictionary(podofoDoc, podofoObj)) return false;

139

140 if (mapALinkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfALinkAnnotationDi ctionary**)out)) return true;

141 if (mapActionDictionary(podofoDoc, podofoObj, (SkPdfActionDictionary**)out)) r eturn true;

142 if (mapAlternateImageDictionary(podofoDoc, podofoObj, (SkPdfAlternateImageDict ionary**)out)) return true;

143 if (mapAnnotationActionsDictionary(podofoDoc, podofoObj, (SkPdfAnnotationActio nsDictionary**)out)) return true;

144 if (mapAnnotationDictionary(podofoDoc, podofoObj, (SkPdfAnnotationDictionary** )out)) return true;

145 if (mapAppearanceCharacteristicsDictionary(podofoDoc, podofoObj, (SkPdfAppeara nceCharacteristicsDictionary**)out)) return true;

146 if (mapAppearanceDictionary(podofoDoc, podofoObj, (SkPdfAppearanceDictionary** )out)) return true;

147 if (mapApplicationDataDictionary(podofoDoc, podofoObj, (SkPdfApplicationDataDi ctionary**)out)) return true;

148 if (mapArtifactsDictionary(podofoDoc, podofoObj, (SkPdfArtifactsDictionary**)o ut)) return true;

149 if (mapAttributeObjectDictionary(podofoDoc, podofoObj, (SkPdfAttributeObjectDi ctionary**)out)) return true;

150 if (mapBeadDictionary(podofoDoc, podofoObj, (SkPdfBeadDictionary**)out)) retur n true;

151 if (mapBlockLevelStructureElementsDictionary(podofoDoc, podofoObj, (SkPdfBlock LevelStructureElementsDictionary**)out)) return true;

152 if (mapBorderStyleDictionary(podofoDoc, podofoObj, (SkPdfBorderStyleDictionary **)out)) return true;

153 if (mapBoxColorInformationDictionary(podofoDoc, podofoObj, (SkPdfBoxColorInfor mationDictionary**)out)) return true;

154 if (mapBoxStyleDictionary(podofoDoc, podofoObj, (SkPdfBoxStyleDictionary**)out )) return true;

155 if (mapCIDFontDescriptorDictionary(podofoDoc, podofoObj, (SkPdfCIDFontDescript orDictionary**)out)) return true;

156 if (mapCIDFontDictionary(podofoDoc, podofoObj, (SkPdfCIDFontDictionary**)out)) return true;

157 if (mapCIDSystemInfoDictionary(podofoDoc, podofoObj, (SkPdfCIDSystemInfoDictio nary**)out)) return true;

158 if (mapCMapDictionary(podofoDoc, podofoObj, (SkPdfCMapDictionary**)out)) retur n true;

159 if (mapCalgrayColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfCalgrayColorSpa ceDictionary**)out)) return true;

160 if (mapCalrgbColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfCalrgbColorSpace Dictionary**)out)) return true;

161 if (mapCatalogDictionary(podofoDoc, podofoObj, (SkPdfCatalogDictionary**)out)) return true;

162 if (mapCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj, (SkPdfCcittfaxdeco deFilterDictionary**)out)) return true;

163 if (mapCheckboxFieldDictionary(podofoDoc, podofoObj, (SkPdfCheckboxFieldDictio nary**)out)) return true;

164 if (mapChoiceFieldDictionary(podofoDoc, podofoObj, (SkPdfChoiceFieldDictionary **)out)) return true;

165 if (mapComponentsWithMetadataDictionary(podofoDoc, podofoObj, (SkPdfComponents WithMetadataDictionary**)out)) return true;

166 if (mapDctdecodeFilterDictionary(podofoDoc, podofoObj, (SkPdfDctdecodeFilterDi ctionary**)out)) return true;

167 if (mapDeviceNColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfDeviceNColorSpa ceDictionary**)out)) return true;

168 if (mapDocumentCatalogActionsDictionary(podofoDoc, podofoObj, (SkPdfDocumentCa talogActionsDictionary**)out)) return true;

169 if (mapDocumentInformationDictionary(podofoDoc, podofoObj, (SkPdfDocumentInfor mationDictionary**)out)) return true;

170 if (mapEmbeddedFileParameterDictionary(podofoDoc, podofoObj, (SkPdfEmbeddedFil eParameterDictionary**)out)) return true;

171 if (mapEmbeddedFileStreamDictionary(podofoDoc, podofoObj, (SkPdfEmbeddedFileSt reamDictionary**)out)) return true;

172 if (mapEmbeddedFontStreamDictionary(podofoDoc, podofoObj, (SkPdfEmbeddedFontSt reamDictionary**)out)) return true;

173 if (mapEncodingDictionary(podofoDoc, podofoObj, (SkPdfEncodingDictionary**)out )) return true;

174 if (mapEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj, (SkPdfEncry ptedEmbeddedFileStreamDictionary**)out)) return true;

175 if (mapEncryptionCommonDictionary(podofoDoc, podofoObj, (SkPdfEncryptionCommon Dictionary**)out)) return true;

176 if (mapFDFCatalogDictionary(podofoDoc, podofoObj, (SkPdfFDFCatalogDictionary** )out)) return true;

177 if (mapFDFDictionary(podofoDoc, podofoObj, (SkPdfFDFDictionary**)out)) return true;

178 if (mapFDFFieldDictionary(podofoDoc, podofoObj, (SkPdfFDFFieldDictionary**)out )) return true;

179 if (mapFDFFileAnnotationDictionary(podofoDoc, podofoObj, (SkPdfFDFFileAnnotati onDictionary**)out)) return true;

180 if (mapFDFNamedPageReferenceDictionary(podofoDoc, podofoObj, (SkPdfFDFNamedPag eReferenceDictionary**)out)) return true;

181 if (mapFDFPageDictionary(podofoDoc, podofoObj, (SkPdfFDFPageDictionary**)out)) return true;

182 if (mapFDFTemplateDictionary(podofoDoc, podofoObj, (SkPdfFDFTemplateDictionary **)out)) return true;

183 if (mapFDFTrailerDictionary(podofoDoc, podofoObj, (SkPdfFDFTrailerDictionary** )out)) return true;

184 if (mapFieldDictionary(podofoDoc, podofoObj, (SkPdfFieldDictionary**)out)) ret urn true;

185 if (mapFileAttachmentAnnotationDictionary(podofoDoc, podofoObj, (SkPdfFileAtta chmentAnnotationDictionary**)out)) return true;

186 if (mapFileSpecificationDictionary(podofoDoc, podofoObj, (SkPdfFileSpecificati onDictionary**)out)) return true;

187 if (mapFileTrailerDictionary(podofoDoc, podofoObj, (SkPdfFileTrailerDictionary **)out)) return true;

188 if (mapFontDescriptorDictionary(podofoDoc, podofoObj, (SkPdfFontDescriptorDict ionary**)out)) return true;

189 if (mapFontDictionary(podofoDoc, podofoObj, (SkPdfFontDictionary**)out)) retur n true;

190 if (mapFormFieldActionsDictionary(podofoDoc, podofoObj, (SkPdfFormFieldActions Dictionary**)out)) return true;

191 if (mapFreeTextAnnotationDictionary(podofoDoc, podofoObj, (SkPdfFreeTextAnnota tionDictionary**)out)) return true;

192 if (mapFunctionCommonDictionary(podofoDoc, podofoObj, (SkPdfFunctionCommonDict ionary**)out)) return true;

193 if (mapGoToActionDictionary(podofoDoc, podofoObj, (SkPdfGoToActionDictionary** )out)) return true;

194 if (mapGraphicsStateDictionary(podofoDoc, podofoObj, (SkPdfGraphicsStateDictio nary**)out)) return true;

195 if (mapGroupAttributesDictionary(podofoDoc, podofoObj, (SkPdfGroupAttributesDi ctionary**)out)) return true;

196 if (mapHideActionDictionary(podofoDoc, podofoObj, (SkPdfHideActionDictionary** )out)) return true;

197 if (mapIccProfileStreamDictionary(podofoDoc, podofoObj, (SkPdfIccProfileStream Dictionary**)out)) return true;

198 if (mapIconFitDictionary(podofoDoc, podofoObj, (SkPdfIconFitDictionary**)out)) return true;

199 if (mapImportDataActionDictionary(podofoDoc, podofoObj, (SkPdfImportDataAction Dictionary**)out)) return true;

200 if (mapInkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfInkAnnotationDictio nary**)out)) return true;

201 if (mapInlineLevelStructureElementsDictionary(podofoDoc, podofoObj, (SkPdfInli neLevelStructureElementsDictionary**)out)) return true;

202 if (mapInteractiveFormDictionary(podofoDoc, podofoObj, (SkPdfInteractiveFormDi ctionary**)out)) return true;

203 if (mapJavascriptActionDictionary(podofoDoc, podofoObj, (SkPdfJavascriptAction Dictionary**)out)) return true;

204 if (mapJavascriptDictionary(podofoDoc, podofoObj, (SkPdfJavascriptDictionary** )out)) return true;

205 if (mapJbig2DecodeFilterDictionary(podofoDoc, podofoObj, (SkPdfJbig2DecodeFilt erDictionary**)out)) return true;

206 if (mapLabColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfLabColorSpaceDictio nary**)out)) return true;

207 if (mapLaunchActionDictionary(podofoDoc, podofoObj, (SkPdfLaunchActionDictiona ry**)out)) return true;

208 if (mapLineAnnotationDictionary(podofoDoc, podofoObj, (SkPdfLineAnnotationDict ionary**)out)) return true;

209 if (mapListAttributeDictionary(podofoDoc, podofoObj, (SkPdfListAttributeDictio nary**)out)) return true;

210 if (mapLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj, (SkPdfLz wdecodeAndFlatedecodeFiltersDictionary**)out)) return true;

211 if (mapMacOsFileInformationDictionary(podofoDoc, podofoObj, (SkPdfMacOsFileInf ormationDictionary**)out)) return true;

212 if (mapMarkInformationDictionary(podofoDoc, podofoObj, (SkPdfMarkInformationDi ctionary**)out)) return true;

213 if (mapMarkedContentReferenceDictionary(podofoDoc, podofoObj, (SkPdfMarkedCont entReferenceDictionary**)out)) return true;

214 if (mapMarkupAnnotationsDictionary(podofoDoc, podofoObj, (SkPdfMarkupAnnotatio nsDictionary**)out)) return true;

215 if (mapMetadataStreamDictionary(podofoDoc, podofoObj, (SkPdfMetadataStreamDict ionary**)out)) return true;

216 if (mapMovieActionDictionary(podofoDoc, podofoObj, (SkPdfMovieActionDictionary **)out)) return true;

217 if (mapMovieActivationDictionary(podofoDoc, podofoObj, (SkPdfMovieActivationDi ctionary**)out)) return true;

218 if (mapMovieAnnotationDictionary(podofoDoc, podofoObj, (SkPdfMovieAnnotationDi ctionary**)out)) return true;

219 if (mapMovieDictionary(podofoDoc, podofoObj, (SkPdfMovieDictionary**)out)) ret urn true;

220 if (mapNameDictionary(podofoDoc, podofoObj, (SkPdfNameDictionary**)out)) retur n true;

221 if (mapNameTreeNodeDictionary(podofoDoc, podofoObj, (SkPdfNameTreeNodeDictiona ry**)out)) return true;

222 if (mapNamedActionsDictionary(podofoDoc, podofoObj, (SkPdfNamedActionsDictiona ry**)out)) return true;

223 if (mapNumberTreeNodeDictionary(podofoDoc, podofoObj, (SkPdfNumberTreeNodeDict ionary**)out)) return true;

224 if (mapObjectReferenceDictionary(podofoDoc, podofoObj, (SkPdfObjectReferenceDi ctionary**)out)) return true;

225 if (mapOpiVersionDictionary(podofoDoc, podofoObj, (SkPdfOpiVersionDictionary** )out)) return true;

226 if (mapOutlineDictionary(podofoDoc, podofoObj, (SkPdfOutlineDictionary**)out)) return true;

227 if (mapOutlineItemDictionary(podofoDoc, podofoObj, (SkPdfOutlineItemDictionary **)out)) return true;

228 if (mapPDF_XOutputIntentDictionary(podofoDoc, podofoObj, (SkPdfPDF_XOutputInte ntDictionary**)out)) return true;

229 if (mapPSXobjectDictionary(podofoDoc, podofoObj, (SkPdfPSXobjectDictionary**)o ut)) return true;

230 if (mapPageLabelDictionary(podofoDoc, podofoObj, (SkPdfPageLabelDictionary**)o ut)) return true;

231 if (mapPageObjectActionsDictionary(podofoDoc, podofoObj, (SkPdfPageObjectActio nsDictionary**)out)) return true;

232 if (mapPageObjectDictionary(podofoDoc, podofoObj, (SkPdfPageObjectDictionary** )out)) return true;

233 if (mapPagePieceDictionary(podofoDoc, podofoObj, (SkPdfPagePieceDictionary**)o ut)) return true;

234 if (mapPageTreeNodeDictionary(podofoDoc, podofoObj, (SkPdfPageTreeNodeDictiona ry**)out)) return true;

235 if (mapPopUpAnnotationDictionary(podofoDoc, podofoObj, (SkPdfPopUpAnnotationDi ctionary**)out)) return true;

236 if (mapPrinterMarkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfPrinterMark AnnotationDictionary**)out)) return true;

237 if (mapPrinterMarkFormDictionary(podofoDoc, podofoObj, (SkPdfPrinterMarkFormDi ctionary**)out)) return true;

238 if (mapRadioButtonFieldDictionary(podofoDoc, podofoObj, (SkPdfRadioButtonField Dictionary**)out)) return true;

239 if (mapReferenceDictionary(podofoDoc, podofoObj, (SkPdfReferenceDictionary**)o ut)) return true;

240 if (mapRemoteGoToActionDictionary(podofoDoc, podofoObj, (SkPdfRemoteGoToAction Dictionary**)out)) return true;

241 if (mapResetFormActionDictionary(podofoDoc, podofoObj, (SkPdfResetFormActionDi ctionary**)out)) return true;

242 if (mapResourceDictionary(podofoDoc, podofoObj, (SkPdfResourceDictionary**)out )) return true;

243 if (mapRubberStampAnnotationDictionary(podofoDoc, podofoObj, (SkPdfRubberStamp AnnotationDictionary**)out)) return true;

244 if (mapSeparationDictionary(podofoDoc, podofoObj, (SkPdfSeparationDictionary** )out)) return true;

245 if (mapShadingDictionary(podofoDoc, podofoObj, (SkPdfShadingDictionary**)out)) return true;

246 if (mapSignatureDictionary(podofoDoc, podofoObj, (SkPdfSignatureDictionary**)o ut)) return true;

247 if (mapSoftMaskDictionary(podofoDoc, podofoObj, (SkPdfSoftMaskDictionary**)out )) return true;

248 if (mapSoftMaskImageDictionary(podofoDoc, podofoObj, (SkPdfSoftMaskImageDictio nary**)out)) return true;

249 if (mapSoundActionDictionary(podofoDoc, podofoObj, (SkPdfSoundActionDictionary **)out)) return true;

250 if (mapSoundAnnotationDictionary(podofoDoc, podofoObj, (SkPdfSoundAnnotationDi ctionary**)out)) return true;

251 if (mapSoundObjectDictionary(podofoDoc, podofoObj, (SkPdfSoundObjectDictionary **)out)) return true;

252 if (mapSourceInformationDictionary(podofoDoc, podofoObj, (SkPdfSourceInformati onDictionary**)out)) return true;

253 if (mapSquareOrCircleAnnotation(podofoDoc, podofoObj, (SkPdfSquareOrCircleAnno tation**)out)) return true;

254 if (mapStandardSecurityHandlerDictionary(podofoDoc, podofoObj, (SkPdfStandardS ecurityHandlerDictionary**)out)) return true;

255 if (mapStandardStructureDictionary(podofoDoc, podofoObj, (SkPdfStandardStructu reDictionary**)out)) return true;

256 if (mapStreamCommonDictionary(podofoDoc, podofoObj, (SkPdfStreamCommonDictiona ry**)out)) return true;

257 if (mapStructureElementAccessDictionary(podofoDoc, podofoObj, (SkPdfStructureE lementAccessDictionary**)out)) return true;

258 if (mapStructureElementDictionary(podofoDoc, podofoObj, (SkPdfStructureElement Dictionary**)out)) return true;

259 if (mapStructureTreeRootDictionary(podofoDoc, podofoObj, (SkPdfStructureTreeRo otDictionary**)out)) return true;

260 if (mapSubmitFormActionDictionary(podofoDoc, podofoObj, (SkPdfSubmitFormAction Dictionary**)out)) return true;

261 if (mapTableAttributesDictionary(podofoDoc, podofoObj, (SkPdfTableAttributesDi ctionary**)out)) return true;

262 if (mapTextAnnotationDictionary(podofoDoc, podofoObj, (SkPdfTextAnnotationDict ionary**)out)) return true;

263 if (mapTextFieldDictionary(podofoDoc, podofoObj, (SkPdfTextFieldDictionary**)o ut)) return true;

264 if (mapThreadActionDictionary(podofoDoc, podofoObj, (SkPdfThreadActionDictiona ry**)out)) return true;

265 if (mapThreadDictionary(podofoDoc, podofoObj, (SkPdfThreadDictionary**)out)) r eturn true;

266 if (mapTransitionDictionary(podofoDoc, podofoObj, (SkPdfTransitionDictionary** )out)) return true;

267 if (mapTransparencyGroupDictionary(podofoDoc, podofoObj, (SkPdfTransparencyGro upDictionary**)out)) return true;

268 if (mapTrapNetworkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfTrapNetwork AnnotationDictionary**)out)) return true;

269 if (mapTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj, (SkPdfTrapN etworkAppearanceStreamDictionary**)out)) return true;

270 if (mapType0FunctionDictionary(podofoDoc, podofoObj, (SkPdfType0FunctionDictio nary**)out)) return true;

271 if (mapType10HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType10HalftoneDict ionary**)out)) return true;

272 if (mapType16HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType16HalftoneDict ionary**)out)) return true;

273 if (mapType1HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType1HalftoneDictio nary**)out)) return true;

274 if (mapType1PatternDictionary(podofoDoc, podofoObj, (SkPdfType1PatternDictiona ry**)out)) return true;

275 if (mapType2FunctionDictionary(podofoDoc, podofoObj, (SkPdfType2FunctionDictio nary**)out)) return true;

276 if (mapType2PatternDictionary(podofoDoc, podofoObj, (SkPdfType2PatternDictiona ry**)out)) return true;

277 if (mapType3FunctionDictionary(podofoDoc, podofoObj, (SkPdfType3FunctionDictio nary**)out)) return true;

278 if (mapType5HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType5HalftoneDictio nary**)out)) return true;

279 if (mapType6HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType6HalftoneDictio nary**)out)) return true;

280 if (mapURIActionDictionary(podofoDoc, podofoObj, (SkPdfURIActionDictionary**)o ut)) return true;

281 if (mapURIDictionary(podofoDoc, podofoObj, (SkPdfURIDictionary**)out)) return true;

282 if (mapURLAliasDictionary(podofoDoc, podofoObj, (SkPdfURLAliasDictionary**)out )) return true;

283 if (mapVariableTextFieldDictionary(podofoDoc, podofoObj, (SkPdfVariableTextFie ldDictionary**)out)) return true;

284 if (mapViewerPreferencesDictionary(podofoDoc, podofoObj, (SkPdfViewerPreferenc esDictionary**)out)) return true;

285 if (mapWebCaptureCommandDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureComma ndDictionary**)out)) return true;

286 if (mapWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj, (SkPdfWebCapt ureCommandSettingsDictionary**)out)) return true;

287 if (mapWebCaptureDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureDictionary** )out)) return true;

288 if (mapWebCaptureImageSetDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureImag eSetDictionary**)out)) return true;

289 if (mapWebCaptureInformationDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureI nformationDictionary**)out)) return true;

290 if (mapWebCapturePageSetDictionary(podofoDoc, podofoObj, (SkPdfWebCapturePageS etDictionary**)out)) return true;

291 if (mapWidgetAnnotationDictionary(podofoDoc, podofoObj, (SkPdfWidgetAnnotation Dictionary**)out)) return true;

292 if (mapWindowsLaunchActionDictionary(podofoDoc, podofoObj, (SkPdfWindowsLaunch ActionDictionary**)out)) return true;

293 if (mapXObjectDictionary(podofoDoc, podofoObj, (SkPdfXObjectDictionary**)out)) return true;

294

295 *out = new SkPdfDictionary(&podofoDoc, &podofoObj);

296 return true;

297 }

298

299 bool mapStream(const SkPdfObject& in, SkPdfStream** out) {

300 return mapStream(in.doc(), in.podofo(), out);

301 }

302

303 bool mapStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPd fStream** out) {

304 if (!isStream(podofoDoc, podofoObj)) return false;

305

306

307 *out = new SkPdfStream(&podofoDoc, &podofoObj);

308 return true;

309 }

310

311 bool mapXObjectDictionary(const SkPdfObject& in, SkPdfXObjectDictionary** out) {

312 return mapXObjectDictionary(in.doc(), in.podofo(), out);

313 }

314

315 bool mapXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj, SkPdfXObjectDictionary** out) {

316 if (!isXObjectDictionary(podofoDoc, podofoObj)) return false;

317

318 if (mapImageDictionary(podofoDoc, podofoObj, (SkPdfImageDictionary**)out)) ret urn true;

319 if (mapType1FormDictionary(podofoDoc, podofoObj, (SkPdfType1FormDictionary**)o ut)) return true;

320

321 *out = new SkPdfXObjectDictionary(&podofoDoc, &podofoObj);

322 return true;

323 }

324

325 bool mapFontDictionary(const SkPdfObject& in, SkPdfFontDictionary** out) {

326 return mapFontDictionary(in.doc(), in.podofo(), out);

327 }

328

329 bool mapFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoO bj, SkPdfFontDictionary** out) {

330 if (!isFontDictionary(podofoDoc, podofoObj)) return false;

331

332 if (mapType0FontDictionary(podofoDoc, podofoObj, (SkPdfType0FontDictionary**)o ut)) return true;

333 if (mapType1FontDictionary(podofoDoc, podofoObj, (SkPdfType1FontDictionary**)o ut)) return true;

334

335 *out = new SkPdfFontDictionary(&podofoDoc, &podofoObj);

336 return true;

337 }

338

339 bool mapTrueTypeFontDictionary(const SkPdfObject& in, SkPdfTrueTypeFontDictionar y** out) {

340 return mapTrueTypeFontDictionary(in.doc(), in.podofo(), out);

341 }

342

343 bool mapTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrueTypeFontDictionary** out) {

344 if (!isTrueTypeFontDictionary(podofoDoc, podofoObj)) return false;

345

346

347 *out = new SkPdfTrueTypeFontDictionary(&podofoDoc, &podofoObj);

348 return true;

349 }

350

351 bool mapStreamCommonDictionary(const SkPdfObject& in, SkPdfStreamCommonDictionar y** out) {

352 return mapStreamCommonDictionary(in.doc(), in.podofo(), out);

353 }

354

355 bool mapStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStreamCommonDictionary** out) {

356 if (!isStreamCommonDictionary(podofoDoc, podofoObj)) return false;

357

358

359 *out = new SkPdfStreamCommonDictionary(&podofoDoc, &podofoObj);

360 return true;

361 }

362

363 bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const SkPdfObject& in, SkPdfLzw decodeAndFlatedecodeFiltersDictionary** out) {

364 return mapLzwdecodeAndFlatedecodeFiltersDictionary(in.doc(), in.podofo(), ou t);

365 }

366

367 bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc , const PdfObject& podofoObj, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** ou t) {

368 if (!isLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj)) return false;

369

370

371 *out = new SkPdfLzwdecodeAndFlatedecodeFiltersDictionary(&podofoDoc, &podofoOb j);

372 return true;

373 }

374

375 bool mapCcittfaxdecodeFilterDictionary(const SkPdfObject& in, SkPdfCcittfaxdecod eFilterDictionary** out) {

376 return mapCcittfaxdecodeFilterDictionary(in.doc(), in.podofo(), out);

377 }

378

379 bool mapCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const Pd fObject& podofoObj, SkPdfCcittfaxdecodeFilterDictionary** out) {

380 if (!isCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj)) return false;

381

382

383 *out = new SkPdfCcittfaxdecodeFilterDictionary(&podofoDoc, &podofoObj);

384 return true;

385 }

386

387 bool mapJbig2DecodeFilterDictionary(const SkPdfObject& in, SkPdfJbig2DecodeFilte rDictionary** out) {

388 return mapJbig2DecodeFilterDictionary(in.doc(), in.podofo(), out);

389 }

390

391 bool mapJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfJbig2DecodeFilterDictionary** out) {

392 if (!isJbig2DecodeFilterDictionary(podofoDoc, podofoObj)) return false;

393

394

395 *out = new SkPdfJbig2DecodeFilterDictionary(&podofoDoc, &podofoObj);

396 return true;

397 }

398

399 bool mapDctdecodeFilterDictionary(const SkPdfObject& in, SkPdfDctdecodeFilterDic tionary** out) {

400 return mapDctdecodeFilterDictionary(in.doc(), in.podofo(), out);

401 }

402

403 bool mapDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfDctdecodeFilterDictionary** out) {

404 if (!isDctdecodeFilterDictionary(podofoDoc, podofoObj)) return false;

405

406

407 *out = new SkPdfDctdecodeFilterDictionary(&podofoDoc, &podofoObj);

408 return true;

409 }

410

411 bool mapFileTrailerDictionary(const SkPdfObject& in, SkPdfFileTrailerDictionary* * out) {

412 return mapFileTrailerDictionary(in.doc(), in.podofo(), out);

413 }

414

415 bool mapFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileTrailerDictionary** out) {

416 if (!isFileTrailerDictionary(podofoDoc, podofoObj)) return false;

417

418

419 *out = new SkPdfFileTrailerDictionary(&podofoDoc, &podofoObj);

420 return true;

421 }

422

423 bool mapEncryptionCommonDictionary(const SkPdfObject& in, SkPdfEncryptionCommonD ictionary** out) {

424 return mapEncryptionCommonDictionary(in.doc(), in.podofo(), out);

425 }

426

427 bool mapEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfEncryptionCommonDictionary** out) {

428 if (!isEncryptionCommonDictionary(podofoDoc, podofoObj)) return false;

429

430

431 *out = new SkPdfEncryptionCommonDictionary(&podofoDoc, &podofoObj);

432 return true;

433 }

434

435 bool mapStandardSecurityHandlerDictionary(const SkPdfObject& in, SkPdfStandardSe curityHandlerDictionary** out) {

436 return mapStandardSecurityHandlerDictionary(in.doc(), in.podofo(), out);

437 }

438

439 bool mapStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardSecurityHandlerDictionary** out) {

440 if (!isStandardSecurityHandlerDictionary(podofoDoc, podofoObj)) return false;

441

442

443 *out = new SkPdfStandardSecurityHandlerDictionary(&podofoDoc, &podofoObj);

444 return true;

445 }

446

447 bool mapCatalogDictionary(const SkPdfObject& in, SkPdfCatalogDictionary** out) {

448 return mapCatalogDictionary(in.doc(), in.podofo(), out);

449 }

450

451 bool mapCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj, SkPdfCatalogDictionary** out) {

452 if (!isCatalogDictionary(podofoDoc, podofoObj)) return false;

453

454

455 *out = new SkPdfCatalogDictionary(&podofoDoc, &podofoObj);

456 return true;

457 }

458

459 bool mapPageTreeNodeDictionary(const SkPdfObject& in, SkPdfPageTreeNodeDictionar y** out) {

460 return mapPageTreeNodeDictionary(in.doc(), in.podofo(), out);

461 }

462

463 bool mapPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageTreeNodeDictionary** out) {

464 if (!isPageTreeNodeDictionary(podofoDoc, podofoObj)) return false;

465

466

467 *out = new SkPdfPageTreeNodeDictionary(&podofoDoc, &podofoObj);

468 return true;

469 }

470

471 bool mapPageObjectDictionary(const SkPdfObject& in, SkPdfPageObjectDictionary** out) {

472 return mapPageObjectDictionary(in.doc(), in.podofo(), out);

473 }

474

475 bool mapPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfPageObjectDictionary** out) {

476 if (!isPageObjectDictionary(podofoDoc, podofoObj)) return false;

477

478

479 *out = new SkPdfPageObjectDictionary(&podofoDoc, &podofoObj);

480 return true;

481 }

482

483 bool mapNameDictionary(const SkPdfObject& in, SkPdfNameDictionary** out) {

484 return mapNameDictionary(in.doc(), in.podofo(), out);

485 }

486

487 bool mapNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoO bj, SkPdfNameDictionary** out) {

488 if (!isNameDictionary(podofoDoc, podofoObj)) return false;

489

490

491 *out = new SkPdfNameDictionary(&podofoDoc, &podofoObj);

492 return true;

493 }

494

495 bool mapResourceDictionary(const SkPdfObject& in, SkPdfResourceDictionary** out) {

496 return mapResourceDictionary(in.doc(), in.podofo(), out);

497 }

498

499 bool mapResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj, SkPdfResourceDictionary** out) {

500 if (!isResourceDictionary(podofoDoc, podofoObj)) return false;

501

502

503 *out = new SkPdfResourceDictionary(&podofoDoc, &podofoObj);

504 return true;

505 }

506

507 bool mapNameTreeNodeDictionary(const SkPdfObject& in, SkPdfNameTreeNodeDictionar y** out) {

508 return mapNameTreeNodeDictionary(in.doc(), in.podofo(), out);

509 }

510

511 bool mapNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameTreeNodeDictionary** out) {

512 if (!isNameTreeNodeDictionary(podofoDoc, podofoObj)) return false;

513

514

515 *out = new SkPdfNameTreeNodeDictionary(&podofoDoc, &podofoObj);

516 return true;

517 }

518

519 bool mapNumberTreeNodeDictionary(const SkPdfObject& in, SkPdfNumberTreeNodeDicti onary** out) {

520 return mapNumberTreeNodeDictionary(in.doc(), in.podofo(), out);

521 }

522

523 bool mapNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfNumberTreeNodeDictionary** out) {

524 if (!isNumberTreeNodeDictionary(podofoDoc, podofoObj)) return false;

525

526

527 *out = new SkPdfNumberTreeNodeDictionary(&podofoDoc, &podofoObj);

528 return true;

529 }

530

531 bool mapFunctionCommonDictionary(const SkPdfObject& in, SkPdfFunctionCommonDicti onary** out) {

532 return mapFunctionCommonDictionary(in.doc(), in.podofo(), out);

533 }

534

535 bool mapFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfFunctionCommonDictionary** out) {

536 if (!isFunctionCommonDictionary(podofoDoc, podofoObj)) return false;

537

538

539 *out = new SkPdfFunctionCommonDictionary(&podofoDoc, &podofoObj);

540 return true;

541 }

542

543 bool mapType0FunctionDictionary(const SkPdfObject& in, SkPdfType0FunctionDiction ary** out) {

544 return mapType0FunctionDictionary(in.doc(), in.podofo(), out);

545 }

546

547 bool mapType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfType0FunctionDictionary** out) {

548 if (!isType0FunctionDictionary(podofoDoc, podofoObj)) return false;

549

550

551 *out = new SkPdfType0FunctionDictionary(&podofoDoc, &podofoObj);

552 return true;

553 }

554

555 bool mapType2FunctionDictionary(const SkPdfObject& in, SkPdfType2FunctionDiction ary** out) {

556 return mapType2FunctionDictionary(in.doc(), in.podofo(), out);

557 }

558

559 bool mapType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfType2FunctionDictionary** out) {

560 if (!isType2FunctionDictionary(podofoDoc, podofoObj)) return false;

561

562

563 *out = new SkPdfType2FunctionDictionary(&podofoDoc, &podofoObj);

564 return true;

565 }

566

567 bool mapType3FunctionDictionary(const SkPdfObject& in, SkPdfType3FunctionDiction ary** out) {

568 return mapType3FunctionDictionary(in.doc(), in.podofo(), out);

569 }

570

571 bool mapType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfType3FunctionDictionary** out) {

572 if (!isType3FunctionDictionary(podofoDoc, podofoObj)) return false;

573

574

575 *out = new SkPdfType3FunctionDictionary(&podofoDoc, &podofoObj);

576 return true;

577 }

578

579 bool mapFileSpecificationDictionary(const SkPdfObject& in, SkPdfFileSpecificatio nDictionary** out) {

580 return mapFileSpecificationDictionary(in.doc(), in.podofo(), out);

581 }

582

583 bool mapFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfFileSpecificationDictionary** out) {

584 if (!isFileSpecificationDictionary(podofoDoc, podofoObj)) return false;

585

586

587 *out = new SkPdfFileSpecificationDictionary(&podofoDoc, &podofoObj);

588 return true;

589 }

590

591 bool mapEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFileStr eamDictionary** out) {

592 return mapEmbeddedFileStreamDictionary(in.doc(), in.podofo(), out);

593 }

594

595 bool mapEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfO bject& podofoObj, SkPdfEmbeddedFileStreamDictionary** out) {

596 if (!isEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;

597

598

599 *out = new SkPdfEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);

600 return true;

601 }

602

603 bool mapEmbeddedFileParameterDictionary(const SkPdfObject& in, SkPdfEmbeddedFile ParameterDictionary** out) {

604 return mapEmbeddedFileParameterDictionary(in.doc(), in.podofo(), out);

605 }

606

607 bool mapEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj, SkPdfEmbeddedFileParameterDictionary** out) {

608 if (!isEmbeddedFileParameterDictionary(podofoDoc, podofoObj)) return false;

609

610

611 *out = new SkPdfEmbeddedFileParameterDictionary(&podofoDoc, &podofoObj);

612 return true;

613 }

614

615 bool mapMacOsFileInformationDictionary(const SkPdfObject& in, SkPdfMacOsFileInfo rmationDictionary** out) {

616 return mapMacOsFileInformationDictionary(in.doc(), in.podofo(), out);

617 }

618

619 bool mapMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const Pd fObject& podofoObj, SkPdfMacOsFileInformationDictionary** out) {

620 if (!isMacOsFileInformationDictionary(podofoDoc, podofoObj)) return false;

621

622

623 *out = new SkPdfMacOsFileInformationDictionary(&podofoDoc, &podofoObj);

624 return true;

625 }

626

627 bool mapGraphicsStateDictionary(const SkPdfObject& in, SkPdfGraphicsStateDiction ary** out) {

628 return mapGraphicsStateDictionary(in.doc(), in.podofo(), out);

629 }

630

631 bool mapGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfGraphicsStateDictionary** out) {

632 if (!isGraphicsStateDictionary(podofoDoc, podofoObj)) return false;

633

634

635 *out = new SkPdfGraphicsStateDictionary(&podofoDoc, &podofoObj);

636 return true;

637 }

638

639 bool mapCalgrayColorSpaceDictionary(const SkPdfObject& in, SkPdfCalgrayColorSpac eDictionary** out) {

640 return mapCalgrayColorSpaceDictionary(in.doc(), in.podofo(), out);

641 }

642

643 bool mapCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfCalgrayColorSpaceDictionary** out) {

644 if (!isCalgrayColorSpaceDictionary(podofoDoc, podofoObj)) return false;

645

646

647 *out = new SkPdfCalgrayColorSpaceDictionary(&podofoDoc, &podofoObj);

648 return true;

649 }

650

651 bool mapCalrgbColorSpaceDictionary(const SkPdfObject& in, SkPdfCalrgbColorSpaceD ictionary** out) {

652 return mapCalrgbColorSpaceDictionary(in.doc(), in.podofo(), out);

653 }

654

655 bool mapCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfCalrgbColorSpaceDictionary** out) {

656 if (!isCalrgbColorSpaceDictionary(podofoDoc, podofoObj)) return false;

657

658

659 *out = new SkPdfCalrgbColorSpaceDictionary(&podofoDoc, &podofoObj);

660 return true;

661 }

662

663 bool mapLabColorSpaceDictionary(const SkPdfObject& in, SkPdfLabColorSpaceDiction ary** out) {

664 return mapLabColorSpaceDictionary(in.doc(), in.podofo(), out);

665 }

666

667 bool mapLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfLabColorSpaceDictionary** out) {

668 if (!isLabColorSpaceDictionary(podofoDoc, podofoObj)) return false;

669

670

671 *out = new SkPdfLabColorSpaceDictionary(&podofoDoc, &podofoObj);

672 return true;

673 }

674

675 bool mapIccProfileStreamDictionary(const SkPdfObject& in, SkPdfIccProfileStreamD ictionary** out) {

676 return mapIccProfileStreamDictionary(in.doc(), in.podofo(), out);

677 }

678

679 bool mapIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfIccProfileStreamDictionary** out) {

680 if (!isIccProfileStreamDictionary(podofoDoc, podofoObj)) return false;

681

682

683 *out = new SkPdfIccProfileStreamDictionary(&podofoDoc, &podofoObj);

684 return true;

685 }

686

687 bool mapDeviceNColorSpaceDictionary(const SkPdfObject& in, SkPdfDeviceNColorSpac eDictionary** out) {

688 return mapDeviceNColorSpaceDictionary(in.doc(), in.podofo(), out);

689 }

690

691 bool mapDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfDeviceNColorSpaceDictionary** out) {

692 if (!isDeviceNColorSpaceDictionary(podofoDoc, podofoObj)) return false;

693

694

695 *out = new SkPdfDeviceNColorSpaceDictionary(&podofoDoc, &podofoObj);

696 return true;

697 }

698

699 bool mapType1PatternDictionary(const SkPdfObject& in, SkPdfType1PatternDictionar y** out) {

700 return mapType1PatternDictionary(in.doc(), in.podofo(), out);

701 }

702

703 bool mapType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1PatternDictionary** out) {

704 if (!isType1PatternDictionary(podofoDoc, podofoObj)) return false;

705

706

707 *out = new SkPdfType1PatternDictionary(&podofoDoc, &podofoObj);

708 return true;

709 }

710

711 bool mapType2PatternDictionary(const SkPdfObject& in, SkPdfType2PatternDictionar y** out) {

712 return mapType2PatternDictionary(in.doc(), in.podofo(), out);

713 }

714

715 bool mapType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2PatternDictionary** out) {

716 if (!isType2PatternDictionary(podofoDoc, podofoObj)) return false;

717

718

719 *out = new SkPdfType2PatternDictionary(&podofoDoc, &podofoObj);

720 return true;

721 }

722

723 bool mapShadingDictionary(const SkPdfObject& in, SkPdfShadingDictionary** out) {

724 return mapShadingDictionary(in.doc(), in.podofo(), out);

725 }

726

727 bool mapShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj, SkPdfShadingDictionary** out) {

728 if (!isShadingDictionary(podofoDoc, podofoObj)) return false;

729

730 if (mapType1ShadingDictionary(podofoDoc, podofoObj, (SkPdfType1ShadingDictiona ry**)out)) return true;

731 if (mapType2ShadingDictionary(podofoDoc, podofoObj, (SkPdfType2ShadingDictiona ry**)out)) return true;

732 if (mapType3ShadingDictionary(podofoDoc, podofoObj, (SkPdfType3ShadingDictiona ry**)out)) return true;

733 if (mapType4ShadingDictionary(podofoDoc, podofoObj, (SkPdfType4ShadingDictiona ry**)out)) return true;

734 if (mapType5ShadingDictionary(podofoDoc, podofoObj, (SkPdfType5ShadingDictiona ry**)out)) return true;

735 if (mapType6ShadingDictionary(podofoDoc, podofoObj, (SkPdfType6ShadingDictiona ry**)out)) return true;

736

737 *out = new SkPdfShadingDictionary(&podofoDoc, &podofoObj);

738 return true;

739 }

740

741 bool mapType1ShadingDictionary(const SkPdfObject& in, SkPdfType1ShadingDictionar y** out) {

742 return mapType1ShadingDictionary(in.doc(), in.podofo(), out);

743 }

744

745 bool mapType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1ShadingDictionary** out) {

746 if (!isType1ShadingDictionary(podofoDoc, podofoObj)) return false;

747

748

749 *out = new SkPdfType1ShadingDictionary(&podofoDoc, &podofoObj);

750 return true;

751 }

752

753 bool mapType2ShadingDictionary(const SkPdfObject& in, SkPdfType2ShadingDictionar y** out) {

754 return mapType2ShadingDictionary(in.doc(), in.podofo(), out);

755 }

756

757 bool mapType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2ShadingDictionary** out) {

758 if (!isType2ShadingDictionary(podofoDoc, podofoObj)) return false;

759

760

761 *out = new SkPdfType2ShadingDictionary(&podofoDoc, &podofoObj);

762 return true;

763 }

764

765 bool mapType3ShadingDictionary(const SkPdfObject& in, SkPdfType3ShadingDictionar y** out) {

766 return mapType3ShadingDictionary(in.doc(), in.podofo(), out);

767 }

768

769 bool mapType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3ShadingDictionary** out) {

770 if (!isType3ShadingDictionary(podofoDoc, podofoObj)) return false;

771

772

773 *out = new SkPdfType3ShadingDictionary(&podofoDoc, &podofoObj);

774 return true;

775 }

776

777 bool mapType4ShadingDictionary(const SkPdfObject& in, SkPdfType4ShadingDictionar y** out) {

778 return mapType4ShadingDictionary(in.doc(), in.podofo(), out);

779 }

780

781 bool mapType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType4ShadingDictionary** out) {

782 if (!isType4ShadingDictionary(podofoDoc, podofoObj)) return false;

783

784

785 *out = new SkPdfType4ShadingDictionary(&podofoDoc, &podofoObj);

786 return true;

787 }

788

789 bool mapType5ShadingDictionary(const SkPdfObject& in, SkPdfType5ShadingDictionar y** out) {

790 return mapType5ShadingDictionary(in.doc(), in.podofo(), out);

791 }

792

793 bool mapType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5ShadingDictionary** out) {

794 if (!isType5ShadingDictionary(podofoDoc, podofoObj)) return false;

795

796

797 *out = new SkPdfType5ShadingDictionary(&podofoDoc, &podofoObj);

798 return true;

799 }

800

801 bool mapType6ShadingDictionary(const SkPdfObject& in, SkPdfType6ShadingDictionar y** out) {

802 return mapType6ShadingDictionary(in.doc(), in.podofo(), out);

803 }

804

805 bool mapType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6ShadingDictionary** out) {

806 if (!isType6ShadingDictionary(podofoDoc, podofoObj)) return false;

807

808

809 *out = new SkPdfType6ShadingDictionary(&podofoDoc, &podofoObj);

810 return true;

811 }

812

813 bool mapImageDictionary(const SkPdfObject& in, SkPdfImageDictionary** out) {

814 return mapImageDictionary(in.doc(), in.podofo(), out);

815 }

816

817 bool mapImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofo Obj, SkPdfImageDictionary** out) {

818 if (!isImageDictionary(podofoDoc, podofoObj)) return false;

819

820

821 *out = new SkPdfImageDictionary(&podofoDoc, &podofoObj);

822 return true;

823 }

824

825 bool mapAlternateImageDictionary(const SkPdfObject& in, SkPdfAlternateImageDicti onary** out) {

826 return mapAlternateImageDictionary(in.doc(), in.podofo(), out);

827 }

828

829 bool mapAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfAlternateImageDictionary** out) {

830 if (!isAlternateImageDictionary(podofoDoc, podofoObj)) return false;

831

832

833 *out = new SkPdfAlternateImageDictionary(&podofoDoc, &podofoObj);

834 return true;

835 }

836

837 bool mapType1FormDictionary(const SkPdfObject& in, SkPdfType1FormDictionary** ou t) {

838 return mapType1FormDictionary(in.doc(), in.podofo(), out);

839 }

840

841 bool mapType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfType1FormDictionary** out) {

842 if (!isType1FormDictionary(podofoDoc, podofoObj)) return false;

843

844

845 *out = new SkPdfType1FormDictionary(&podofoDoc, &podofoObj);

846 return true;

847 }

848

849 bool mapGroupAttributesDictionary(const SkPdfObject& in, SkPdfGroupAttributesDic tionary** out) {

850 return mapGroupAttributesDictionary(in.doc(), in.podofo(), out);

851 }

852

853 bool mapGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfGroupAttributesDictionary** out) {

854 if (!isGroupAttributesDictionary(podofoDoc, podofoObj)) return false;

855

856

857 *out = new SkPdfGroupAttributesDictionary(&podofoDoc, &podofoObj);

858 return true;

859 }

860

861 bool mapReferenceDictionary(const SkPdfObject& in, SkPdfReferenceDictionary** ou t) {

862 return mapReferenceDictionary(in.doc(), in.podofo(), out);

863 }

864

865 bool mapReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfReferenceDictionary** out) {

866 if (!isReferenceDictionary(podofoDoc, podofoObj)) return false;

867

868

869 *out = new SkPdfReferenceDictionary(&podofoDoc, &podofoObj);

870 return true;

871 }

872

873 bool mapPSXobjectDictionary(const SkPdfObject& in, SkPdfPSXobjectDictionary** ou t) {

874 return mapPSXobjectDictionary(in.doc(), in.podofo(), out);

875 }

876

877 bool mapPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfPSXobjectDictionary** out) {

878 if (!isPSXobjectDictionary(podofoDoc, podofoObj)) return false;

879

880

881 *out = new SkPdfPSXobjectDictionary(&podofoDoc, &podofoObj);

882 return true;

883 }

884

885 bool mapType1FontDictionary(const SkPdfObject& in, SkPdfType1FontDictionary** ou t) {

886 return mapType1FontDictionary(in.doc(), in.podofo(), out);

887 }

888

889 bool mapType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfType1FontDictionary** out) {

890 if (!isType1FontDictionary(podofoDoc, podofoObj)) return false;

891

892 if (mapMultiMasterFontDictionary(podofoDoc, podofoObj, (SkPdfMultiMasterFontDi ctionary**)out)) return true;

893 if (mapTrueTypeFontDictionary(podofoDoc, podofoObj, (SkPdfTrueTypeFontDictiona ry**)out)) return true;

894 if (mapType3FontDictionary(podofoDoc, podofoObj, (SkPdfType3FontDictionary**)o ut)) return true;

895

896 *out = new SkPdfType1FontDictionary(&podofoDoc, &podofoObj);

897 return true;

898 }

899

900 bool mapType3FontDictionary(const SkPdfObject& in, SkPdfType3FontDictionary** ou t) {

901 return mapType3FontDictionary(in.doc(), in.podofo(), out);

902 }

903

904 bool mapType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfType3FontDictionary** out) {

905 if (!isType3FontDictionary(podofoDoc, podofoObj)) return false;

906

907

908 *out = new SkPdfType3FontDictionary(&podofoDoc, &podofoObj);

909 return true;

910 }

911

912 bool mapEncodingDictionary(const SkPdfObject& in, SkPdfEncodingDictionary** out) {

913 return mapEncodingDictionary(in.doc(), in.podofo(), out);

914 }

915

916 bool mapEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj, SkPdfEncodingDictionary** out) {

917 if (!isEncodingDictionary(podofoDoc, podofoObj)) return false;

918

919

920 *out = new SkPdfEncodingDictionary(&podofoDoc, &podofoObj);

921 return true;

922 }

923

924 bool mapCIDSystemInfoDictionary(const SkPdfObject& in, SkPdfCIDSystemInfoDiction ary** out) {

925 return mapCIDSystemInfoDictionary(in.doc(), in.podofo(), out);

926 }

927

928 bool mapCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfCIDSystemInfoDictionary** out) {

929 if (!isCIDSystemInfoDictionary(podofoDoc, podofoObj)) return false;

930

931

932 *out = new SkPdfCIDSystemInfoDictionary(&podofoDoc, &podofoObj);

933 return true;

934 }

935

936 bool mapCIDFontDictionary(const SkPdfObject& in, SkPdfCIDFontDictionary** out) {

937 return mapCIDFontDictionary(in.doc(), in.podofo(), out);

938 }

939

940 bool mapCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj, SkPdfCIDFontDictionary** out) {

941 if (!isCIDFontDictionary(podofoDoc, podofoObj)) return false;

942

943

944 *out = new SkPdfCIDFontDictionary(&podofoDoc, &podofoObj);

945 return true;

946 }

947

948 bool mapCMapDictionary(const SkPdfObject& in, SkPdfCMapDictionary** out) {

949 return mapCMapDictionary(in.doc(), in.podofo(), out);

950 }

951

952 bool mapCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoO bj, SkPdfCMapDictionary** out) {

953 if (!isCMapDictionary(podofoDoc, podofoObj)) return false;

954

955

956 *out = new SkPdfCMapDictionary(&podofoDoc, &podofoObj);

957 return true;

958 }

959

960 bool mapType0FontDictionary(const SkPdfObject& in, SkPdfType0FontDictionary** ou t) {

961 return mapType0FontDictionary(in.doc(), in.podofo(), out);

962 }

963

964 bool mapType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfType0FontDictionary** out) {

965 if (!isType0FontDictionary(podofoDoc, podofoObj)) return false;

966

967

968 *out = new SkPdfType0FontDictionary(&podofoDoc, &podofoObj);

969 return true;

970 }

971

972 bool mapFontDescriptorDictionary(const SkPdfObject& in, SkPdfFontDescriptorDicti onary** out) {

973 return mapFontDescriptorDictionary(in.doc(), in.podofo(), out);

974 }

975

976 bool mapFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfFontDescriptorDictionary** out) {

977 if (!isFontDescriptorDictionary(podofoDoc, podofoObj)) return false;

978

979

980 *out = new SkPdfFontDescriptorDictionary(&podofoDoc, &podofoObj);

981 return true;

982 }

983

984 bool mapCIDFontDescriptorDictionary(const SkPdfObject& in, SkPdfCIDFontDescripto rDictionary** out) {

985 return mapCIDFontDescriptorDictionary(in.doc(), in.podofo(), out);

986 }

987

988 bool mapCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfCIDFontDescriptorDictionary** out) {

989 if (!isCIDFontDescriptorDictionary(podofoDoc, podofoObj)) return false;

990

991

992 *out = new SkPdfCIDFontDescriptorDictionary(&podofoDoc, &podofoObj);

993 return true;

994 }

995

996 bool mapEmbeddedFontStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFontStr eamDictionary** out) {

997 return mapEmbeddedFontStreamDictionary(in.doc(), in.podofo(), out);

998 }

999

1000 bool mapEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfO bject& podofoObj, SkPdfEmbeddedFontStreamDictionary** out) {

1001 if (!isEmbeddedFontStreamDictionary(podofoDoc, podofoObj)) return false;

1002

1003

1004 *out = new SkPdfEmbeddedFontStreamDictionary(&podofoDoc, &podofoObj);

1005 return true;

1006 }

1007

1008 bool mapType1HalftoneDictionary(const SkPdfObject& in, SkPdfType1HalftoneDiction ary** out) {

1009 return mapType1HalftoneDictionary(in.doc(), in.podofo(), out);

1010 }

1011

1012 bool mapType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfType1HalftoneDictionary** out) {

1013 if (!isType1HalftoneDictionary(podofoDoc, podofoObj)) return false;

1014

1015

1016 *out = new SkPdfType1HalftoneDictionary(&podofoDoc, &podofoObj);

1017 return true;

1018 }

1019

1020 bool mapType6HalftoneDictionary(const SkPdfObject& in, SkPdfType6HalftoneDiction ary** out) {

1021 return mapType6HalftoneDictionary(in.doc(), in.podofo(), out);

1022 }

1023

1024 bool mapType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfType6HalftoneDictionary** out) {

1025 if (!isType6HalftoneDictionary(podofoDoc, podofoObj)) return false;

1026

1027

1028 *out = new SkPdfType6HalftoneDictionary(&podofoDoc, &podofoObj);

1029 return true;

1030 }

1031

1032 bool mapType10HalftoneDictionary(const SkPdfObject& in, SkPdfType10HalftoneDicti onary** out) {

1033 return mapType10HalftoneDictionary(in.doc(), in.podofo(), out);

1034 }

1035

1036 bool mapType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfType10HalftoneDictionary** out) {

1037 if (!isType10HalftoneDictionary(podofoDoc, podofoObj)) return false;

1038

1039

1040 *out = new SkPdfType10HalftoneDictionary(&podofoDoc, &podofoObj);

1041 return true;

1042 }

1043

1044 bool mapType16HalftoneDictionary(const SkPdfObject& in, SkPdfType16HalftoneDicti onary** out) {

1045 return mapType16HalftoneDictionary(in.doc(), in.podofo(), out);

1046 }

1047

1048 bool mapType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfType16HalftoneDictionary** out) {

1049 if (!isType16HalftoneDictionary(podofoDoc, podofoObj)) return false;

1050

1051

1052 *out = new SkPdfType16HalftoneDictionary(&podofoDoc, &podofoObj);

1053 return true;

1054 }

1055

1056 bool mapType5HalftoneDictionary(const SkPdfObject& in, SkPdfType5HalftoneDiction ary** out) {

1057 return mapType5HalftoneDictionary(in.doc(), in.podofo(), out);

1058 }

1059

1060 bool mapType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfType5HalftoneDictionary** out) {

1061 if (!isType5HalftoneDictionary(podofoDoc, podofoObj)) return false;

1062

1063

1064 *out = new SkPdfType5HalftoneDictionary(&podofoDoc, &podofoObj);

1065 return true;

1066 }

1067

1068 bool mapSoftMaskDictionary(const SkPdfObject& in, SkPdfSoftMaskDictionary** out) {

1069 return mapSoftMaskDictionary(in.doc(), in.podofo(), out);

1070 }

1071

1072 bool mapSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj, SkPdfSoftMaskDictionary** out) {

1073 if (!isSoftMaskDictionary(podofoDoc, podofoObj)) return false;

1074

1075

1076 *out = new SkPdfSoftMaskDictionary(&podofoDoc, &podofoObj);

1077 return true;

1078 }

1079

1080 bool mapSoftMaskImageDictionary(const SkPdfObject& in, SkPdfSoftMaskImageDiction ary** out) {

1081 return mapSoftMaskImageDictionary(in.doc(), in.podofo(), out);

1082 }

1083

1084 bool mapSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfSoftMaskImageDictionary** out) {

1085 if (!isSoftMaskImageDictionary(podofoDoc, podofoObj)) return false;

1086

1087

1088 *out = new SkPdfSoftMaskImageDictionary(&podofoDoc, &podofoObj);

1089 return true;

1090 }

1091

1092 bool mapTransparencyGroupDictionary(const SkPdfObject& in, SkPdfTransparencyGrou pDictionary** out) {

1093 return mapTransparencyGroupDictionary(in.doc(), in.podofo(), out);

1094 }

1095

1096 bool mapTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfTransparencyGroupDictionary** out) {

1097 if (!isTransparencyGroupDictionary(podofoDoc, podofoObj)) return false;

1098

1099

1100 *out = new SkPdfTransparencyGroupDictionary(&podofoDoc, &podofoObj);

1101 return true;

1102 }

1103

1104 bool mapViewerPreferencesDictionary(const SkPdfObject& in, SkPdfViewerPreference sDictionary** out) {

1105 return mapViewerPreferencesDictionary(in.doc(), in.podofo(), out);

1106 }

1107

1108 bool mapViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfViewerPreferencesDictionary** out) {

1109 if (!isViewerPreferencesDictionary(podofoDoc, podofoObj)) return false;

1110

1111

1112 *out = new SkPdfViewerPreferencesDictionary(&podofoDoc, &podofoObj);

1113 return true;

1114 }

1115

1116 bool mapOutlineDictionary(const SkPdfObject& in, SkPdfOutlineDictionary** out) {

1117 return mapOutlineDictionary(in.doc(), in.podofo(), out);

1118 }

1119

1120 bool mapOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj, SkPdfOutlineDictionary** out) {

1121 if (!isOutlineDictionary(podofoDoc, podofoObj)) return false;

1122

1123

1124 *out = new SkPdfOutlineDictionary(&podofoDoc, &podofoObj);

1125 return true;

1126 }

1127

1128 bool mapOutlineItemDictionary(const SkPdfObject& in, SkPdfOutlineItemDictionary* * out) {

1129 return mapOutlineItemDictionary(in.doc(), in.podofo(), out);

1130 }

1131

1132 bool mapOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineItemDictionary** out) {

1133 if (!isOutlineItemDictionary(podofoDoc, podofoObj)) return false;

1134

1135

1136 *out = new SkPdfOutlineItemDictionary(&podofoDoc, &podofoObj);

1137 return true;

1138 }

1139

1140 bool mapPageLabelDictionary(const SkPdfObject& in, SkPdfPageLabelDictionary** ou t) {

1141 return mapPageLabelDictionary(in.doc(), in.podofo(), out);

1142 }

1143

1144 bool mapPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfPageLabelDictionary** out) {

1145 if (!isPageLabelDictionary(podofoDoc, podofoObj)) return false;

1146

1147

1148 *out = new SkPdfPageLabelDictionary(&podofoDoc, &podofoObj);

1149 return true;

1150 }

1151

1152 bool mapThreadDictionary(const SkPdfObject& in, SkPdfThreadDictionary** out) {

1153 return mapThreadDictionary(in.doc(), in.podofo(), out);

1154 }

1155

1156 bool mapThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podof oObj, SkPdfThreadDictionary** out) {

1157 if (!isThreadDictionary(podofoDoc, podofoObj)) return false;

1158

1159

1160 *out = new SkPdfThreadDictionary(&podofoDoc, &podofoObj);

1161 return true;

1162 }

1163

1164 bool mapBeadDictionary(const SkPdfObject& in, SkPdfBeadDictionary** out) {

1165 return mapBeadDictionary(in.doc(), in.podofo(), out);

1166 }

1167

1168 bool mapBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoO bj, SkPdfBeadDictionary** out) {

1169 if (!isBeadDictionary(podofoDoc, podofoObj)) return false;

1170

1171

1172 *out = new SkPdfBeadDictionary(&podofoDoc, &podofoObj);

1173 return true;

1174 }

1175

1176 bool mapTransitionDictionary(const SkPdfObject& in, SkPdfTransitionDictionary** out) {

1177 return mapTransitionDictionary(in.doc(), in.podofo(), out);

1178 }

1179

1180 bool mapTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfTransitionDictionary** out) {

1181 if (!isTransitionDictionary(podofoDoc, podofoObj)) return false;

1182

1183

1184 *out = new SkPdfTransitionDictionary(&podofoDoc, &podofoObj);

1185 return true;

1186 }

1187

1188 bool mapAnnotationDictionary(const SkPdfObject& in, SkPdfAnnotationDictionary** out) {

1189 return mapAnnotationDictionary(in.doc(), in.podofo(), out);

1190 }

1191

1192 bool mapAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfAnnotationDictionary** out) {

1193 if (!isAnnotationDictionary(podofoDoc, podofoObj)) return false;

1194

1195

1196 *out = new SkPdfAnnotationDictionary(&podofoDoc, &podofoObj);

1197 return true;

1198 }

1199

1200 bool mapBorderStyleDictionary(const SkPdfObject& in, SkPdfBorderStyleDictionary* * out) {

1201 return mapBorderStyleDictionary(in.doc(), in.podofo(), out);

1202 }

1203

1204 bool mapBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBorderStyleDictionary** out) {

1205 if (!isBorderStyleDictionary(podofoDoc, podofoObj)) return false;

1206

1207

1208 *out = new SkPdfBorderStyleDictionary(&podofoDoc, &podofoObj);

1209 return true;

1210 }

1211

1212 bool mapAppearanceDictionary(const SkPdfObject& in, SkPdfAppearanceDictionary** out) {

1213 return mapAppearanceDictionary(in.doc(), in.podofo(), out);

1214 }

1215

1216 bool mapAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfAppearanceDictionary** out) {

1217 if (!isAppearanceDictionary(podofoDoc, podofoObj)) return false;

1218

1219

1220 *out = new SkPdfAppearanceDictionary(&podofoDoc, &podofoObj);

1221 return true;

1222 }

1223

1224 bool mapTextAnnotationDictionary(const SkPdfObject& in, SkPdfTextAnnotationDicti onary** out) {

1225 return mapTextAnnotationDictionary(in.doc(), in.podofo(), out);

1226 }

1227

1228 bool mapTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfTextAnnotationDictionary** out) {

1229 if (!isTextAnnotationDictionary(podofoDoc, podofoObj)) return false;

1230

1231

1232 *out = new SkPdfTextAnnotationDictionary(&podofoDoc, &podofoObj);

1233 return true;

1234 }

1235

1236 bool mapALinkAnnotationDictionary(const SkPdfObject& in, SkPdfALinkAnnotationDic tionary** out) {

1237 return mapALinkAnnotationDictionary(in.doc(), in.podofo(), out);

1238 }

1239

1240 bool mapALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfALinkAnnotationDictionary** out) {

1241 if (!isALinkAnnotationDictionary(podofoDoc, podofoObj)) return false;

1242

1243

1244 *out = new SkPdfALinkAnnotationDictionary(&podofoDoc, &podofoObj);

1245 return true;

1246 }

1247

1248 bool mapFreeTextAnnotationDictionary(const SkPdfObject& in, SkPdfFreeTextAnnotat ionDictionary** out) {

1249 return mapFreeTextAnnotationDictionary(in.doc(), in.podofo(), out);

1250 }

1251

1252 bool mapFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfO bject& podofoObj, SkPdfFreeTextAnnotationDictionary** out) {

1253 if (!isFreeTextAnnotationDictionary(podofoDoc, podofoObj)) return false;

1254

1255

1256 *out = new SkPdfFreeTextAnnotationDictionary(&podofoDoc, &podofoObj);

1257 return true;

1258 }

1259

1260 bool mapLineAnnotationDictionary(const SkPdfObject& in, SkPdfLineAnnotationDicti onary** out) {

1261 return mapLineAnnotationDictionary(in.doc(), in.podofo(), out);

1262 }

1263

1264 bool mapLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfLineAnnotationDictionary** out) {

1265 if (!isLineAnnotationDictionary(podofoDoc, podofoObj)) return false;

1266

1267

1268 *out = new SkPdfLineAnnotationDictionary(&podofoDoc, &podofoObj);

1269 return true;

1270 }

1271

1272 bool mapSquareOrCircleAnnotation(const SkPdfObject& in, SkPdfSquareOrCircleAnnot ation** out) {

1273 return mapSquareOrCircleAnnotation(in.doc(), in.podofo(), out);

1274 }

1275

1276 bool mapSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfSquareOrCircleAnnotation** out) {

1277 if (!isSquareOrCircleAnnotation(podofoDoc, podofoObj)) return false;

1278

1279

1280 *out = new SkPdfSquareOrCircleAnnotation(&podofoDoc, &podofoObj);

1281 return true;

1282 }

1283

1284 bool mapMarkupAnnotationsDictionary(const SkPdfObject& in, SkPdfMarkupAnnotation sDictionary** out) {

1285 return mapMarkupAnnotationsDictionary(in.doc(), in.podofo(), out);

1286 }

1287

1288 bool mapMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfMarkupAnnotationsDictionary** out) {

1289 if (!isMarkupAnnotationsDictionary(podofoDoc, podofoObj)) return false;

1290

1291

1292 *out = new SkPdfMarkupAnnotationsDictionary(&podofoDoc, &podofoObj);

1293 return true;

1294 }

1295

1296 bool mapRubberStampAnnotationDictionary(const SkPdfObject& in, SkPdfRubberStampA nnotationDictionary** out) {

1297 return mapRubberStampAnnotationDictionary(in.doc(), in.podofo(), out);

1298 }

1299

1300 bool mapRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj, SkPdfRubberStampAnnotationDictionary** out) {

1301 if (!isRubberStampAnnotationDictionary(podofoDoc, podofoObj)) return false;

1302

1303

1304 *out = new SkPdfRubberStampAnnotationDictionary(&podofoDoc, &podofoObj);

1305 return true;

1306 }

1307

1308 bool mapInkAnnotationDictionary(const SkPdfObject& in, SkPdfInkAnnotationDiction ary** out) {

1309 return mapInkAnnotationDictionary(in.doc(), in.podofo(), out);

1310 }

1311

1312 bool mapInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfInkAnnotationDictionary** out) {

1313 if (!isInkAnnotationDictionary(podofoDoc, podofoObj)) return false;

1314

1315

1316 *out = new SkPdfInkAnnotationDictionary(&podofoDoc, &podofoObj);

1317 return true;

1318 }

1319

1320 bool mapPopUpAnnotationDictionary(const SkPdfObject& in, SkPdfPopUpAnnotationDic tionary** out) {

1321 return mapPopUpAnnotationDictionary(in.doc(), in.podofo(), out);

1322 }

1323

1324 bool mapPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfPopUpAnnotationDictionary** out) {

1325 if (!isPopUpAnnotationDictionary(podofoDoc, podofoObj)) return false;

1326

1327

1328 *out = new SkPdfPopUpAnnotationDictionary(&podofoDoc, &podofoObj);

1329 return true;

1330 }

1331

1332 bool mapFileAttachmentAnnotationDictionary(const SkPdfObject& in, SkPdfFileAttac hmentAnnotationDictionary** out) {

1333 return mapFileAttachmentAnnotationDictionary(in.doc(), in.podofo(), out);

1334 }

1335

1336 bool mapFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, cons t PdfObject& podofoObj, SkPdfFileAttachmentAnnotationDictionary** out) {

1337 if (!isFileAttachmentAnnotationDictionary(podofoDoc, podofoObj)) return false;

1338

1339

1340 *out = new SkPdfFileAttachmentAnnotationDictionary(&podofoDoc, &podofoObj);

1341 return true;

1342 }

1343

1344 bool mapSoundAnnotationDictionary(const SkPdfObject& in, SkPdfSoundAnnotationDic tionary** out) {

1345 return mapSoundAnnotationDictionary(in.doc(), in.podofo(), out);

1346 }

1347

1348 bool mapSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfSoundAnnotationDictionary** out) {

1349 if (!isSoundAnnotationDictionary(podofoDoc, podofoObj)) return false;

1350

1351

1352 *out = new SkPdfSoundAnnotationDictionary(&podofoDoc, &podofoObj);

1353 return true;

1354 }

1355

1356 bool mapMovieAnnotationDictionary(const SkPdfObject& in, SkPdfMovieAnnotationDic tionary** out) {

1357 return mapMovieAnnotationDictionary(in.doc(), in.podofo(), out);

1358 }

1359

1360 bool mapMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfMovieAnnotationDictionary** out) {

1361 if (!isMovieAnnotationDictionary(podofoDoc, podofoObj)) return false;

1362

1363

1364 *out = new SkPdfMovieAnnotationDictionary(&podofoDoc, &podofoObj);

1365 return true;

1366 }

1367

1368 bool mapWidgetAnnotationDictionary(const SkPdfObject& in, SkPdfWidgetAnnotationD ictionary** out) {

1369 return mapWidgetAnnotationDictionary(in.doc(), in.podofo(), out);

1370 }

1371

1372 bool mapWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfWidgetAnnotationDictionary** out) {

1373 if (!isWidgetAnnotationDictionary(podofoDoc, podofoObj)) return false;

1374

1375

1376 *out = new SkPdfWidgetAnnotationDictionary(&podofoDoc, &podofoObj);

1377 return true;

1378 }

1379

1380 bool mapActionDictionary(const SkPdfObject& in, SkPdfActionDictionary** out) {

1381 return mapActionDictionary(in.doc(), in.podofo(), out);

1382 }

1383

1384 bool mapActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podof oObj, SkPdfActionDictionary** out) {

1385 if (!isActionDictionary(podofoDoc, podofoObj)) return false;

1386

1387

1388 *out = new SkPdfActionDictionary(&podofoDoc, &podofoObj);

1389 return true;

1390 }

1391

1392 bool mapAnnotationActionsDictionary(const SkPdfObject& in, SkPdfAnnotationAction sDictionary** out) {

1393 return mapAnnotationActionsDictionary(in.doc(), in.podofo(), out);

1394 }

1395

1396 bool mapAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfAnnotationActionsDictionary** out) {

1397 if (!isAnnotationActionsDictionary(podofoDoc, podofoObj)) return false;

1398

1399

1400 *out = new SkPdfAnnotationActionsDictionary(&podofoDoc, &podofoObj);

1401 return true;

1402 }

1403

1404 bool mapPageObjectActionsDictionary(const SkPdfObject& in, SkPdfPageObjectAction sDictionary** out) {

1405 return mapPageObjectActionsDictionary(in.doc(), in.podofo(), out);

1406 }

1407

1408 bool mapPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfPageObjectActionsDictionary** out) {

1409 if (!isPageObjectActionsDictionary(podofoDoc, podofoObj)) return false;

1410

1411

1412 *out = new SkPdfPageObjectActionsDictionary(&podofoDoc, &podofoObj);

1413 return true;

1414 }

1415

1416 bool mapFormFieldActionsDictionary(const SkPdfObject& in, SkPdfFormFieldActionsD ictionary** out) {

1417 return mapFormFieldActionsDictionary(in.doc(), in.podofo(), out);

1418 }

1419

1420 bool mapFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfFormFieldActionsDictionary** out) {

1421 if (!isFormFieldActionsDictionary(podofoDoc, podofoObj)) return false;

1422

1423

1424 *out = new SkPdfFormFieldActionsDictionary(&podofoDoc, &podofoObj);

1425 return true;

1426 }

1427

1428 bool mapDocumentCatalogActionsDictionary(const SkPdfObject& in, SkPdfDocumentCat alogActionsDictionary** out) {

1429 return mapDocumentCatalogActionsDictionary(in.doc(), in.podofo(), out);

1430 }

1431

1432 bool mapDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentCatalogActionsDictionary** out) {

1433 if (!isDocumentCatalogActionsDictionary(podofoDoc, podofoObj)) return false;

1434

1435

1436 *out = new SkPdfDocumentCatalogActionsDictionary(&podofoDoc, &podofoObj);

1437 return true;

1438 }

1439

1440 bool mapGoToActionDictionary(const SkPdfObject& in, SkPdfGoToActionDictionary** out) {

1441 return mapGoToActionDictionary(in.doc(), in.podofo(), out);

1442 }

1443

1444 bool mapGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfGoToActionDictionary** out) {

1445 if (!isGoToActionDictionary(podofoDoc, podofoObj)) return false;

1446

1447

1448 *out = new SkPdfGoToActionDictionary(&podofoDoc, &podofoObj);

1449 return true;

1450 }

1451

1452 bool mapRemoteGoToActionDictionary(const SkPdfObject& in, SkPdfRemoteGoToActionD ictionary** out) {

1453 return mapRemoteGoToActionDictionary(in.doc(), in.podofo(), out);

1454 }

1455

1456 bool mapRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfRemoteGoToActionDictionary** out) {

1457 if (!isRemoteGoToActionDictionary(podofoDoc, podofoObj)) return false;

1458

1459

1460 *out = new SkPdfRemoteGoToActionDictionary(&podofoDoc, &podofoObj);

1461 return true;

1462 }

1463

1464 bool mapLaunchActionDictionary(const SkPdfObject& in, SkPdfLaunchActionDictionar y** out) {

1465 return mapLaunchActionDictionary(in.doc(), in.podofo(), out);

1466 }

1467

1468 bool mapLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLaunchActionDictionary** out) {

1469 if (!isLaunchActionDictionary(podofoDoc, podofoObj)) return false;

1470

1471

1472 *out = new SkPdfLaunchActionDictionary(&podofoDoc, &podofoObj);

1473 return true;

1474 }

1475

1476 bool mapWindowsLaunchActionDictionary(const SkPdfObject& in, SkPdfWindowsLaunchA ctionDictionary** out) {

1477 return mapWindowsLaunchActionDictionary(in.doc(), in.podofo(), out);

1478 }

1479

1480 bool mapWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const Pdf Object& podofoObj, SkPdfWindowsLaunchActionDictionary** out) {

1481 if (!isWindowsLaunchActionDictionary(podofoDoc, podofoObj)) return false;

1482

1483

1484 *out = new SkPdfWindowsLaunchActionDictionary(&podofoDoc, &podofoObj);

1485 return true;

1486 }

1487

1488 bool mapThreadActionDictionary(const SkPdfObject& in, SkPdfThreadActionDictionar y** out) {

1489 return mapThreadActionDictionary(in.doc(), in.podofo(), out);

1490 }

1491

1492 bool mapThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadActionDictionary** out) {

1493 if (!isThreadActionDictionary(podofoDoc, podofoObj)) return false;

1494

1495

1496 *out = new SkPdfThreadActionDictionary(&podofoDoc, &podofoObj);

1497 return true;

1498 }

1499

1500 bool mapURIActionDictionary(const SkPdfObject& in, SkPdfURIActionDictionary** ou t) {

1501 return mapURIActionDictionary(in.doc(), in.podofo(), out);

1502 }

1503

1504 bool mapURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfURIActionDictionary** out) {

1505 if (!isURIActionDictionary(podofoDoc, podofoObj)) return false;

1506

1507

1508 *out = new SkPdfURIActionDictionary(&podofoDoc, &podofoObj);

1509 return true;

1510 }

1511

1512 bool mapURIDictionary(const SkPdfObject& in, SkPdfURIDictionary** out) {

1513 return mapURIDictionary(in.doc(), in.podofo(), out);

1514 }

1515

1516 bool mapURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoOb j, SkPdfURIDictionary** out) {

1517 if (!isURIDictionary(podofoDoc, podofoObj)) return false;

1518

1519

1520 *out = new SkPdfURIDictionary(&podofoDoc, &podofoObj);

1521 return true;

1522 }

1523

1524 bool mapSoundActionDictionary(const SkPdfObject& in, SkPdfSoundActionDictionary* * out) {

1525 return mapSoundActionDictionary(in.doc(), in.podofo(), out);

1526 }

1527

1528 bool mapSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundActionDictionary** out) {

1529 if (!isSoundActionDictionary(podofoDoc, podofoObj)) return false;

1530

1531

1532 *out = new SkPdfSoundActionDictionary(&podofoDoc, &podofoObj);

1533 return true;

1534 }

1535

1536 bool mapMovieActionDictionary(const SkPdfObject& in, SkPdfMovieActionDictionary* * out) {

1537 return mapMovieActionDictionary(in.doc(), in.podofo(), out);

1538 }

1539

1540 bool mapMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActionDictionary** out) {

1541 if (!isMovieActionDictionary(podofoDoc, podofoObj)) return false;

1542

1543

1544 *out = new SkPdfMovieActionDictionary(&podofoDoc, &podofoObj);

1545 return true;

1546 }

1547

1548 bool mapHideActionDictionary(const SkPdfObject& in, SkPdfHideActionDictionary** out) {

1549 return mapHideActionDictionary(in.doc(), in.podofo(), out);

1550 }

1551

1552 bool mapHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfHideActionDictionary** out) {

1553 if (!isHideActionDictionary(podofoDoc, podofoObj)) return false;

1554

1555

1556 *out = new SkPdfHideActionDictionary(&podofoDoc, &podofoObj);

1557 return true;

1558 }

1559

1560 bool mapNamedActionsDictionary(const SkPdfObject& in, SkPdfNamedActionsDictionar y** out) {

1561 return mapNamedActionsDictionary(in.doc(), in.podofo(), out);

1562 }

1563

1564 bool mapNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNamedActionsDictionary** out) {

1565 if (!isNamedActionsDictionary(podofoDoc, podofoObj)) return false;

1566

1567

1568 *out = new SkPdfNamedActionsDictionary(&podofoDoc, &podofoObj);

1569 return true;

1570 }

1571

1572 bool mapInteractiveFormDictionary(const SkPdfObject& in, SkPdfInteractiveFormDic tionary** out) {

1573 return mapInteractiveFormDictionary(in.doc(), in.podofo(), out);

1574 }

1575

1576 bool mapInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfInteractiveFormDictionary** out) {

1577 if (!isInteractiveFormDictionary(podofoDoc, podofoObj)) return false;

1578

1579

1580 *out = new SkPdfInteractiveFormDictionary(&podofoDoc, &podofoObj);

1581 return true;

1582 }

1583

1584 bool mapFieldDictionary(const SkPdfObject& in, SkPdfFieldDictionary** out) {

1585 return mapFieldDictionary(in.doc(), in.podofo(), out);

1586 }

1587

1588 bool mapFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofo Obj, SkPdfFieldDictionary** out) {

1589 if (!isFieldDictionary(podofoDoc, podofoObj)) return false;

1590

1591

1592 *out = new SkPdfFieldDictionary(&podofoDoc, &podofoObj);

1593 return true;

1594 }

1595

1596 bool mapVariableTextFieldDictionary(const SkPdfObject& in, SkPdfVariableTextFiel dDictionary** out) {

1597 return mapVariableTextFieldDictionary(in.doc(), in.podofo(), out);

1598 }

1599

1600 bool mapVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfVariableTextFieldDictionary** out) {

1601 if (!isVariableTextFieldDictionary(podofoDoc, podofoObj)) return false;

1602

1603

1604 *out = new SkPdfVariableTextFieldDictionary(&podofoDoc, &podofoObj);

1605 return true;

1606 }

1607

1608 bool mapAppearanceCharacteristicsDictionary(const SkPdfObject& in, SkPdfAppearan ceCharacteristicsDictionary** out) {

1609 return mapAppearanceCharacteristicsDictionary(in.doc(), in.podofo(), out);

1610 }

1611

1612 bool mapAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, con st PdfObject& podofoObj, SkPdfAppearanceCharacteristicsDictionary** out) {

1613 if (!isAppearanceCharacteristicsDictionary(podofoDoc, podofoObj)) return false ;

1614

1615

1616 *out = new SkPdfAppearanceCharacteristicsDictionary(&podofoDoc, &podofoObj);

1617 return true;

1618 }

1619

1620 bool mapCheckboxFieldDictionary(const SkPdfObject& in, SkPdfCheckboxFieldDiction ary** out) {

1621 return mapCheckboxFieldDictionary(in.doc(), in.podofo(), out);

1622 }

1623

1624 bool mapCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfCheckboxFieldDictionary** out) {

1625 if (!isCheckboxFieldDictionary(podofoDoc, podofoObj)) return false;

1626

1627

1628 *out = new SkPdfCheckboxFieldDictionary(&podofoDoc, &podofoObj);

1629 return true;

1630 }

1631

1632 bool mapRadioButtonFieldDictionary(const SkPdfObject& in, SkPdfRadioButtonFieldD ictionary** out) {

1633 return mapRadioButtonFieldDictionary(in.doc(), in.podofo(), out);

1634 }

1635

1636 bool mapRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfRadioButtonFieldDictionary** out) {

1637 if (!isRadioButtonFieldDictionary(podofoDoc, podofoObj)) return false;

1638

1639

1640 *out = new SkPdfRadioButtonFieldDictionary(&podofoDoc, &podofoObj);

1641 return true;

1642 }

1643

1644 bool mapTextFieldDictionary(const SkPdfObject& in, SkPdfTextFieldDictionary** ou t) {

1645 return mapTextFieldDictionary(in.doc(), in.podofo(), out);

1646 }

1647

1648 bool mapTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfTextFieldDictionary** out) {

1649 if (!isTextFieldDictionary(podofoDoc, podofoObj)) return false;

1650

1651

1652 *out = new SkPdfTextFieldDictionary(&podofoDoc, &podofoObj);

1653 return true;

1654 }

1655

1656 bool mapChoiceFieldDictionary(const SkPdfObject& in, SkPdfChoiceFieldDictionary* * out) {

1657 return mapChoiceFieldDictionary(in.doc(), in.podofo(), out);

1658 }

1659

1660 bool mapChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfChoiceFieldDictionary** out) {

1661 if (!isChoiceFieldDictionary(podofoDoc, podofoObj)) return false;

1662

1663

1664 *out = new SkPdfChoiceFieldDictionary(&podofoDoc, &podofoObj);

1665 return true;

1666 }

1667

1668 bool mapSignatureDictionary(const SkPdfObject& in, SkPdfSignatureDictionary** ou t) {

1669 return mapSignatureDictionary(in.doc(), in.podofo(), out);

1670 }

1671

1672 bool mapSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfSignatureDictionary** out) {

1673 if (!isSignatureDictionary(podofoDoc, podofoObj)) return false;

1674

1675

1676 *out = new SkPdfSignatureDictionary(&podofoDoc, &podofoObj);

1677 return true;

1678 }

1679

1680 bool mapSubmitFormActionDictionary(const SkPdfObject& in, SkPdfSubmitFormActionD ictionary** out) {

1681 return mapSubmitFormActionDictionary(in.doc(), in.podofo(), out);

1682 }

1683

1684 bool mapSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfSubmitFormActionDictionary** out) {

1685 if (!isSubmitFormActionDictionary(podofoDoc, podofoObj)) return false;

1686

1687

1688 *out = new SkPdfSubmitFormActionDictionary(&podofoDoc, &podofoObj);

1689 return true;

1690 }

1691

1692 bool mapResetFormActionDictionary(const SkPdfObject& in, SkPdfResetFormActionDic tionary** out) {

1693 return mapResetFormActionDictionary(in.doc(), in.podofo(), out);

1694 }

1695

1696 bool mapResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfResetFormActionDictionary** out) {

1697 if (!isResetFormActionDictionary(podofoDoc, podofoObj)) return false;

1698

1699

1700 *out = new SkPdfResetFormActionDictionary(&podofoDoc, &podofoObj);

1701 return true;

1702 }

1703

1704 bool mapImportDataActionDictionary(const SkPdfObject& in, SkPdfImportDataActionD ictionary** out) {

1705 return mapImportDataActionDictionary(in.doc(), in.podofo(), out);

1706 }

1707

1708 bool mapImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfImportDataActionDictionary** out) {

1709 if (!isImportDataActionDictionary(podofoDoc, podofoObj)) return false;

1710

1711

1712 *out = new SkPdfImportDataActionDictionary(&podofoDoc, &podofoObj);

1713 return true;

1714 }

1715

1716 bool mapJavascriptActionDictionary(const SkPdfObject& in, SkPdfJavascriptActionD ictionary** out) {

1717 return mapJavascriptActionDictionary(in.doc(), in.podofo(), out);

1718 }

1719

1720 bool mapJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfJavascriptActionDictionary** out) {

1721 if (!isJavascriptActionDictionary(podofoDoc, podofoObj)) return false;

1722

1723

1724 *out = new SkPdfJavascriptActionDictionary(&podofoDoc, &podofoObj);

1725 return true;

1726 }

1727

1728 bool mapFDFTrailerDictionary(const SkPdfObject& in, SkPdfFDFTrailerDictionary** out) {

1729 return mapFDFTrailerDictionary(in.doc(), in.podofo(), out);

1730 }

1731

1732 bool mapFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfFDFTrailerDictionary** out) {

1733 if (!isFDFTrailerDictionary(podofoDoc, podofoObj)) return false;

1734

1735

1736 *out = new SkPdfFDFTrailerDictionary(&podofoDoc, &podofoObj);

1737 return true;

1738 }

1739

1740 bool mapFDFCatalogDictionary(const SkPdfObject& in, SkPdfFDFCatalogDictionary** out) {

1741 return mapFDFCatalogDictionary(in.doc(), in.podofo(), out);

1742 }

1743

1744 bool mapFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfFDFCatalogDictionary** out) {

1745 if (!isFDFCatalogDictionary(podofoDoc, podofoObj)) return false;

1746

1747

1748 *out = new SkPdfFDFCatalogDictionary(&podofoDoc, &podofoObj);

1749 return true;

1750 }

1751

1752 bool mapFDFDictionary(const SkPdfObject& in, SkPdfFDFDictionary** out) {

1753 return mapFDFDictionary(in.doc(), in.podofo(), out);

1754 }

1755

1756 bool mapFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoOb j, SkPdfFDFDictionary** out) {

1757 if (!isFDFDictionary(podofoDoc, podofoObj)) return false;

1758

1759

1760 *out = new SkPdfFDFDictionary(&podofoDoc, &podofoObj);

1761 return true;

1762 }

1763

1764 bool mapEncryptedEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEncryp tedEmbeddedFileStreamDictionary** out) {

1765 return mapEncryptedEmbeddedFileStreamDictionary(in.doc(), in.podofo(), out);

1766 }

1767

1768 bool mapEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, c onst PdfObject& podofoObj, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {

1769 if (!isEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return fal se;

1770

1771

1772 *out = new SkPdfEncryptedEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);

1773 return true;

1774 }

1775

1776 bool mapJavascriptDictionary(const SkPdfObject& in, SkPdfJavascriptDictionary** out) {

1777 return mapJavascriptDictionary(in.doc(), in.podofo(), out);

1778 }

1779

1780 bool mapJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfJavascriptDictionary** out) {

1781 if (!isJavascriptDictionary(podofoDoc, podofoObj)) return false;

1782

1783

1784 *out = new SkPdfJavascriptDictionary(&podofoDoc, &podofoObj);

1785 return true;

1786 }

1787

1788 bool mapFDFFieldDictionary(const SkPdfObject& in, SkPdfFDFFieldDictionary** out) {

1789 return mapFDFFieldDictionary(in.doc(), in.podofo(), out);

1790 }

1791

1792 bool mapFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj, SkPdfFDFFieldDictionary** out) {

1793 if (!isFDFFieldDictionary(podofoDoc, podofoObj)) return false;

1794

1795

1796 *out = new SkPdfFDFFieldDictionary(&podofoDoc, &podofoObj);

1797 return true;

1798 }

1799

1800 bool mapIconFitDictionary(const SkPdfObject& in, SkPdfIconFitDictionary** out) {

1801 return mapIconFitDictionary(in.doc(), in.podofo(), out);

1802 }

1803

1804 bool mapIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj, SkPdfIconFitDictionary** out) {

1805 if (!isIconFitDictionary(podofoDoc, podofoObj)) return false;

1806

1807

1808 *out = new SkPdfIconFitDictionary(&podofoDoc, &podofoObj);

1809 return true;

1810 }

1811

1812 bool mapFDFPageDictionary(const SkPdfObject& in, SkPdfFDFPageDictionary** out) {

1813 return mapFDFPageDictionary(in.doc(), in.podofo(), out);

1814 }

1815

1816 bool mapFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj, SkPdfFDFPageDictionary** out) {

1817 if (!isFDFPageDictionary(podofoDoc, podofoObj)) return false;

1818

1819

1820 *out = new SkPdfFDFPageDictionary(&podofoDoc, &podofoObj);

1821 return true;

1822 }

1823

1824 bool mapFDFTemplateDictionary(const SkPdfObject& in, SkPdfFDFTemplateDictionary* * out) {

1825 return mapFDFTemplateDictionary(in.doc(), in.podofo(), out);

1826 }

1827

1828 bool mapFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTemplateDictionary** out) {

1829 if (!isFDFTemplateDictionary(podofoDoc, podofoObj)) return false;

1830

1831

1832 *out = new SkPdfFDFTemplateDictionary(&podofoDoc, &podofoObj);

1833 return true;

1834 }

1835

1836 bool mapFDFNamedPageReferenceDictionary(const SkPdfObject& in, SkPdfFDFNamedPage ReferenceDictionary** out) {

1837 return mapFDFNamedPageReferenceDictionary(in.doc(), in.podofo(), out);

1838 }

1839

1840 bool mapFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj, SkPdfFDFNamedPageReferenceDictionary** out) {

1841 if (!isFDFNamedPageReferenceDictionary(podofoDoc, podofoObj)) return false;

1842

1843

1844 *out = new SkPdfFDFNamedPageReferenceDictionary(&podofoDoc, &podofoObj);

1845 return true;

1846 }

1847

1848 bool mapFDFFileAnnotationDictionary(const SkPdfObject& in, SkPdfFDFFileAnnotatio nDictionary** out) {

1849 return mapFDFFileAnnotationDictionary(in.doc(), in.podofo(), out);

1850 }

1851

1852 bool mapFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfFDFFileAnnotationDictionary** out) {

1853 if (!isFDFFileAnnotationDictionary(podofoDoc, podofoObj)) return false;

1854

1855

1856 *out = new SkPdfFDFFileAnnotationDictionary(&podofoDoc, &podofoObj);

1857 return true;

1858 }

1859

1860 bool mapSoundObjectDictionary(const SkPdfObject& in, SkPdfSoundObjectDictionary* * out) {

1861 return mapSoundObjectDictionary(in.doc(), in.podofo(), out);

1862 }

1863

1864 bool mapSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundObjectDictionary** out) {

1865 if (!isSoundObjectDictionary(podofoDoc, podofoObj)) return false;

1866

1867

1868 *out = new SkPdfSoundObjectDictionary(&podofoDoc, &podofoObj);

1869 return true;

1870 }

1871

1872 bool mapMovieDictionary(const SkPdfObject& in, SkPdfMovieDictionary** out) {

1873 return mapMovieDictionary(in.doc(), in.podofo(), out);

1874 }

1875

1876 bool mapMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofo Obj, SkPdfMovieDictionary** out) {

1877 if (!isMovieDictionary(podofoDoc, podofoObj)) return false;

1878

1879

1880 *out = new SkPdfMovieDictionary(&podofoDoc, &podofoObj);

1881 return true;

1882 }

1883

1884 bool mapMovieActivationDictionary(const SkPdfObject& in, SkPdfMovieActivationDic tionary** out) {

1885 return mapMovieActivationDictionary(in.doc(), in.podofo(), out);

1886 }

1887

1888 bool mapMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfMovieActivationDictionary** out) {

1889 if (!isMovieActivationDictionary(podofoDoc, podofoObj)) return false;

1890

1891

1892 *out = new SkPdfMovieActivationDictionary(&podofoDoc, &podofoObj);

1893 return true;

1894 }

1895

1896 bool mapDocumentInformationDictionary(const SkPdfObject& in, SkPdfDocumentInform ationDictionary** out) {

1897 return mapDocumentInformationDictionary(in.doc(), in.podofo(), out);

1898 }

1899

1900 bool mapDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const Pdf Object& podofoObj, SkPdfDocumentInformationDictionary** out) {

1901 if (!isDocumentInformationDictionary(podofoDoc, podofoObj)) return false;

1902

1903

1904 *out = new SkPdfDocumentInformationDictionary(&podofoDoc, &podofoObj);

1905 return true;

1906 }

1907

1908 bool mapMetadataStreamDictionary(const SkPdfObject& in, SkPdfMetadataStreamDicti onary** out) {

1909 return mapMetadataStreamDictionary(in.doc(), in.podofo(), out);

1910 }

1911

1912 bool mapMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj, SkPdfMetadataStreamDictionary** out) {

1913 if (!isMetadataStreamDictionary(podofoDoc, podofoObj)) return false;

1914

1915

1916 *out = new SkPdfMetadataStreamDictionary(&podofoDoc, &podofoObj);

1917 return true;

1918 }

1919

1920 bool mapComponentsWithMetadataDictionary(const SkPdfObject& in, SkPdfComponentsW ithMetadataDictionary** out) {

1921 return mapComponentsWithMetadataDictionary(in.doc(), in.podofo(), out);

1922 }

1923

1924 bool mapComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfComponentsWithMetadataDictionary** out) {

1925 if (!isComponentsWithMetadataDictionary(podofoDoc, podofoObj)) return false;

1926

1927

1928 *out = new SkPdfComponentsWithMetadataDictionary(&podofoDoc, &podofoObj);

1929 return true;

1930 }

1931

1932 bool mapPagePieceDictionary(const SkPdfObject& in, SkPdfPagePieceDictionary** ou t) {

1933 return mapPagePieceDictionary(in.doc(), in.podofo(), out);

1934 }

1935

1936 bool mapPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfPagePieceDictionary** out) {

1937 if (!isPagePieceDictionary(podofoDoc, podofoObj)) return false;

1938

1939

1940 *out = new SkPdfPagePieceDictionary(&podofoDoc, &podofoObj);

1941 return true;

1942 }

1943

1944 bool mapApplicationDataDictionary(const SkPdfObject& in, SkPdfApplicationDataDic tionary** out) {

1945 return mapApplicationDataDictionary(in.doc(), in.podofo(), out);

1946 }

1947

1948 bool mapApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfApplicationDataDictionary** out) {

1949 if (!isApplicationDataDictionary(podofoDoc, podofoObj)) return false;

1950

1951

1952 *out = new SkPdfApplicationDataDictionary(&podofoDoc, &podofoObj);

1953 return true;

1954 }

1955

1956 bool mapStructureTreeRootDictionary(const SkPdfObject& in, SkPdfStructureTreeRoo tDictionary** out) {

1957 return mapStructureTreeRootDictionary(in.doc(), in.podofo(), out);

1958 }

1959

1960 bool mapStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfStructureTreeRootDictionary** out) {

1961 if (!isStructureTreeRootDictionary(podofoDoc, podofoObj)) return false;

1962

1963

1964 *out = new SkPdfStructureTreeRootDictionary(&podofoDoc, &podofoObj);

1965 return true;

1966 }

1967

1968 bool mapStructureElementDictionary(const SkPdfObject& in, SkPdfStructureElementD ictionary** out) {

1969 return mapStructureElementDictionary(in.doc(), in.podofo(), out);

1970 }

1971

1972 bool mapStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj, SkPdfStructureElementDictionary** out) {

1973 if (!isStructureElementDictionary(podofoDoc, podofoObj)) return false;

1974

1975

1976 *out = new SkPdfStructureElementDictionary(&podofoDoc, &podofoObj);

1977 return true;

1978 }

1979

1980 bool mapMarkedContentReferenceDictionary(const SkPdfObject& in, SkPdfMarkedConte ntReferenceDictionary** out) {

1981 return mapMarkedContentReferenceDictionary(in.doc(), in.podofo(), out);

1982 }

1983

1984 bool mapMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkedContentReferenceDictionary** out) {

1985 if (!isMarkedContentReferenceDictionary(podofoDoc, podofoObj)) return false;

1986

1987

1988 *out = new SkPdfMarkedContentReferenceDictionary(&podofoDoc, &podofoObj);

1989 return true;

1990 }

1991

1992 bool mapObjectReferenceDictionary(const SkPdfObject& in, SkPdfObjectReferenceDic tionary** out) {

1993 return mapObjectReferenceDictionary(in.doc(), in.podofo(), out);

1994 }

1995

1996 bool mapObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfObjectReferenceDictionary** out) {

1997 if (!isObjectReferenceDictionary(podofoDoc, podofoObj)) return false;

1998

1999

2000 *out = new SkPdfObjectReferenceDictionary(&podofoDoc, &podofoObj);

2001 return true;

2002 }

2003

2004 bool mapStructureElementAccessDictionary(const SkPdfObject& in, SkPdfStructureEl ementAccessDictionary** out) {

2005 return mapStructureElementAccessDictionary(in.doc(), in.podofo(), out);

2006 }

2007

2008 bool mapStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementAccessDictionary** out) {

2009 if (!isStructureElementAccessDictionary(podofoDoc, podofoObj)) return false;

2010

2011

2012 *out = new SkPdfStructureElementAccessDictionary(&podofoDoc, &podofoObj);

2013 return true;

2014 }

2015

2016 bool mapAttributeObjectDictionary(const SkPdfObject& in, SkPdfAttributeObjectDic tionary** out) {

2017 return mapAttributeObjectDictionary(in.doc(), in.podofo(), out);

2018 }

2019

2020 bool mapAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfAttributeObjectDictionary** out) {

2021 if (!isAttributeObjectDictionary(podofoDoc, podofoObj)) return false;

2022

2023

2024 *out = new SkPdfAttributeObjectDictionary(&podofoDoc, &podofoObj);

2025 return true;

2026 }

2027

2028 bool mapMarkInformationDictionary(const SkPdfObject& in, SkPdfMarkInformationDic tionary** out) {

2029 return mapMarkInformationDictionary(in.doc(), in.podofo(), out);

2030 }

2031

2032 bool mapMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfMarkInformationDictionary** out) {

2033 if (!isMarkInformationDictionary(podofoDoc, podofoObj)) return false;

2034

2035

2036 *out = new SkPdfMarkInformationDictionary(&podofoDoc, &podofoObj);

2037 return true;

2038 }

2039

2040 bool mapArtifactsDictionary(const SkPdfObject& in, SkPdfArtifactsDictionary** ou t) {

2041 return mapArtifactsDictionary(in.doc(), in.podofo(), out);

2042 }

2043

2044 bool mapArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj, SkPdfArtifactsDictionary** out) {

2045 if (!isArtifactsDictionary(podofoDoc, podofoObj)) return false;

2046

2047

2048 *out = new SkPdfArtifactsDictionary(&podofoDoc, &podofoObj);

2049 return true;

2050 }

2051

2052 bool mapStandardStructureDictionary(const SkPdfObject& in, SkPdfStandardStructur eDictionary** out) {

2053 return mapStandardStructureDictionary(in.doc(), in.podofo(), out);

2054 }

2055

2056 bool mapStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfStandardStructureDictionary** out) {

2057 if (!isStandardStructureDictionary(podofoDoc, podofoObj)) return false;

2058

2059

2060 *out = new SkPdfStandardStructureDictionary(&podofoDoc, &podofoObj);

2061 return true;

2062 }

2063

2064 bool mapBlockLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfBlockL evelStructureElementsDictionary** out) {

2065 return mapBlockLevelStructureElementsDictionary(in.doc(), in.podofo(), out);

2066 }

2067

2068 bool mapBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, c onst PdfObject& podofoObj, SkPdfBlockLevelStructureElementsDictionary** out) {

2069 if (!isBlockLevelStructureElementsDictionary(podofoDoc, podofoObj)) return fal se;

2070

2071

2072 *out = new SkPdfBlockLevelStructureElementsDictionary(&podofoDoc, &podofoObj);

2073 return true;

2074 }

2075

2076 bool mapInlineLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfInlin eLevelStructureElementsDictionary** out) {

2077 return mapInlineLevelStructureElementsDictionary(in.doc(), in.podofo(), out) ;

2078 }

2079

2080 bool mapInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInlineLevelStructureElementsDictionary** out) {

2081 if (!isInlineLevelStructureElementsDictionary(podofoDoc, podofoObj)) return fa lse;

2082

2083

2084 *out = new SkPdfInlineLevelStructureElementsDictionary(&podofoDoc, &podofoObj) ;

2085 return true;

2086 }

2087

2088 bool mapListAttributeDictionary(const SkPdfObject& in, SkPdfListAttributeDiction ary** out) {

2089 return mapListAttributeDictionary(in.doc(), in.podofo(), out);

2090 }

2091

2092 bool mapListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj, SkPdfListAttributeDictionary** out) {

2093 if (!isListAttributeDictionary(podofoDoc, podofoObj)) return false;

2094

2095

2096 *out = new SkPdfListAttributeDictionary(&podofoDoc, &podofoObj);

2097 return true;

2098 }

2099

2100 bool mapTableAttributesDictionary(const SkPdfObject& in, SkPdfTableAttributesDic tionary** out) {

2101 return mapTableAttributesDictionary(in.doc(), in.podofo(), out);

2102 }

2103

2104 bool mapTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfTableAttributesDictionary** out) {

2105 if (!isTableAttributesDictionary(podofoDoc, podofoObj)) return false;

2106

2107

2108 *out = new SkPdfTableAttributesDictionary(&podofoDoc, &podofoObj);

2109 return true;

2110 }

2111

2112 bool mapWebCaptureInformationDictionary(const SkPdfObject& in, SkPdfWebCaptureIn formationDictionary** out) {

2113 return mapWebCaptureInformationDictionary(in.doc(), in.podofo(), out);

2114 }

2115

2116 bool mapWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj, SkPdfWebCaptureInformationDictionary** out) {

2117 if (!isWebCaptureInformationDictionary(podofoDoc, podofoObj)) return false;

2118

2119

2120 *out = new SkPdfWebCaptureInformationDictionary(&podofoDoc, &podofoObj);

2121 return true;

2122 }

2123

2124 bool mapWebCaptureDictionary(const SkPdfObject& in, SkPdfWebCaptureDictionary** out) {

2125 return mapWebCaptureDictionary(in.doc(), in.podofo(), out);

2126 }

2127

2128 bool mapWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfWebCaptureDictionary** out) {

2129 if (!isWebCaptureDictionary(podofoDoc, podofoObj)) return false;

2130

2131

2132 *out = new SkPdfWebCaptureDictionary(&podofoDoc, &podofoObj);

2133 return true;

2134 }

2135

2136 bool mapWebCapturePageSetDictionary(const SkPdfObject& in, SkPdfWebCapturePageSe tDictionary** out) {

2137 return mapWebCapturePageSetDictionary(in.doc(), in.podofo(), out);

2138 }

2139

2140 bool mapWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfWebCapturePageSetDictionary** out) {

2141 if (!isWebCapturePageSetDictionary(podofoDoc, podofoObj)) return false;

2142

2143

2144 *out = new SkPdfWebCapturePageSetDictionary(&podofoDoc, &podofoObj);

2145 return true;

2146 }

2147

2148 bool mapWebCaptureImageSetDictionary(const SkPdfObject& in, SkPdfWebCaptureImage SetDictionary** out) {

2149 return mapWebCaptureImageSetDictionary(in.doc(), in.podofo(), out);

2150 }

2151

2152 bool mapWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfO bject& podofoObj, SkPdfWebCaptureImageSetDictionary** out) {

2153 if (!isWebCaptureImageSetDictionary(podofoDoc, podofoObj)) return false;

2154

2155

2156 *out = new SkPdfWebCaptureImageSetDictionary(&podofoDoc, &podofoObj);

2157 return true;

2158 }

2159

2160 bool mapSourceInformationDictionary(const SkPdfObject& in, SkPdfSourceInformatio nDictionary** out) {

2161 return mapSourceInformationDictionary(in.doc(), in.podofo(), out);

2162 }

2163

2164 bool mapSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfSourceInformationDictionary** out) {

2165 if (!isSourceInformationDictionary(podofoDoc, podofoObj)) return false;

2166

2167

2168 *out = new SkPdfSourceInformationDictionary(&podofoDoc, &podofoObj);

2169 return true;

2170 }

2171

2172 bool mapURLAliasDictionary(const SkPdfObject& in, SkPdfURLAliasDictionary** out) {

2173 return mapURLAliasDictionary(in.doc(), in.podofo(), out);

2174 }

2175

2176 bool mapURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj, SkPdfURLAliasDictionary** out) {

2177 if (!isURLAliasDictionary(podofoDoc, podofoObj)) return false;

2178

2179

2180 *out = new SkPdfURLAliasDictionary(&podofoDoc, &podofoObj);

2181 return true;

2182 }

2183

2184 bool mapWebCaptureCommandDictionary(const SkPdfObject& in, SkPdfWebCaptureComman dDictionary** out) {

2185 return mapWebCaptureCommandDictionary(in.doc(), in.podofo(), out);

2186 }

2187

2188 bool mapWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfWebCaptureCommandDictionary** out) {

2189 if (!isWebCaptureCommandDictionary(podofoDoc, podofoObj)) return false;

2190

2191

2192 *out = new SkPdfWebCaptureCommandDictionary(&podofoDoc, &podofoObj);

2193 return true;

2194 }

2195

2196 bool mapWebCaptureCommandSettingsDictionary(const SkPdfObject& in, SkPdfWebCaptu reCommandSettingsDictionary** out) {

2197 return mapWebCaptureCommandSettingsDictionary(in.doc(), in.podofo(), out);

2198 }

2199

2200 bool mapWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, con st PdfObject& podofoObj, SkPdfWebCaptureCommandSettingsDictionary** out) {

2201 if (!isWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj)) return false ;

2202

2203

2204 *out = new SkPdfWebCaptureCommandSettingsDictionary(&podofoDoc, &podofoObj);

2205 return true;

2206 }

2207

2208 bool mapBoxColorInformationDictionary(const SkPdfObject& in, SkPdfBoxColorInform ationDictionary** out) {

2209 return mapBoxColorInformationDictionary(in.doc(), in.podofo(), out);

2210 }

2211

2212 bool mapBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const Pdf Object& podofoObj, SkPdfBoxColorInformationDictionary** out) {

2213 if (!isBoxColorInformationDictionary(podofoDoc, podofoObj)) return false;

2214

2215

2216 *out = new SkPdfBoxColorInformationDictionary(&podofoDoc, &podofoObj);

2217 return true;

2218 }

2219

2220 bool mapBoxStyleDictionary(const SkPdfObject& in, SkPdfBoxStyleDictionary** out) {

2221 return mapBoxStyleDictionary(in.doc(), in.podofo(), out);

2222 }

2223

2224 bool mapBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj, SkPdfBoxStyleDictionary** out) {

2225 if (!isBoxStyleDictionary(podofoDoc, podofoObj)) return false;

2226

2227

2228 *out = new SkPdfBoxStyleDictionary(&podofoDoc, &podofoObj);

2229 return true;

2230 }

2231

2232 bool mapPrinterMarkAnnotationDictionary(const SkPdfObject& in, SkPdfPrinterMarkA nnotationDictionary** out) {

2233 return mapPrinterMarkAnnotationDictionary(in.doc(), in.podofo(), out);

2234 }

2235

2236 bool mapPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj, SkPdfPrinterMarkAnnotationDictionary** out) {

2237 if (!isPrinterMarkAnnotationDictionary(podofoDoc, podofoObj)) return false;

2238

2239

2240 *out = new SkPdfPrinterMarkAnnotationDictionary(&podofoDoc, &podofoObj);

2241 return true;

2242 }

2243

2244 bool mapPrinterMarkFormDictionary(const SkPdfObject& in, SkPdfPrinterMarkFormDic tionary** out) {

2245 return mapPrinterMarkFormDictionary(in.doc(), in.podofo(), out);

2246 }

2247

2248 bool mapPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfPrinterMarkFormDictionary** out) {

2249 if (!isPrinterMarkFormDictionary(podofoDoc, podofoObj)) return false;

2250

2251

2252 *out = new SkPdfPrinterMarkFormDictionary(&podofoDoc, &podofoObj);

2253 return true;

2254 }

2255

2256 bool mapSeparationDictionary(const SkPdfObject& in, SkPdfSeparationDictionary** out) {

2257 return mapSeparationDictionary(in.doc(), in.podofo(), out);

2258 }

2259

2260 bool mapSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfSeparationDictionary** out) {

2261 if (!isSeparationDictionary(podofoDoc, podofoObj)) return false;

2262

2263

2264 *out = new SkPdfSeparationDictionary(&podofoDoc, &podofoObj);

2265 return true;

2266 }

2267

2268 bool mapPDF_XOutputIntentDictionary(const SkPdfObject& in, SkPdfPDF_XOutputInten tDictionary** out) {

2269 return mapPDF_XOutputIntentDictionary(in.doc(), in.podofo(), out);

2270 }

2271

2272 bool mapPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj, SkPdfPDF_XOutputIntentDictionary** out) {

2273 if (!isPDF_XOutputIntentDictionary(podofoDoc, podofoObj)) return false;

2274

2275

2276 *out = new SkPdfPDF_XOutputIntentDictionary(&podofoDoc, &podofoObj);

2277 return true;

2278 }

2279

2280 bool mapTrapNetworkAnnotationDictionary(const SkPdfObject& in, SkPdfTrapNetworkA nnotationDictionary** out) {

2281 return mapTrapNetworkAnnotationDictionary(in.doc(), in.podofo(), out);

2282 }

2283

2284 bool mapTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj, SkPdfTrapNetworkAnnotationDictionary** out) {

2285 if (!isTrapNetworkAnnotationDictionary(podofoDoc, podofoObj)) return false;

2286

2287

2288 *out = new SkPdfTrapNetworkAnnotationDictionary(&podofoDoc, &podofoObj);

2289 return true;

2290 }

2291

2292 bool mapTrapNetworkAppearanceStreamDictionary(const SkPdfObject& in, SkPdfTrapNe tworkAppearanceStreamDictionary** out) {

2293 return mapTrapNetworkAppearanceStreamDictionary(in.doc(), in.podofo(), out);

2294 }

2295

2296 bool mapTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, c onst PdfObject& podofoObj, SkPdfTrapNetworkAppearanceStreamDictionary** out) {

2297 if (!isTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj)) return fal se;

2298

2299

2300 *out = new SkPdfTrapNetworkAppearanceStreamDictionary(&podofoDoc, &podofoObj);

2301 return true;

2302 }

2303

2304 bool mapOpiVersionDictionary(const SkPdfObject& in, SkPdfOpiVersionDictionary** out) {

2305 return mapOpiVersionDictionary(in.doc(), in.podofo(), out);

2306 }

2307

2308 bool mapOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj, SkPdfOpiVersionDictionary** out) {

2309 if (!isOpiVersionDictionary(podofoDoc, podofoObj)) return false;

2310

2311

2312 *out = new SkPdfOpiVersionDictionary(&podofoDoc, &podofoObj);

2313 return true;

2314 }

2315

2316 bool mapMultiMasterFontDictionary(const SkPdfObject& in, SkPdfMultiMasterFontDic tionary** out) {

2317 return mapMultiMasterFontDictionary(in.doc(), in.podofo(), out);

2318 }

2319

2320 bool mapMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj, SkPdfMultiMasterFontDictionary** out) {

2321 if (!isMultiMasterFontDictionary(podofoDoc, podofoObj)) return false;

2322

2323

2324 *out = new SkPdfMultiMasterFontDictionary(&podofoDoc, &podofoObj);

2325 return true;

2326 }

2327

2328 bool isObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2329 return true;

2330 }

2331

2332 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dic t, const char* key, SkPdfObject** data) {

2333 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2334 if (value == NULL) { return false; }

2335 if (data == NULL) { return true; }

2336 return mapObject(pdfDoc, value, (SkPdfObject**)data);

2337 }

2338

2339 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dic t, const char* key, const char* abr, SkPdfObject** data) {

2340 if (ObjectFromDictionary(pdfDoc, dict, key, data)) return true;

2341 if (abr == NULL \|\| *abr == '\0') return false;

2342 return ObjectFromDictionary(pdfDoc, dict, abr, data);

2343 }

2344

2345 bool isNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2346 return podofoObj.GetDataType() == ePdfDataType_Null;

2347 }

2348

2349 bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNull** data) {

2350 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2351 if (value == NULL) { return false; }

2352 if (data == NULL) { return true; }

2353 return mapNull(pdfDoc, value, (SkPdfNull**)data);

2354 }

2355

2356 bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNull** data) {

2357 if (NullFromDictionary(pdfDoc, dict, key, data)) return true;

2358 if (abr == NULL \|\| *abr == '\0') return false;

2359 return NullFromDictionary(pdfDoc, dict, abr, data);

2360 }

2361

2362 bool isBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2363 return podofoObj.GetDataType() == ePdfDataType_Bool;

2364 }

2365

2366 bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& di ct, const char* key, SkPdfBoolean** data) {

2367 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2368 if (value == NULL) { return false; }

2369 if (data == NULL) { return true; }

2370 return mapBoolean(pdfDoc, value, (SkPdfBoolean**)data);

2371 }

2372

2373 bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& di ct, const char* key, const char* abr, SkPdfBoolean** data) {

2374 if (BooleanFromDictionary(pdfDoc, dict, key, data)) return true;

2375 if (abr == NULL \|\| *abr == '\0') return false;

2376 return BooleanFromDictionary(pdfDoc, dict, abr, data);

2377 }

2378

2379 bool isInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2380 return podofoObj.GetDataType() == ePdfDataType_Number \|\| podofoObj.GetDataType () == ePdfDataType_Real;

2381 }

2382

2383 bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& di ct, const char* key, SkPdfInteger** data) {

2384 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2385 if (value == NULL) { return false; }

2386 if (data == NULL) { return true; }

2387 return mapInteger(pdfDoc, value, (SkPdfInteger**)data);

2388 }

2389

2390 bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& di ct, const char* key, const char* abr, SkPdfInteger** data) {

2391 if (IntegerFromDictionary(pdfDoc, dict, key, data)) return true;

2392 if (abr == NULL \|\| *abr == '\0') return false;

2393 return IntegerFromDictionary(pdfDoc, dict, abr, data);

2394 }

2395

2396 bool isNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2397 return podofoObj.GetDataType() == ePdfDataType_Number \|\| podofoObj.GetDataType () == ePdfDataType_Real;

2398 }

2399

2400 bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dic t, const char* key, SkPdfNumber** data) {

2401 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2402 if (value == NULL) { return false; }

2403 if (data == NULL) { return true; }

2404 return mapNumber(pdfDoc, value, (SkPdfNumber**)data);

2405 }

2406

2407 bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dic t, const char* key, const char* abr, SkPdfNumber** data) {

2408 if (NumberFromDictionary(pdfDoc, dict, key, data)) return true;

2409 if (abr == NULL \|\| *abr == '\0') return false;

2410 return NumberFromDictionary(pdfDoc, dict, abr, data);

2411 }

2412

2413 bool isName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2414 return podofoObj.GetDataType() == ePdfDataType_Name;

2415 }

2416

2417 bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfName** data) {

2418 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2419 if (value == NULL) { return false; }

2420 if (data == NULL) { return true; }

2421 return mapName(pdfDoc, value, (SkPdfName**)data);

2422 }

2423

2424 bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfName** data) {

2425 if (NameFromDictionary(pdfDoc, dict, key, data)) return true;

2426 if (abr == NULL \|\| *abr == '\0') return false;

2427 return NameFromDictionary(pdfDoc, dict, abr, data);

2428 }

2429

2430 bool isReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2431 return podofoObj.GetDataType() == ePdfDataType_Reference;

2432 }

2433

2434 bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfReference** data) {

2435 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2436 if (value == NULL) { return false; }

2437 if (data == NULL) { return true; }

2438 return mapReference(pdfDoc, value, (SkPdfReference**)data);

2439 }

2440

2441 bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfReference** data) {

2442 if (ReferenceFromDictionary(pdfDoc, dict, key, data)) return true;

2443 if (abr == NULL \|\| *abr == '\0') return false;

2444 return ReferenceFromDictionary(pdfDoc, dict, abr, data);

2445 }

2446

2447 bool isArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2448 return podofoObj.GetDataType() == ePdfDataType_Array;

2449 }

2450

2451 bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict , const char* key, SkPdfArray** data) {

2452 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2453 if (value == NULL) { return false; }

2454 if (data == NULL) { return true; }

2455 return mapArray(pdfDoc, value, (SkPdfArray**)data);

2456 }

2457

2458 bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict , const char* key, const char* abr, SkPdfArray** data) {

2459 if (ArrayFromDictionary(pdfDoc, dict, key, data)) return true;

2460 if (abr == NULL \|\| *abr == '\0') return false;

2461 return ArrayFromDictionary(pdfDoc, dict, abr, data);

2462 }

2463

2464 bool isString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2465 return podofoObj.GetDataType() == ePdfDataType_String \|\| podofoObj.GetDataType () == ePdfDataType_HexString;

2466 }

2467

2468 bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dic t, const char* key, SkPdfString** data) {

2469 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2470 if (value == NULL) { return false; }

2471 if (data == NULL) { return true; }

2472 return mapString(pdfDoc, value, (SkPdfString**)data);

2473 }

2474

2475 bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dic t, const char* key, const char* abr, SkPdfString** data) {

2476 if (StringFromDictionary(pdfDoc, dict, key, data)) return true;

2477 if (abr == NULL \|\| *abr == '\0') return false;

2478 return StringFromDictionary(pdfDoc, dict, abr, data);

2479 }

2480

2481 bool isHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2482 return podofoObj.GetDataType() == ePdfDataType_HexString;

2483 }

2484

2485 bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfHexString** data) {

2486 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2487 if (value == NULL) { return false; }

2488 if (data == NULL) { return true; }

2489 return mapHexString(pdfDoc, value, (SkPdfHexString**)data);

2490 }

2491

2492 bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfHexString** data) {

2493 if (HexStringFromDictionary(pdfDoc, dict, key, data)) return true;

2494 if (abr == NULL \|\| *abr == '\0') return false;

2495 return HexStringFromDictionary(pdfDoc, dict, abr, data);

2496 }

2497

2498 bool isDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2499 return podofoObj.GetDataType() == ePdfDataType_Dictionary;

2500 }

2501

2502 bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDictionary** data) {

2503 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2504 if (value == NULL) { return false; }

2505 if (data == NULL) { return true; }

2506 return mapDictionary(pdfDoc, value, (SkPdfDictionary**)data);

2507 }

2508

2509 bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDictionary** data) {

2510 if (DictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2511 if (abr == NULL \|\| *abr == '\0') return false;

2512 return DictionaryFromDictionary(pdfDoc, dict, abr, data);

2513 }

2514

2515 bool isStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2516 return true;

2517 }

2518

2519 bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dic t, const char* key, SkPdfStream** data) {

2520 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2521 if (value == NULL) { return false; }

2522 if (data == NULL) { return true; }

2523 return mapStream(pdfDoc, value, (SkPdfStream**)data);

2524 }

2525

2526 bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dic t, const char* key, const char* abr, SkPdfStream** data) {

2527 if (StreamFromDictionary(pdfDoc, dict, key, data)) return true;

2528 if (abr == NULL \|\| *abr == '\0') return false;

2529 return StreamFromDictionary(pdfDoc, dict, abr, data);

2530 }

2531

2532 bool isXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podof oObj) {

2533 return true;

2534 }

2535

2536 bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, SkPdfXObjectDictionary** data) {

2537 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2538 if (value == NULL) { return false; }

2539 if (data == NULL) { return true; }

2540 return mapXObjectDictionary(pdfDoc, value, (SkPdfXObjectDictionary**)data);

2541 }

2542

2543 bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, const char* abr, SkPdfXObjectDictionary** data) {

2544 if (XObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2545 if (abr == NULL \|\| *abr == '\0') return false;

2546 return XObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);

2547 }

2548

2549 bool isFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoOb j) {

2550 return true;

2551 }

2552

2553 bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDiction ary& dict, const char* key, SkPdfFontDictionary** data) {

2554 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2555 if (value == NULL) { return false; }

2556 if (data == NULL) { return true; }

2557 return mapFontDictionary(pdfDoc, value, (SkPdfFontDictionary**)data);

2558 }

2559

2560 bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDiction ary& dict, const char* key, const char* abr, SkPdfFontDictionary** data) {

2561 if (FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2562 if (abr == NULL \|\| *abr == '\0') return false;

2563 return FontDictionaryFromDictionary(pdfDoc, dict, abr, data);

2564 }

2565

2566 bool isTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2567 std::string Subtype;

2568 if (!podofoObj.IsDictionary()) return false;

2569 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;

2570 if ((Subtype != "TrueType")) return false;

2571

2572 return true;

2573 }

2574

2575 bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfTrueTypeFontDictionary** data) {

2576 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2577 if (value == NULL) { return false; }

2578 if (data == NULL) { return true; }

2579 return mapTrueTypeFontDictionary(pdfDoc, value, (SkPdfTrueTypeFontDictionary **)data);

2580 }

2581

2582 bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfTrueTypeFontDictionary ** data) {

2583 if (TrueTypeFontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

2584 if (abr == NULL \|\| *abr == '\0') return false;

2585 return TrueTypeFontDictionaryFromDictionary(pdfDoc, dict, abr, data);

2586 }

2587

2588 bool isStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2589 return true;

2590 }

2591

2592 bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfStreamCommonDictionary** data) {

2593 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2594 if (value == NULL) { return false; }

2595 if (data == NULL) { return true; }

2596 return mapStreamCommonDictionary(pdfDoc, value, (SkPdfStreamCommonDictionary **)data);

2597 }

2598

2599 bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfStreamCommonDictionary ** data) {

2600 if (StreamCommonDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

2601 if (abr == NULL \|\| *abr == '\0') return false;

2602 return StreamCommonDictionaryFromDictionary(pdfDoc, dict, abr, data);

2603 }

2604

2605 bool isLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2606 return true;

2607 }

2608

2609 bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument * pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLzwdecodeAndFlatedeco deFiltersDictionary** data) {

2610 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2611 if (value == NULL) { return false; }

2612 if (data == NULL) { return true; }

2613 return mapLzwdecodeAndFlatedecodeFiltersDictionary(pdfDoc, value, (SkPdfLzwd ecodeAndFlatedecodeFiltersDictionary**)data);

2614 }

2615

2616 bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument * pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLzwd ecodeAndFlatedecodeFiltersDictionary** data) {

2617 if (LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2618 if (abr == NULL \|\| *abr == '\0') return false;

2619 return LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(pdfDoc, dict, ab r, data);

2620 }

2621

2622 bool isCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const Pdf Object& podofoObj) {

2623 return true;

2624 }

2625

2626 bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCcittfaxdecodeFilterDictionary* * data) {

2627 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2628 if (value == NULL) { return false; }

2629 if (data == NULL) { return true; }

2630 return mapCcittfaxdecodeFilterDictionary(pdfDoc, value, (SkPdfCcittfaxdecode FilterDictionary**)data);

2631 }

2632

2633 bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCcittfaxdecode FilterDictionary** data) {

2634 if (CcittfaxdecodeFilterDictionaryFromDictionary(pdfDoc, dict, key, data)) ret urn true;

2635 if (abr == NULL \|\| *abr == '\0') return false;

2636 return CcittfaxdecodeFilterDictionaryFromDictionary(pdfDoc, dict, abr, data);

2637 }

2638

2639 bool isJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

2640 return true;

2641 }

2642

2643 bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfJbig2DecodeFilterDictionary** data ) {

2644 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2645 if (value == NULL) { return false; }

2646 if (data == NULL) { return true; }

2647 return mapJbig2DecodeFilterDictionary(pdfDoc, value, (SkPdfJbig2DecodeFilter Dictionary**)data);

2648 }

2649

2650 bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfJbig2DecodeFilter Dictionary** data) {

2651 if (Jbig2DecodeFilterDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2652 if (abr == NULL \|\| *abr == '\0') return false;

2653 return Jbig2DecodeFilterDictionaryFromDictionary(pdfDoc, dict, abr, data);

2654 }

2655

2656 bool isDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

2657 return true;

2658 }

2659

2660 bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDctdecodeFilterDictionary** data) {

2661 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2662 if (value == NULL) { return false; }

2663 if (data == NULL) { return true; }

2664 return mapDctdecodeFilterDictionary(pdfDoc, value, (SkPdfDctdecodeFilterDict ionary**)data);

2665 }

2666

2667 bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDctdecodeFilterDict ionary** data) {

2668 if (DctdecodeFilterDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

2669 if (abr == NULL \|\| *abr == '\0') return false;

2670 return DctdecodeFilterDictionaryFromDictionary(pdfDoc, dict, abr, data);

2671 }

2672

2673 bool isFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj) {

2674 return true;

2675 }

2676

2677 bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, SkPdfFileTrailerDictionary** data) {

2678 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2679 if (value == NULL) { return false; }

2680 if (data == NULL) { return true; }

2681 return mapFileTrailerDictionary(pdfDoc, value, (SkPdfFileTrailerDictionary** )data);

2682 }

2683

2684 bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, const char* abr, SkPdfFileTrailerDictionary** data) {

2685 if (FileTrailerDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2686 if (abr == NULL \|\| *abr == '\0') return false;

2687 return FileTrailerDictionaryFromDictionary(pdfDoc, dict, abr, data);

2688 }

2689

2690 bool isEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

2691 return true;

2692 }

2693

2694 bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfEncryptionCommonDictionary** data) {

2695 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2696 if (value == NULL) { return false; }

2697 if (data == NULL) { return true; }

2698 return mapEncryptionCommonDictionary(pdfDoc, value, (SkPdfEncryptionCommonDi ctionary**)data);

2699 }

2700

2701 bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfEncryptionCommonDi ctionary** data) {

2702 if (EncryptionCommonDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2703 if (abr == NULL \|\| *abr == '\0') return false;

2704 return EncryptionCommonDictionaryFromDictionary(pdfDoc, dict, abr, data);

2705 }

2706

2707 bool isStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2708 return true;

2709 }

2710

2711 bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDo c, const PdfDictionary& dict, const char* key, SkPdfStandardSecurityHandlerDicti onary** data) {

2712 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2713 if (value == NULL) { return false; }

2714 if (data == NULL) { return true; }

2715 return mapStandardSecurityHandlerDictionary(pdfDoc, value, (SkPdfStandardSec urityHandlerDictionary**)data);

2716 }

2717

2718 bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDo c, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardSec urityHandlerDictionary** data) {

2719 if (StandardSecurityHandlerDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2720 if (abr == NULL \|\| *abr == '\0') return false;

2721 return StandardSecurityHandlerDictionaryFromDictionary(pdfDoc, dict, abr, data );

2722 }

2723

2724 bool isCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podof oObj) {

2725 return true;

2726 }

2727

2728 bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, SkPdfCatalogDictionary** data) {

2729 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2730 if (value == NULL) { return false; }

2731 if (data == NULL) { return true; }

2732 return mapCatalogDictionary(pdfDoc, value, (SkPdfCatalogDictionary**)data);

2733 }

2734

2735 bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, const char* abr, SkPdfCatalogDictionary** data) {

2736 if (CatalogDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2737 if (abr == NULL \|\| *abr == '\0') return false;

2738 return CatalogDictionaryFromDictionary(pdfDoc, dict, abr, data);

2739 }

2740

2741 bool isPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2742 return true;

2743 }

2744

2745 bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfPageTreeNodeDictionary** data) {

2746 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2747 if (value == NULL) { return false; }

2748 if (data == NULL) { return true; }

2749 return mapPageTreeNodeDictionary(pdfDoc, value, (SkPdfPageTreeNodeDictionary **)data);

2750 }

2751

2752 bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfPageTreeNodeDictionary ** data) {

2753 if (PageTreeNodeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

2754 if (abr == NULL \|\| *abr == '\0') return false;

2755 return PageTreeNodeDictionaryFromDictionary(pdfDoc, dict, abr, data);

2756 }

2757

2758 bool isPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

2759 return true;

2760 }

2761

2762 bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfPageObjectDictionary** data) {

2763 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2764 if (value == NULL) { return false; }

2765 if (data == NULL) { return true; }

2766 return mapPageObjectDictionary(pdfDoc, value, (SkPdfPageObjectDictionary**)d ata);

2767 }

2768

2769 bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfPageObjectDictionary** d ata) {

2770 if (PageObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2771 if (abr == NULL \|\| *abr == '\0') return false;

2772 return PageObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);

2773 }

2774

2775 bool isNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoOb j) {

2776 return true;

2777 }

2778

2779 bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDiction ary& dict, const char* key, SkPdfNameDictionary** data) {

2780 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2781 if (value == NULL) { return false; }

2782 if (data == NULL) { return true; }

2783 return mapNameDictionary(pdfDoc, value, (SkPdfNameDictionary**)data);

2784 }

2785

2786 bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDiction ary& dict, const char* key, const char* abr, SkPdfNameDictionary** data) {

2787 if (NameDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2788 if (abr == NULL \|\| *abr == '\0') return false;

2789 return NameDictionaryFromDictionary(pdfDoc, dict, abr, data);

2790 }

2791

2792 bool isResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj) {

2793 return true;

2794 }

2795

2796 bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, SkPdfResourceDictionary** data) {

2797 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2798 if (value == NULL) { return false; }

2799 if (data == NULL) { return true; }

2800 return mapResourceDictionary(pdfDoc, value, (SkPdfResourceDictionary**)data) ;

2801 }

2802

2803 bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, const char* abr, SkPdfResourceDictionary** data) {

2804 if (ResourceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2805 if (abr == NULL \|\| *abr == '\0') return false;

2806 return ResourceDictionaryFromDictionary(pdfDoc, dict, abr, data);

2807 }

2808

2809 bool isNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2810 return true;

2811 }

2812

2813 bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfNameTreeNodeDictionary** data) {

2814 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2815 if (value == NULL) { return false; }

2816 if (data == NULL) { return true; }

2817 return mapNameTreeNodeDictionary(pdfDoc, value, (SkPdfNameTreeNodeDictionary **)data);

2818 }

2819

2820 bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfNameTreeNodeDictionary ** data) {

2821 if (NameTreeNodeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

2822 if (abr == NULL \|\| *abr == '\0') return false;

2823 return NameTreeNodeDictionaryFromDictionary(pdfDoc, dict, abr, data);

2824 }

2825

2826 bool isNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

2827 return true;

2828 }

2829

2830 bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNumberTreeNodeDictionary** data) {

2831 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2832 if (value == NULL) { return false; }

2833 if (data == NULL) { return true; }

2834 return mapNumberTreeNodeDictionary(pdfDoc, value, (SkPdfNumberTreeNodeDictio nary**)data);

2835 }

2836

2837 bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNumberTreeNodeDictio nary** data) {

2838 if (NumberTreeNodeDictionaryFromDictionary(pdfDoc, dict, key, data)) return tr ue;

2839 if (abr == NULL \|\| *abr == '\0') return false;

2840 return NumberTreeNodeDictionaryFromDictionary(pdfDoc, dict, abr, data);

2841 }

2842

2843 bool isFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

2844 return true;

2845 }

2846

2847 bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFunctionCommonDictionary** data) {

2848 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2849 if (value == NULL) { return false; }

2850 if (data == NULL) { return true; }

2851 return mapFunctionCommonDictionary(pdfDoc, value, (SkPdfFunctionCommonDictio nary**)data);

2852 }

2853

2854 bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFunctionCommonDictio nary** data) {

2855 if (FunctionCommonDictionaryFromDictionary(pdfDoc, dict, key, data)) return tr ue;

2856 if (abr == NULL \|\| *abr == '\0') return false;

2857 return FunctionCommonDictionaryFromDictionary(pdfDoc, dict, abr, data);

2858 }

2859

2860 bool isType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2861 return true;

2862 }

2863

2864 bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfType0FunctionDictionary** data) {

2865 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2866 if (value == NULL) { return false; }

2867 if (data == NULL) { return true; }

2868 return mapType0FunctionDictionary(pdfDoc, value, (SkPdfType0FunctionDictiona ry**)data);

2869 }

2870

2871 bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfType0FunctionDictiona ry** data) {

2872 if (Type0FunctionDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

2873 if (abr == NULL \|\| *abr == '\0') return false;

2874 return Type0FunctionDictionaryFromDictionary(pdfDoc, dict, abr, data);

2875 }

2876

2877 bool isType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2878 return true;

2879 }

2880

2881 bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfType2FunctionDictionary** data) {

2882 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2883 if (value == NULL) { return false; }

2884 if (data == NULL) { return true; }

2885 return mapType2FunctionDictionary(pdfDoc, value, (SkPdfType2FunctionDictiona ry**)data);

2886 }

2887

2888 bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfType2FunctionDictiona ry** data) {

2889 if (Type2FunctionDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

2890 if (abr == NULL \|\| *abr == '\0') return false;

2891 return Type2FunctionDictionaryFromDictionary(pdfDoc, dict, abr, data);

2892 }

2893

2894 bool isType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2895 return true;

2896 }

2897

2898 bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfType3FunctionDictionary** data) {

2899 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2900 if (value == NULL) { return false; }

2901 if (data == NULL) { return true; }

2902 return mapType3FunctionDictionary(pdfDoc, value, (SkPdfType3FunctionDictiona ry**)data);

2903 }

2904

2905 bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfType3FunctionDictiona ry** data) {

2906 if (Type3FunctionDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

2907 if (abr == NULL \|\| *abr == '\0') return false;

2908 return Type3FunctionDictionaryFromDictionary(pdfDoc, dict, abr, data);

2909 }

2910

2911 bool isFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

2912 return true;

2913 }

2914

2915 bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfFileSpecificationDictionary** data ) {

2916 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2917 if (value == NULL) { return false; }

2918 if (data == NULL) { return true; }

2919 return mapFileSpecificationDictionary(pdfDoc, value, (SkPdfFileSpecification Dictionary**)data);

2920 }

2921

2922 bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfFileSpecification Dictionary** data) {

2923 if (FileSpecificationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

2924 if (abr == NULL \|\| *abr == '\0') return false;

2925 return FileSpecificationDictionaryFromDictionary(pdfDoc, dict, abr, data);

2926 }

2927

2928 bool isEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj) {

2929 return true;

2930 }

2931

2932 bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, co nst PdfDictionary& dict, const char* key, SkPdfEmbeddedFileStreamDictionary** da ta) {

2933 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2934 if (value == NULL) { return false; }

2935 if (data == NULL) { return true; }

2936 return mapEmbeddedFileStreamDictionary(pdfDoc, value, (SkPdfEmbeddedFileStre amDictionary**)data);

2937 }

2938

2939 bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, co nst PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileStre amDictionary** data) {

2940 if (EmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) retur n true;

2941 if (abr == NULL \|\| *abr == '\0') return false;

2942 return EmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);

2943 }

2944

2945 bool isEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const Pd fObject& podofoObj) {

2946 return true;

2947 }

2948

2949 bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFileParameterDictionar y** data) {

2950 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2951 if (value == NULL) { return false; }

2952 if (data == NULL) { return true; }

2953 return mapEmbeddedFileParameterDictionary(pdfDoc, value, (SkPdfEmbeddedFileP arameterDictionary**)data);

2954 }

2955

2956 bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileP arameterDictionary** data) {

2957 if (EmbeddedFileParameterDictionaryFromDictionary(pdfDoc, dict, key, data)) re turn true;

2958 if (abr == NULL \|\| *abr == '\0') return false;

2959 return EmbeddedFileParameterDictionaryFromDictionary(pdfDoc, dict, abr, data);

2960 }

2961

2962 bool isMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const Pdf Object& podofoObj) {

2963 return true;

2964 }

2965

2966 bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMacOsFileInformationDictionary* * data) {

2967 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2968 if (value == NULL) { return false; }

2969 if (data == NULL) { return true; }

2970 return mapMacOsFileInformationDictionary(pdfDoc, value, (SkPdfMacOsFileInfor mationDictionary**)data);

2971 }

2972

2973 bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMacOsFileInfor mationDictionary** data) {

2974 if (MacOsFileInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) ret urn true;

2975 if (abr == NULL \|\| *abr == '\0') return false;

2976 return MacOsFileInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);

2977 }

2978

2979 bool isGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

2980 return true;

2981 }

2982

2983 bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfGraphicsStateDictionary** data) {

2984 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

2985 if (value == NULL) { return false; }

2986 if (data == NULL) { return true; }

2987 return mapGraphicsStateDictionary(pdfDoc, value, (SkPdfGraphicsStateDictiona ry**)data);

2988 }

2989

2990 bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfGraphicsStateDictiona ry** data) {

2991 if (GraphicsStateDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

2992 if (abr == NULL \|\| *abr == '\0') return false;

2993 return GraphicsStateDictionaryFromDictionary(pdfDoc, dict, abr, data);

2994 }

2995

2996 bool isCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

2997 return true;

2998 }

2999

3000 bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfCalgrayColorSpaceDictionary** data ) {

3001 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3002 if (value == NULL) { return false; }

3003 if (data == NULL) { return true; }

3004 return mapCalgrayColorSpaceDictionary(pdfDoc, value, (SkPdfCalgrayColorSpace Dictionary**)data);

3005 }

3006

3007 bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfCalgrayColorSpace Dictionary** data) {

3008 if (CalgrayColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3009 if (abr == NULL \|\| *abr == '\0') return false;

3010 return CalgrayColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);

3011 }

3012

3013 bool isCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

3014 return true;

3015 }

3016

3017 bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfCalrgbColorSpaceDictionary** data) {

3018 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3019 if (value == NULL) { return false; }

3020 if (data == NULL) { return true; }

3021 return mapCalrgbColorSpaceDictionary(pdfDoc, value, (SkPdfCalrgbColorSpaceDi ctionary**)data);

3022 }

3023

3024 bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfCalrgbColorSpaceDi ctionary** data) {

3025 if (CalrgbColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3026 if (abr == NULL \|\| *abr == '\0') return false;

3027 return CalrgbColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);

3028 }

3029

3030 bool isLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3031 return true;

3032 }

3033

3034 bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfLabColorSpaceDictionary** data) {

3035 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3036 if (value == NULL) { return false; }

3037 if (data == NULL) { return true; }

3038 return mapLabColorSpaceDictionary(pdfDoc, value, (SkPdfLabColorSpaceDictiona ry**)data);

3039 }

3040

3041 bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfLabColorSpaceDictiona ry** data) {

3042 if (LabColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

3043 if (abr == NULL \|\| *abr == '\0') return false;

3044 return LabColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);

3045 }

3046

3047 bool isIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

3048 return true;

3049 }

3050

3051 bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfIccProfileStreamDictionary** data) {

3052 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3053 if (value == NULL) { return false; }

3054 if (data == NULL) { return true; }

3055 return mapIccProfileStreamDictionary(pdfDoc, value, (SkPdfIccProfileStreamDi ctionary**)data);

3056 }

3057

3058 bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfIccProfileStreamDi ctionary** data) {

3059 if (IccProfileStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3060 if (abr == NULL \|\| *abr == '\0') return false;

3061 return IccProfileStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);

3062 }

3063

3064 bool isDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

3065 return true;

3066 }

3067

3068 bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfDeviceNColorSpaceDictionary** data ) {

3069 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3070 if (value == NULL) { return false; }

3071 if (data == NULL) { return true; }

3072 return mapDeviceNColorSpaceDictionary(pdfDoc, value, (SkPdfDeviceNColorSpace Dictionary**)data);

3073 }

3074

3075 bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfDeviceNColorSpace Dictionary** data) {

3076 if (DeviceNColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3077 if (abr == NULL \|\| *abr == '\0') return false;

3078 return DeviceNColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);

3079 }

3080

3081 bool isType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3082 return true;

3083 }

3084

3085 bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfType1PatternDictionary** data) {

3086 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3087 if (value == NULL) { return false; }

3088 if (data == NULL) { return true; }

3089 return mapType1PatternDictionary(pdfDoc, value, (SkPdfType1PatternDictionary **)data);

3090 }

3091

3092 bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfType1PatternDictionary ** data) {

3093 if (Type1PatternDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

3094 if (abr == NULL \|\| *abr == '\0') return false;

3095 return Type1PatternDictionaryFromDictionary(pdfDoc, dict, abr, data);

3096 }

3097

3098 bool isType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3099 return true;

3100 }

3101

3102 bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfType2PatternDictionary** data) {

3103 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3104 if (value == NULL) { return false; }

3105 if (data == NULL) { return true; }

3106 return mapType2PatternDictionary(pdfDoc, value, (SkPdfType2PatternDictionary **)data);

3107 }

3108

3109 bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfType2PatternDictionary ** data) {

3110 if (Type2PatternDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

3111 if (abr == NULL \|\| *abr == '\0') return false;

3112 return Type2PatternDictionaryFromDictionary(pdfDoc, dict, abr, data);

3113 }

3114

3115 bool isShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podof oObj) {

3116 return true;

3117 }

3118

3119 bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, SkPdfShadingDictionary** data) {

3120 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3121 if (value == NULL) { return false; }

3122 if (data == NULL) { return true; }

3123 return mapShadingDictionary(pdfDoc, value, (SkPdfShadingDictionary**)data);

3124 }

3125

3126 bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, const char* abr, SkPdfShadingDictionary** data) {

3127 if (ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3128 if (abr == NULL \|\| *abr == '\0') return false;

3129 return ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);

3130 }

3131

3132 bool isType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3133 return true;

3134 }

3135

3136 bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfType1ShadingDictionary** data) {

3137 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3138 if (value == NULL) { return false; }

3139 if (data == NULL) { return true; }

3140 return mapType1ShadingDictionary(pdfDoc, value, (SkPdfType1ShadingDictionary **)data);

3141 }

3142

3143 bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfType1ShadingDictionary ** data) {

3144 if (Type1ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

3145 if (abr == NULL \|\| *abr == '\0') return false;

3146 return Type1ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);

3147 }

3148

3149 bool isType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3150 return true;

3151 }

3152

3153 bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfType2ShadingDictionary** data) {

3154 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3155 if (value == NULL) { return false; }

3156 if (data == NULL) { return true; }

3157 return mapType2ShadingDictionary(pdfDoc, value, (SkPdfType2ShadingDictionary **)data);

3158 }

3159

3160 bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfType2ShadingDictionary ** data) {

3161 if (Type2ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

3162 if (abr == NULL \|\| *abr == '\0') return false;

3163 return Type2ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);

3164 }

3165

3166 bool isType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3167 return true;

3168 }

3169

3170 bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfType3ShadingDictionary** data) {

3171 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3172 if (value == NULL) { return false; }

3173 if (data == NULL) { return true; }

3174 return mapType3ShadingDictionary(pdfDoc, value, (SkPdfType3ShadingDictionary **)data);

3175 }

3176

3177 bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfType3ShadingDictionary ** data) {

3178 if (Type3ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

3179 if (abr == NULL \|\| *abr == '\0') return false;

3180 return Type3ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);

3181 }

3182

3183 bool isType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3184 return true;

3185 }

3186

3187 bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfType4ShadingDictionary** data) {

3188 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3189 if (value == NULL) { return false; }

3190 if (data == NULL) { return true; }

3191 return mapType4ShadingDictionary(pdfDoc, value, (SkPdfType4ShadingDictionary **)data);

3192 }

3193

3194 bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfType4ShadingDictionary ** data) {

3195 if (Type4ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

3196 if (abr == NULL \|\| *abr == '\0') return false;

3197 return Type4ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);

3198 }

3199

3200 bool isType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3201 return true;

3202 }

3203

3204 bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfType5ShadingDictionary** data) {

3205 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3206 if (value == NULL) { return false; }

3207 if (data == NULL) { return true; }

3208 return mapType5ShadingDictionary(pdfDoc, value, (SkPdfType5ShadingDictionary **)data);

3209 }

3210

3211 bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfType5ShadingDictionary ** data) {

3212 if (Type5ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

3213 if (abr == NULL \|\| *abr == '\0') return false;

3214 return Type5ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);

3215 }

3216

3217 bool isType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3218 return true;

3219 }

3220

3221 bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfType6ShadingDictionary** data) {

3222 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3223 if (value == NULL) { return false; }

3224 if (data == NULL) { return true; }

3225 return mapType6ShadingDictionary(pdfDoc, value, (SkPdfType6ShadingDictionary **)data);

3226 }

3227

3228 bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfType6ShadingDictionary ** data) {

3229 if (Type6ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

3230 if (abr == NULL \|\| *abr == '\0') return false;

3231 return Type6ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);

3232 }

3233

3234 bool isImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoO bj) {

3235 std::string Subtype;

3236 if (!podofoObj.IsDictionary()) return false;

3237 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;

3238 if ((Subtype != "Image")) return false;

3239

3240 return true;

3241 }

3242

3243 bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictio nary& dict, const char* key, SkPdfImageDictionary** data) {

3244 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3245 if (value == NULL) { return false; }

3246 if (data == NULL) { return true; }

3247 return mapImageDictionary(pdfDoc, value, (SkPdfImageDictionary**)data);

3248 }

3249

3250 bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictio nary& dict, const char* key, const char* abr, SkPdfImageDictionary** data) {

3251 if (ImageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3252 if (abr == NULL \|\| *abr == '\0') return false;

3253 return ImageDictionaryFromDictionary(pdfDoc, dict, abr, data);

3254 }

3255

3256 bool isAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

3257 return true;

3258 }

3259

3260 bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAlternateImageDictionary** data) {

3261 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3262 if (value == NULL) { return false; }

3263 if (data == NULL) { return true; }

3264 return mapAlternateImageDictionary(pdfDoc, value, (SkPdfAlternateImageDictio nary**)data);

3265 }

3266

3267 bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAlternateImageDictio nary** data) {

3268 if (AlternateImageDictionaryFromDictionary(pdfDoc, dict, key, data)) return tr ue;

3269 if (abr == NULL \|\| *abr == '\0') return false;

3270 return AlternateImageDictionaryFromDictionary(pdfDoc, dict, abr, data);

3271 }

3272

3273 bool isType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

3274 std::string Subtype;

3275 if (!podofoObj.IsDictionary()) return false;

3276 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;

3277 if ((Subtype != "Form")) return false;

3278

3279 return true;

3280 }

3281

3282 bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfType1FormDictionary** data) {

3283 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3284 if (value == NULL) { return false; }

3285 if (data == NULL) { return true; }

3286 return mapType1FormDictionary(pdfDoc, value, (SkPdfType1FormDictionary**)dat a);

3287 }

3288

3289 bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfType1FormDictionary** dat a) {

3290 if (Type1FormDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3291 if (abr == NULL \|\| *abr == '\0') return false;

3292 return Type1FormDictionaryFromDictionary(pdfDoc, dict, abr, data);

3293 }

3294

3295 bool isGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

3296 return true;

3297 }

3298

3299 bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGroupAttributesDictionary** data) {

3300 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3301 if (value == NULL) { return false; }

3302 if (data == NULL) { return true; }

3303 return mapGroupAttributesDictionary(pdfDoc, value, (SkPdfGroupAttributesDict ionary**)data);

3304 }

3305

3306 bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGroupAttributesDict ionary** data) {

3307 if (GroupAttributesDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

3308 if (abr == NULL \|\| *abr == '\0') return false;

3309 return GroupAttributesDictionaryFromDictionary(pdfDoc, dict, abr, data);

3310 }

3311

3312 bool isReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

3313 return true;

3314 }

3315

3316 bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfReferenceDictionary** data) {

3317 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3318 if (value == NULL) { return false; }

3319 if (data == NULL) { return true; }

3320 return mapReferenceDictionary(pdfDoc, value, (SkPdfReferenceDictionary**)dat a);

3321 }

3322

3323 bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfReferenceDictionary** dat a) {

3324 if (ReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3325 if (abr == NULL \|\| *abr == '\0') return false;

3326 return ReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);

3327 }

3328

3329 bool isPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

3330 return true;

3331 }

3332

3333 bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfPSXobjectDictionary** data) {

3334 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3335 if (value == NULL) { return false; }

3336 if (data == NULL) { return true; }

3337 return mapPSXobjectDictionary(pdfDoc, value, (SkPdfPSXobjectDictionary**)dat a);

3338 }

3339

3340 bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfPSXobjectDictionary** dat a) {

3341 if (PSXobjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3342 if (abr == NULL \|\| *abr == '\0') return false;

3343 return PSXobjectDictionaryFromDictionary(pdfDoc, dict, abr, data);

3344 }

3345

3346 bool isType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

3347 std::string Subtype;

3348 if (!podofoObj.IsDictionary()) return false;

3349 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;

3350 if ((Subtype != "MMType1") && (Subtype != "TrueType") && (Subtype != "Type3") && (Subtype != "Type1")) return false;

3351

3352 return true;

3353 }

3354

3355 bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfType1FontDictionary** data) {

3356 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3357 if (value == NULL) { return false; }

3358 if (data == NULL) { return true; }

3359 return mapType1FontDictionary(pdfDoc, value, (SkPdfType1FontDictionary**)dat a);

3360 }

3361

3362 bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfType1FontDictionary** dat a) {

3363 if (Type1FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3364 if (abr == NULL \|\| *abr == '\0') return false;

3365 return Type1FontDictionaryFromDictionary(pdfDoc, dict, abr, data);

3366 }

3367

3368 bool isType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

3369 std::string Subtype;

3370 if (!podofoObj.IsDictionary()) return false;

3371 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;

3372 if ((Subtype != "Type3")) return false;

3373

3374 return true;

3375 }

3376

3377 bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfType3FontDictionary** data) {

3378 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3379 if (value == NULL) { return false; }

3380 if (data == NULL) { return true; }

3381 return mapType3FontDictionary(pdfDoc, value, (SkPdfType3FontDictionary**)dat a);

3382 }

3383

3384 bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfType3FontDictionary** dat a) {

3385 if (Type3FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3386 if (abr == NULL \|\| *abr == '\0') return false;

3387 return Type3FontDictionaryFromDictionary(pdfDoc, dict, abr, data);

3388 }

3389

3390 bool isEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj) {

3391 return true;

3392 }

3393

3394 bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, SkPdfEncodingDictionary** data) {

3395 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3396 if (value == NULL) { return false; }

3397 if (data == NULL) { return true; }

3398 return mapEncodingDictionary(pdfDoc, value, (SkPdfEncodingDictionary**)data) ;

3399 }

3400

3401 bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, const char* abr, SkPdfEncodingDictionary** data) {

3402 if (EncodingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3403 if (abr == NULL \|\| *abr == '\0') return false;

3404 return EncodingDictionaryFromDictionary(pdfDoc, dict, abr, data);

3405 }

3406

3407 bool isCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3408 return true;

3409 }

3410

3411 bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfCIDSystemInfoDictionary** data) {

3412 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3413 if (value == NULL) { return false; }

3414 if (data == NULL) { return true; }

3415 return mapCIDSystemInfoDictionary(pdfDoc, value, (SkPdfCIDSystemInfoDictiona ry**)data);

3416 }

3417

3418 bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfCIDSystemInfoDictiona ry** data) {

3419 if (CIDSystemInfoDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

3420 if (abr == NULL \|\| *abr == '\0') return false;

3421 return CIDSystemInfoDictionaryFromDictionary(pdfDoc, dict, abr, data);

3422 }

3423

3424 bool isCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podof oObj) {

3425 std::string Subtype;

3426 if (!podofoObj.IsDictionary()) return false;

3427 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;

3428 if ((Subtype != "CIDFontType0") && (Subtype != "CIDFontType2")) return false;

3429

3430 return true;

3431 }

3432

3433 bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, SkPdfCIDFontDictionary** data) {

3434 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3435 if (value == NULL) { return false; }

3436 if (data == NULL) { return true; }

3437 return mapCIDFontDictionary(pdfDoc, value, (SkPdfCIDFontDictionary**)data);

3438 }

3439

3440 bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, const char* abr, SkPdfCIDFontDictionary** data) {

3441 if (CIDFontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3442 if (abr == NULL \|\| *abr == '\0') return false;

3443 return CIDFontDictionaryFromDictionary(pdfDoc, dict, abr, data);

3444 }

3445

3446 bool isCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoOb j) {

3447 return true;

3448 }

3449

3450 bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDiction ary& dict, const char* key, SkPdfCMapDictionary** data) {

3451 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3452 if (value == NULL) { return false; }

3453 if (data == NULL) { return true; }

3454 return mapCMapDictionary(pdfDoc, value, (SkPdfCMapDictionary**)data);

3455 }

3456

3457 bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDiction ary& dict, const char* key, const char* abr, SkPdfCMapDictionary** data) {

3458 if (CMapDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3459 if (abr == NULL \|\| *abr == '\0') return false;

3460 return CMapDictionaryFromDictionary(pdfDoc, dict, abr, data);

3461 }

3462

3463 bool isType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

3464 std::string Subtype;

3465 if (!podofoObj.IsDictionary()) return false;

3466 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;

3467 if ((Subtype != "Type0")) return false;

3468

3469 return true;

3470 }

3471

3472 bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfType0FontDictionary** data) {

3473 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3474 if (value == NULL) { return false; }

3475 if (data == NULL) { return true; }

3476 return mapType0FontDictionary(pdfDoc, value, (SkPdfType0FontDictionary**)dat a);

3477 }

3478

3479 bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfType0FontDictionary** dat a) {

3480 if (Type0FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3481 if (abr == NULL \|\| *abr == '\0') return false;

3482 return Type0FontDictionaryFromDictionary(pdfDoc, dict, abr, data);

3483 }

3484

3485 bool isFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

3486 std::string Type;

3487 if (!podofoObj.IsDictionary()) return false;

3488 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Type", "", &Ty pe)) return false;

3489 if ((Type != "FontDescriptor")) return false;

3490

3491 return true;

3492 }

3493

3494 bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFontDescriptorDictionary** data) {

3495 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3496 if (value == NULL) { return false; }

3497 if (data == NULL) { return true; }

3498 return mapFontDescriptorDictionary(pdfDoc, value, (SkPdfFontDescriptorDictio nary**)data);

3499 }

3500

3501 bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFontDescriptorDictio nary** data) {

3502 if (FontDescriptorDictionaryFromDictionary(pdfDoc, dict, key, data)) return tr ue;

3503 if (abr == NULL \|\| *abr == '\0') return false;

3504 return FontDescriptorDictionaryFromDictionary(pdfDoc, dict, abr, data);

3505 }

3506

3507 bool isCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

3508 return true;

3509 }

3510

3511 bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfCIDFontDescriptorDictionary** data ) {

3512 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3513 if (value == NULL) { return false; }

3514 if (data == NULL) { return true; }

3515 return mapCIDFontDescriptorDictionary(pdfDoc, value, (SkPdfCIDFontDescriptor Dictionary**)data);

3516 }

3517

3518 bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDFontDescriptor Dictionary** data) {

3519 if (CIDFontDescriptorDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3520 if (abr == NULL \|\| *abr == '\0') return false;

3521 return CIDFontDescriptorDictionaryFromDictionary(pdfDoc, dict, abr, data);

3522 }

3523

3524 bool isEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj) {

3525 return true;

3526 }

3527

3528 bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, co nst PdfDictionary& dict, const char* key, SkPdfEmbeddedFontStreamDictionary** da ta) {

3529 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3530 if (value == NULL) { return false; }

3531 if (data == NULL) { return true; }

3532 return mapEmbeddedFontStreamDictionary(pdfDoc, value, (SkPdfEmbeddedFontStre amDictionary**)data);

3533 }

3534

3535 bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, co nst PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFontStre amDictionary** data) {

3536 if (EmbeddedFontStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) retur n true;

3537 if (abr == NULL \|\| *abr == '\0') return false;

3538 return EmbeddedFontStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);

3539 }

3540

3541 bool isType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3542 return true;

3543 }

3544

3545 bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfType1HalftoneDictionary** data) {

3546 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3547 if (value == NULL) { return false; }

3548 if (data == NULL) { return true; }

3549 return mapType1HalftoneDictionary(pdfDoc, value, (SkPdfType1HalftoneDictiona ry**)data);

3550 }

3551

3552 bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfType1HalftoneDictiona ry** data) {

3553 if (Type1HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

3554 if (abr == NULL \|\| *abr == '\0') return false;

3555 return Type1HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);

3556 }

3557

3558 bool isType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3559 return true;

3560 }

3561

3562 bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfType6HalftoneDictionary** data) {

3563 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3564 if (value == NULL) { return false; }

3565 if (data == NULL) { return true; }

3566 return mapType6HalftoneDictionary(pdfDoc, value, (SkPdfType6HalftoneDictiona ry**)data);

3567 }

3568

3569 bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfType6HalftoneDictiona ry** data) {

3570 if (Type6HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

3571 if (abr == NULL \|\| *abr == '\0') return false;

3572 return Type6HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);

3573 }

3574

3575 bool isType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

3576 return true;

3577 }

3578

3579 bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType10HalftoneDictionary** data) {

3580 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3581 if (value == NULL) { return false; }

3582 if (data == NULL) { return true; }

3583 return mapType10HalftoneDictionary(pdfDoc, value, (SkPdfType10HalftoneDictio nary**)data);

3584 }

3585

3586 bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType10HalftoneDictio nary** data) {

3587 if (Type10HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return tr ue;

3588 if (abr == NULL \|\| *abr == '\0') return false;

3589 return Type10HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);

3590 }

3591

3592 bool isType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

3593 return true;

3594 }

3595

3596 bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType16HalftoneDictionary** data) {

3597 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3598 if (value == NULL) { return false; }

3599 if (data == NULL) { return true; }

3600 return mapType16HalftoneDictionary(pdfDoc, value, (SkPdfType16HalftoneDictio nary**)data);

3601 }

3602

3603 bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType16HalftoneDictio nary** data) {

3604 if (Type16HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return tr ue;

3605 if (abr == NULL \|\| *abr == '\0') return false;

3606 return Type16HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);

3607 }

3608

3609 bool isType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3610 return true;

3611 }

3612

3613 bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfType5HalftoneDictionary** data) {

3614 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3615 if (value == NULL) { return false; }

3616 if (data == NULL) { return true; }

3617 return mapType5HalftoneDictionary(pdfDoc, value, (SkPdfType5HalftoneDictiona ry**)data);

3618 }

3619

3620 bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfType5HalftoneDictiona ry** data) {

3621 if (Type5HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

3622 if (abr == NULL \|\| *abr == '\0') return false;

3623 return Type5HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);

3624 }

3625

3626 bool isSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj) {

3627 return true;

3628 }

3629

3630 bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, SkPdfSoftMaskDictionary** data) {

3631 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3632 if (value == NULL) { return false; }

3633 if (data == NULL) { return true; }

3634 return mapSoftMaskDictionary(pdfDoc, value, (SkPdfSoftMaskDictionary**)data) ;

3635 }

3636

3637 bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, const char* abr, SkPdfSoftMaskDictionary** data) {

3638 if (SoftMaskDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3639 if (abr == NULL \|\| *abr == '\0') return false;

3640 return SoftMaskDictionaryFromDictionary(pdfDoc, dict, abr, data);

3641 }

3642

3643 bool isSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3644 return true;

3645 }

3646

3647 bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfSoftMaskImageDictionary** data) {

3648 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3649 if (value == NULL) { return false; }

3650 if (data == NULL) { return true; }

3651 return mapSoftMaskImageDictionary(pdfDoc, value, (SkPdfSoftMaskImageDictiona ry**)data);

3652 }

3653

3654 bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfSoftMaskImageDictiona ry** data) {

3655 if (SoftMaskImageDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

3656 if (abr == NULL \|\| *abr == '\0') return false;

3657 return SoftMaskImageDictionaryFromDictionary(pdfDoc, dict, abr, data);

3658 }

3659

3660 bool isTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

3661 return true;

3662 }

3663

3664 bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfTransparencyGroupDictionary** data ) {

3665 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3666 if (value == NULL) { return false; }

3667 if (data == NULL) { return true; }

3668 return mapTransparencyGroupDictionary(pdfDoc, value, (SkPdfTransparencyGroup Dictionary**)data);

3669 }

3670

3671 bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfTransparencyGroup Dictionary** data) {

3672 if (TransparencyGroupDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3673 if (abr == NULL \|\| *abr == '\0') return false;

3674 return TransparencyGroupDictionaryFromDictionary(pdfDoc, dict, abr, data);

3675 }

3676

3677 bool isViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

3678 return true;

3679 }

3680

3681 bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfViewerPreferencesDictionary** data ) {

3682 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3683 if (value == NULL) { return false; }

3684 if (data == NULL) { return true; }

3685 return mapViewerPreferencesDictionary(pdfDoc, value, (SkPdfViewerPreferences Dictionary**)data);

3686 }

3687

3688 bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfViewerPreferences Dictionary** data) {

3689 if (ViewerPreferencesDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3690 if (abr == NULL \|\| *abr == '\0') return false;

3691 return ViewerPreferencesDictionaryFromDictionary(pdfDoc, dict, abr, data);

3692 }

3693

3694 bool isOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podof oObj) {

3695 return true;

3696 }

3697

3698 bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, SkPdfOutlineDictionary** data) {

3699 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3700 if (value == NULL) { return false; }

3701 if (data == NULL) { return true; }

3702 return mapOutlineDictionary(pdfDoc, value, (SkPdfOutlineDictionary**)data);

3703 }

3704

3705 bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, const char* abr, SkPdfOutlineDictionary** data) {

3706 if (OutlineDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3707 if (abr == NULL \|\| *abr == '\0') return false;

3708 return OutlineDictionaryFromDictionary(pdfDoc, dict, abr, data);

3709 }

3710

3711 bool isOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj) {

3712 return true;

3713 }

3714

3715 bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, SkPdfOutlineItemDictionary** data) {

3716 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3717 if (value == NULL) { return false; }

3718 if (data == NULL) { return true; }

3719 return mapOutlineItemDictionary(pdfDoc, value, (SkPdfOutlineItemDictionary** )data);

3720 }

3721

3722 bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, const char* abr, SkPdfOutlineItemDictionary** data) {

3723 if (OutlineItemDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3724 if (abr == NULL \|\| *abr == '\0') return false;

3725 return OutlineItemDictionaryFromDictionary(pdfDoc, dict, abr, data);

3726 }

3727

3728 bool isPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

3729 return true;

3730 }

3731

3732 bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfPageLabelDictionary** data) {

3733 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3734 if (value == NULL) { return false; }

3735 if (data == NULL) { return true; }

3736 return mapPageLabelDictionary(pdfDoc, value, (SkPdfPageLabelDictionary**)dat a);

3737 }

3738

3739 bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfPageLabelDictionary** dat a) {

3740 if (PageLabelDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3741 if (abr == NULL \|\| *abr == '\0') return false;

3742 return PageLabelDictionaryFromDictionary(pdfDoc, dict, abr, data);

3743 }

3744

3745 bool isThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofo Obj) {

3746 return true;

3747 }

3748

3749 bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDicti onary& dict, const char* key, SkPdfThreadDictionary** data) {

3750 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3751 if (value == NULL) { return false; }

3752 if (data == NULL) { return true; }

3753 return mapThreadDictionary(pdfDoc, value, (SkPdfThreadDictionary**)data);

3754 }

3755

3756 bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDicti onary& dict, const char* key, const char* abr, SkPdfThreadDictionary** data) {

3757 if (ThreadDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3758 if (abr == NULL \|\| *abr == '\0') return false;

3759 return ThreadDictionaryFromDictionary(pdfDoc, dict, abr, data);

3760 }

3761

3762 bool isBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoOb j) {

3763 return true;

3764 }

3765

3766 bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDiction ary& dict, const char* key, SkPdfBeadDictionary** data) {

3767 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3768 if (value == NULL) { return false; }

3769 if (data == NULL) { return true; }

3770 return mapBeadDictionary(pdfDoc, value, (SkPdfBeadDictionary**)data);

3771 }

3772

3773 bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDiction ary& dict, const char* key, const char* abr, SkPdfBeadDictionary** data) {

3774 if (BeadDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3775 if (abr == NULL \|\| *abr == '\0') return false;

3776 return BeadDictionaryFromDictionary(pdfDoc, dict, abr, data);

3777 }

3778

3779 bool isTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

3780 return true;

3781 }

3782

3783 bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfTransitionDictionary** data) {

3784 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3785 if (value == NULL) { return false; }

3786 if (data == NULL) { return true; }

3787 return mapTransitionDictionary(pdfDoc, value, (SkPdfTransitionDictionary**)d ata);

3788 }

3789

3790 bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfTransitionDictionary** d ata) {

3791 if (TransitionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3792 if (abr == NULL \|\| *abr == '\0') return false;

3793 return TransitionDictionaryFromDictionary(pdfDoc, dict, abr, data);

3794 }

3795

3796 bool isAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

3797 return true;

3798 }

3799

3800 bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfAnnotationDictionary** data) {

3801 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3802 if (value == NULL) { return false; }

3803 if (data == NULL) { return true; }

3804 return mapAnnotationDictionary(pdfDoc, value, (SkPdfAnnotationDictionary**)d ata);

3805 }

3806

3807 bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfAnnotationDictionary** d ata) {

3808 if (AnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3809 if (abr == NULL \|\| *abr == '\0') return false;

3810 return AnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

3811 }

3812

3813 bool isBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj) {

3814 return true;

3815 }

3816

3817 bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, SkPdfBorderStyleDictionary** data) {

3818 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3819 if (value == NULL) { return false; }

3820 if (data == NULL) { return true; }

3821 return mapBorderStyleDictionary(pdfDoc, value, (SkPdfBorderStyleDictionary** )data);

3822 }

3823

3824 bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, const char* abr, SkPdfBorderStyleDictionary** data) {

3825 if (BorderStyleDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3826 if (abr == NULL \|\| *abr == '\0') return false;

3827 return BorderStyleDictionaryFromDictionary(pdfDoc, dict, abr, data);

3828 }

3829

3830 bool isAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

3831 return true;

3832 }

3833

3834 bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfAppearanceDictionary** data) {

3835 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3836 if (value == NULL) { return false; }

3837 if (data == NULL) { return true; }

3838 return mapAppearanceDictionary(pdfDoc, value, (SkPdfAppearanceDictionary**)d ata);

3839 }

3840

3841 bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfAppearanceDictionary** d ata) {

3842 if (AppearanceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3843 if (abr == NULL \|\| *abr == '\0') return false;

3844 return AppearanceDictionaryFromDictionary(pdfDoc, dict, abr, data);

3845 }

3846

3847 bool isTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

3848 return true;

3849 }

3850

3851 bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTextAnnotationDictionary** data) {

3852 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3853 if (value == NULL) { return false; }

3854 if (data == NULL) { return true; }

3855 return mapTextAnnotationDictionary(pdfDoc, value, (SkPdfTextAnnotationDictio nary**)data);

3856 }

3857

3858 bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTextAnnotationDictio nary** data) {

3859 if (TextAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return tr ue;

3860 if (abr == NULL \|\| *abr == '\0') return false;

3861 return TextAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

3862 }

3863

3864 bool isALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

3865 return true;

3866 }

3867

3868 bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfALinkAnnotationDictionary** data) {

3869 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3870 if (value == NULL) { return false; }

3871 if (data == NULL) { return true; }

3872 return mapALinkAnnotationDictionary(pdfDoc, value, (SkPdfALinkAnnotationDict ionary**)data);

3873 }

3874

3875 bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfALinkAnnotationDict ionary** data) {

3876 if (ALinkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

3877 if (abr == NULL \|\| *abr == '\0') return false;

3878 return ALinkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

3879 }

3880

3881 bool isFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj) {

3882 return true;

3883 }

3884

3885 bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, co nst PdfDictionary& dict, const char* key, SkPdfFreeTextAnnotationDictionary** da ta) {

3886 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3887 if (value == NULL) { return false; }

3888 if (data == NULL) { return true; }

3889 return mapFreeTextAnnotationDictionary(pdfDoc, value, (SkPdfFreeTextAnnotati onDictionary**)data);

3890 }

3891

3892 bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, co nst PdfDictionary& dict, const char* key, const char* abr, SkPdfFreeTextAnnotati onDictionary** data) {

3893 if (FreeTextAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) retur n true;

3894 if (abr == NULL \|\| *abr == '\0') return false;

3895 return FreeTextAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

3896 }

3897

3898 bool isLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

3899 return true;

3900 }

3901

3902 bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLineAnnotationDictionary** data) {

3903 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3904 if (value == NULL) { return false; }

3905 if (data == NULL) { return true; }

3906 return mapLineAnnotationDictionary(pdfDoc, value, (SkPdfLineAnnotationDictio nary**)data);

3907 }

3908

3909 bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLineAnnotationDictio nary** data) {

3910 if (LineAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return tr ue;

3911 if (abr == NULL \|\| *abr == '\0') return false;

3912 return LineAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

3913 }

3914

3915 bool isSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

3916 return true;

3917 }

3918

3919 bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSquareOrCircleAnnotation** data) {

3920 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3921 if (value == NULL) { return false; }

3922 if (data == NULL) { return true; }

3923 return mapSquareOrCircleAnnotation(pdfDoc, value, (SkPdfSquareOrCircleAnnota tion**)data);

3924 }

3925

3926 bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSquareOrCircleAnnota tion** data) {

3927 if (SquareOrCircleAnnotationFromDictionary(pdfDoc, dict, key, data)) return tr ue;

3928 if (abr == NULL \|\| *abr == '\0') return false;

3929 return SquareOrCircleAnnotationFromDictionary(pdfDoc, dict, abr, data);

3930 }

3931

3932 bool isMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

3933 return true;

3934 }

3935

3936 bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfMarkupAnnotationsDictionary** data ) {

3937 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3938 if (value == NULL) { return false; }

3939 if (data == NULL) { return true; }

3940 return mapMarkupAnnotationsDictionary(pdfDoc, value, (SkPdfMarkupAnnotations Dictionary**)data);

3941 }

3942

3943 bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkupAnnotations Dictionary** data) {

3944 if (MarkupAnnotationsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

3945 if (abr == NULL \|\| *abr == '\0') return false;

3946 return MarkupAnnotationsDictionaryFromDictionary(pdfDoc, dict, abr, data);

3947 }

3948

3949 bool isRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const Pd fObject& podofoObj) {

3950 return true;

3951 }

3952

3953 bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRubberStampAnnotationDictionar y** data) {

3954 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3955 if (value == NULL) { return false; }

3956 if (data == NULL) { return true; }

3957 return mapRubberStampAnnotationDictionary(pdfDoc, value, (SkPdfRubberStampAn notationDictionary**)data);

3958 }

3959

3960 bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRubberStampAn notationDictionary** data) {

3961 if (RubberStampAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) re turn true;

3962 if (abr == NULL \|\| *abr == '\0') return false;

3963 return RubberStampAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

3964 }

3965

3966 bool isInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

3967 return true;

3968 }

3969

3970 bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfInkAnnotationDictionary** data) {

3971 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3972 if (value == NULL) { return false; }

3973 if (data == NULL) { return true; }

3974 return mapInkAnnotationDictionary(pdfDoc, value, (SkPdfInkAnnotationDictiona ry**)data);

3975 }

3976

3977 bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfInkAnnotationDictiona ry** data) {

3978 if (InkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

3979 if (abr == NULL \|\| *abr == '\0') return false;

3980 return InkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

3981 }

3982

3983 bool isPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

3984 return true;

3985 }

3986

3987 bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPopUpAnnotationDictionary** data) {

3988 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

3989 if (value == NULL) { return false; }

3990 if (data == NULL) { return true; }

3991 return mapPopUpAnnotationDictionary(pdfDoc, value, (SkPdfPopUpAnnotationDict ionary**)data);

3992 }

3993

3994 bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPopUpAnnotationDict ionary** data) {

3995 if (PopUpAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

3996 if (abr == NULL \|\| *abr == '\0') return false;

3997 return PopUpAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

3998 }

3999

4000 bool isFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

4001 return true;

4002 }

4003

4004 bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfD oc, const PdfDictionary& dict, const char* key, SkPdfFileAttachmentAnnotationDic tionary** data) {

4005 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4006 if (value == NULL) { return false; }

4007 if (data == NULL) { return true; }

4008 return mapFileAttachmentAnnotationDictionary(pdfDoc, value, (SkPdfFileAttach mentAnnotationDictionary**)data);

4009 }

4010

4011 bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfD oc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileAttach mentAnnotationDictionary** data) {

4012 if (FileAttachmentAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4013 if (abr == NULL \|\| *abr == '\0') return false;

4014 return FileAttachmentAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, dat a);

4015 }

4016

4017 bool isSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

4018 return true;

4019 }

4020

4021 bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundAnnotationDictionary** data) {

4022 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4023 if (value == NULL) { return false; }

4024 if (data == NULL) { return true; }

4025 return mapSoundAnnotationDictionary(pdfDoc, value, (SkPdfSoundAnnotationDict ionary**)data);

4026 }

4027

4028 bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundAnnotationDict ionary** data) {

4029 if (SoundAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

4030 if (abr == NULL \|\| *abr == '\0') return false;

4031 return SoundAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

4032 }

4033

4034 bool isMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

4035 return true;

4036 }

4037

4038 bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieAnnotationDictionary** data) {

4039 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4040 if (value == NULL) { return false; }

4041 if (data == NULL) { return true; }

4042 return mapMovieAnnotationDictionary(pdfDoc, value, (SkPdfMovieAnnotationDict ionary**)data);

4043 }

4044

4045 bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieAnnotationDict ionary** data) {

4046 if (MovieAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

4047 if (abr == NULL \|\| *abr == '\0') return false;

4048 return MovieAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

4049 }

4050

4051 bool isWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

4052 return true;

4053 }

4054

4055 bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfWidgetAnnotationDictionary** data) {

4056 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4057 if (value == NULL) { return false; }

4058 if (data == NULL) { return true; }

4059 return mapWidgetAnnotationDictionary(pdfDoc, value, (SkPdfWidgetAnnotationDi ctionary**)data);

4060 }

4061

4062 bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfWidgetAnnotationDi ctionary** data) {

4063 if (WidgetAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4064 if (abr == NULL \|\| *abr == '\0') return false;

4065 return WidgetAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

4066 }

4067

4068 bool isActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofo Obj) {

4069 return true;

4070 }

4071

4072 bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDicti onary& dict, const char* key, SkPdfActionDictionary** data) {

4073 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4074 if (value == NULL) { return false; }

4075 if (data == NULL) { return true; }

4076 return mapActionDictionary(pdfDoc, value, (SkPdfActionDictionary**)data);

4077 }

4078

4079 bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDicti onary& dict, const char* key, const char* abr, SkPdfActionDictionary** data) {

4080 if (ActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4081 if (abr == NULL \|\| *abr == '\0') return false;

4082 return ActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4083 }

4084

4085 bool isAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

4086 return true;

4087 }

4088

4089 bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfAnnotationActionsDictionary** data ) {

4090 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4091 if (value == NULL) { return false; }

4092 if (data == NULL) { return true; }

4093 return mapAnnotationActionsDictionary(pdfDoc, value, (SkPdfAnnotationActions Dictionary**)data);

4094 }

4095

4096 bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfAnnotationActions Dictionary** data) {

4097 if (AnnotationActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4098 if (abr == NULL \|\| *abr == '\0') return false;

4099 return AnnotationActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);

4100 }

4101

4102 bool isPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

4103 return true;

4104 }

4105

4106 bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfPageObjectActionsDictionary** data ) {

4107 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4108 if (value == NULL) { return false; }

4109 if (data == NULL) { return true; }

4110 return mapPageObjectActionsDictionary(pdfDoc, value, (SkPdfPageObjectActions Dictionary**)data);

4111 }

4112

4113 bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfPageObjectActions Dictionary** data) {

4114 if (PageObjectActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4115 if (abr == NULL \|\| *abr == '\0') return false;

4116 return PageObjectActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);

4117 }

4118

4119 bool isFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

4120 return true;

4121 }

4122

4123 bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfFormFieldActionsDictionary** data) {

4124 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4125 if (value == NULL) { return false; }

4126 if (data == NULL) { return true; }

4127 return mapFormFieldActionsDictionary(pdfDoc, value, (SkPdfFormFieldActionsDi ctionary**)data);

4128 }

4129

4130 bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfFormFieldActionsDi ctionary** data) {

4131 if (FormFieldActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4132 if (abr == NULL \|\| *abr == '\0') return false;

4133 return FormFieldActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);

4134 }

4135

4136 bool isDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj) {

4137 return true;

4138 }

4139

4140 bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc , const PdfDictionary& dict, const char* key, SkPdfDocumentCatalogActionsDiction ary** data) {

4141 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4142 if (value == NULL) { return false; }

4143 if (data == NULL) { return true; }

4144 return mapDocumentCatalogActionsDictionary(pdfDoc, value, (SkPdfDocumentCata logActionsDictionary**)data);

4145 }

4146

4147 bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc , const PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentCata logActionsDictionary** data) {

4148 if (DocumentCatalogActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) r eturn true;

4149 if (abr == NULL \|\| *abr == '\0') return false;

4150 return DocumentCatalogActionsDictionaryFromDictionary(pdfDoc, dict, abr, data) ;

4151 }

4152

4153 bool isGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

4154 return true;

4155 }

4156

4157 bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfGoToActionDictionary** data) {

4158 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4159 if (value == NULL) { return false; }

4160 if (data == NULL) { return true; }

4161 return mapGoToActionDictionary(pdfDoc, value, (SkPdfGoToActionDictionary**)d ata);

4162 }

4163

4164 bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfGoToActionDictionary** d ata) {

4165 if (GoToActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4166 if (abr == NULL \|\| *abr == '\0') return false;

4167 return GoToActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4168 }

4169

4170 bool isRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

4171 return true;

4172 }

4173

4174 bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfRemoteGoToActionDictionary** data) {

4175 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4176 if (value == NULL) { return false; }

4177 if (data == NULL) { return true; }

4178 return mapRemoteGoToActionDictionary(pdfDoc, value, (SkPdfRemoteGoToActionDi ctionary**)data);

4179 }

4180

4181 bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfRemoteGoToActionDi ctionary** data) {

4182 if (RemoteGoToActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4183 if (abr == NULL \|\| *abr == '\0') return false;

4184 return RemoteGoToActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4185 }

4186

4187 bool isLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

4188 return true;

4189 }

4190

4191 bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfLaunchActionDictionary** data) {

4192 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4193 if (value == NULL) { return false; }

4194 if (data == NULL) { return true; }

4195 return mapLaunchActionDictionary(pdfDoc, value, (SkPdfLaunchActionDictionary **)data);

4196 }

4197

4198 bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfLaunchActionDictionary ** data) {

4199 if (LaunchActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

4200 if (abr == NULL \|\| *abr == '\0') return false;

4201 return LaunchActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4202 }

4203

4204 bool isWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfO bject& podofoObj) {

4205 return true;

4206 }

4207

4208 bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, c onst PdfDictionary& dict, const char* key, SkPdfWindowsLaunchActionDictionary** data) {

4209 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4210 if (value == NULL) { return false; }

4211 if (data == NULL) { return true; }

4212 return mapWindowsLaunchActionDictionary(pdfDoc, value, (SkPdfWindowsLaunchAc tionDictionary**)data);

4213 }

4214

4215 bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, c onst PdfDictionary& dict, const char* key, const char* abr, SkPdfWindowsLaunchAc tionDictionary** data) {

4216 if (WindowsLaunchActionDictionaryFromDictionary(pdfDoc, dict, key, data)) retu rn true;

4217 if (abr == NULL \|\| *abr == '\0') return false;

4218 return WindowsLaunchActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4219 }

4220

4221 bool isThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

4222 return true;

4223 }

4224

4225 bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfThreadActionDictionary** data) {

4226 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4227 if (value == NULL) { return false; }

4228 if (data == NULL) { return true; }

4229 return mapThreadActionDictionary(pdfDoc, value, (SkPdfThreadActionDictionary **)data);

4230 }

4231

4232 bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfThreadActionDictionary ** data) {

4233 if (ThreadActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

4234 if (abr == NULL \|\| *abr == '\0') return false;

4235 return ThreadActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4236 }

4237

4238 bool isURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

4239 return true;

4240 }

4241

4242 bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfURIActionDictionary** data) {

4243 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4244 if (value == NULL) { return false; }

4245 if (data == NULL) { return true; }

4246 return mapURIActionDictionary(pdfDoc, value, (SkPdfURIActionDictionary**)dat a);

4247 }

4248

4249 bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfURIActionDictionary** dat a) {

4250 if (URIActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4251 if (abr == NULL \|\| *abr == '\0') return false;

4252 return URIActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4253 }

4254

4255 bool isURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj ) {

4256 return true;

4257 }

4258

4259 bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictiona ry& dict, const char* key, SkPdfURIDictionary** data) {

4260 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4261 if (value == NULL) { return false; }

4262 if (data == NULL) { return true; }

4263 return mapURIDictionary(pdfDoc, value, (SkPdfURIDictionary**)data);

4264 }

4265

4266 bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictiona ry& dict, const char* key, const char* abr, SkPdfURIDictionary** data) {

4267 if (URIDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4268 if (abr == NULL \|\| *abr == '\0') return false;

4269 return URIDictionaryFromDictionary(pdfDoc, dict, abr, data);

4270 }

4271

4272 bool isSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj) {

4273 return true;

4274 }

4275

4276 bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, SkPdfSoundActionDictionary** data) {

4277 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4278 if (value == NULL) { return false; }

4279 if (data == NULL) { return true; }

4280 return mapSoundActionDictionary(pdfDoc, value, (SkPdfSoundActionDictionary** )data);

4281 }

4282

4283 bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, const char* abr, SkPdfSoundActionDictionary** data) {

4284 if (SoundActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4285 if (abr == NULL \|\| *abr == '\0') return false;

4286 return SoundActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4287 }

4288

4289 bool isMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj) {

4290 return true;

4291 }

4292

4293 bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, SkPdfMovieActionDictionary** data) {

4294 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4295 if (value == NULL) { return false; }

4296 if (data == NULL) { return true; }

4297 return mapMovieActionDictionary(pdfDoc, value, (SkPdfMovieActionDictionary** )data);

4298 }

4299

4300 bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, const char* abr, SkPdfMovieActionDictionary** data) {

4301 if (MovieActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4302 if (abr == NULL \|\| *abr == '\0') return false;

4303 return MovieActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4304 }

4305

4306 bool isHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

4307 return true;

4308 }

4309

4310 bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfHideActionDictionary** data) {

4311 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4312 if (value == NULL) { return false; }

4313 if (data == NULL) { return true; }

4314 return mapHideActionDictionary(pdfDoc, value, (SkPdfHideActionDictionary**)d ata);

4315 }

4316

4317 bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfHideActionDictionary** d ata) {

4318 if (HideActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4319 if (abr == NULL \|\| *abr == '\0') return false;

4320 return HideActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4321 }

4322

4323 bool isNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

4324 return true;

4325 }

4326

4327 bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, SkPdfNamedActionsDictionary** data) {

4328 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4329 if (value == NULL) { return false; }

4330 if (data == NULL) { return true; }

4331 return mapNamedActionsDictionary(pdfDoc, value, (SkPdfNamedActionsDictionary **)data);

4332 }

4333

4334 bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pd fDictionary& dict, const char* key, const char* abr, SkPdfNamedActionsDictionary ** data) {

4335 if (NamedActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true ;

4336 if (abr == NULL \|\| *abr == '\0') return false;

4337 return NamedActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);

4338 }

4339

4340 bool isInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

4341 return true;

4342 }

4343

4344 bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInteractiveFormDictionary** data) {

4345 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4346 if (value == NULL) { return false; }

4347 if (data == NULL) { return true; }

4348 return mapInteractiveFormDictionary(pdfDoc, value, (SkPdfInteractiveFormDict ionary**)data);

4349 }

4350

4351 bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInteractiveFormDict ionary** data) {

4352 if (InteractiveFormDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

4353 if (abr == NULL \|\| *abr == '\0') return false;

4354 return InteractiveFormDictionaryFromDictionary(pdfDoc, dict, abr, data);

4355 }

4356

4357 bool isFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoO bj) {

4358 return true;

4359 }

4360

4361 bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictio nary& dict, const char* key, SkPdfFieldDictionary** data) {

4362 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4363 if (value == NULL) { return false; }

4364 if (data == NULL) { return true; }

4365 return mapFieldDictionary(pdfDoc, value, (SkPdfFieldDictionary**)data);

4366 }

4367

4368 bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictio nary& dict, const char* key, const char* abr, SkPdfFieldDictionary** data) {

4369 if (FieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4370 if (abr == NULL \|\| *abr == '\0') return false;

4371 return FieldDictionaryFromDictionary(pdfDoc, dict, abr, data);

4372 }

4373

4374 bool isVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

4375 return true;

4376 }

4377

4378 bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfVariableTextFieldDictionary** data ) {

4379 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4380 if (value == NULL) { return false; }

4381 if (data == NULL) { return true; }

4382 return mapVariableTextFieldDictionary(pdfDoc, value, (SkPdfVariableTextField Dictionary**)data);

4383 }

4384

4385 bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfVariableTextField Dictionary** data) {

4386 if (VariableTextFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4387 if (abr == NULL \|\| *abr == '\0') return false;

4388 return VariableTextFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);

4389 }

4390

4391 bool isAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, cons t PdfObject& podofoObj) {

4392 return true;

4393 }

4394

4395 bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdf Doc, const PdfDictionary& dict, const char* key, SkPdfAppearanceCharacteristicsD ictionary** data) {

4396 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4397 if (value == NULL) { return false; }

4398 if (data == NULL) { return true; }

4399 return mapAppearanceCharacteristicsDictionary(pdfDoc, value, (SkPdfAppearanc eCharacteristicsDictionary**)data);

4400 }

4401

4402 bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdf Doc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAppearanc eCharacteristicsDictionary** data) {

4403 if (AppearanceCharacteristicsDictionaryFromDictionary(pdfDoc, dict, key, data) ) return true;

4404 if (abr == NULL \|\| *abr == '\0') return false;

4405 return AppearanceCharacteristicsDictionaryFromDictionary(pdfDoc, dict, abr, da ta);

4406 }

4407

4408 bool isCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

4409 return true;

4410 }

4411

4412 bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfCheckboxFieldDictionary** data) {

4413 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4414 if (value == NULL) { return false; }

4415 if (data == NULL) { return true; }

4416 return mapCheckboxFieldDictionary(pdfDoc, value, (SkPdfCheckboxFieldDictiona ry**)data);

4417 }

4418

4419 bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfCheckboxFieldDictiona ry** data) {

4420 if (CheckboxFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

4421 if (abr == NULL \|\| *abr == '\0') return false;

4422 return CheckboxFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);

4423 }

4424

4425 bool isRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

4426 return true;

4427 }

4428

4429 bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfRadioButtonFieldDictionary** data) {

4430 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4431 if (value == NULL) { return false; }

4432 if (data == NULL) { return true; }

4433 return mapRadioButtonFieldDictionary(pdfDoc, value, (SkPdfRadioButtonFieldDi ctionary**)data);

4434 }

4435

4436 bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfRadioButtonFieldDi ctionary** data) {

4437 if (RadioButtonFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4438 if (abr == NULL \|\| *abr == '\0') return false;

4439 return RadioButtonFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);

4440 }

4441

4442 bool isTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

4443 return true;

4444 }

4445

4446 bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfTextFieldDictionary** data) {

4447 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4448 if (value == NULL) { return false; }

4449 if (data == NULL) { return true; }

4450 return mapTextFieldDictionary(pdfDoc, value, (SkPdfTextFieldDictionary**)dat a);

4451 }

4452

4453 bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfTextFieldDictionary** dat a) {

4454 if (TextFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4455 if (abr == NULL \|\| *abr == '\0') return false;

4456 return TextFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);

4457 }

4458

4459 bool isChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj) {

4460 return true;

4461 }

4462

4463 bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, SkPdfChoiceFieldDictionary** data) {

4464 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4465 if (value == NULL) { return false; }

4466 if (data == NULL) { return true; }

4467 return mapChoiceFieldDictionary(pdfDoc, value, (SkPdfChoiceFieldDictionary** )data);

4468 }

4469

4470 bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, const char* abr, SkPdfChoiceFieldDictionary** data) {

4471 if (ChoiceFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4472 if (abr == NULL \|\| *abr == '\0') return false;

4473 return ChoiceFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);

4474 }

4475

4476 bool isSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

4477 return true;

4478 }

4479

4480 bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfSignatureDictionary** data) {

4481 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4482 if (value == NULL) { return false; }

4483 if (data == NULL) { return true; }

4484 return mapSignatureDictionary(pdfDoc, value, (SkPdfSignatureDictionary**)dat a);

4485 }

4486

4487 bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfSignatureDictionary** dat a) {

4488 if (SignatureDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4489 if (abr == NULL \|\| *abr == '\0') return false;

4490 return SignatureDictionaryFromDictionary(pdfDoc, dict, abr, data);

4491 }

4492

4493 bool isSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

4494 return true;

4495 }

4496

4497 bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfSubmitFormActionDictionary** data) {

4498 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4499 if (value == NULL) { return false; }

4500 if (data == NULL) { return true; }

4501 return mapSubmitFormActionDictionary(pdfDoc, value, (SkPdfSubmitFormActionDi ctionary**)data);

4502 }

4503

4504 bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfSubmitFormActionDi ctionary** data) {

4505 if (SubmitFormActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4506 if (abr == NULL \|\| *abr == '\0') return false;

4507 return SubmitFormActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4508 }

4509

4510 bool isResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

4511 return true;

4512 }

4513

4514 bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfResetFormActionDictionary** data) {

4515 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4516 if (value == NULL) { return false; }

4517 if (data == NULL) { return true; }

4518 return mapResetFormActionDictionary(pdfDoc, value, (SkPdfResetFormActionDict ionary**)data);

4519 }

4520

4521 bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfResetFormActionDict ionary** data) {

4522 if (ResetFormActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

4523 if (abr == NULL \|\| *abr == '\0') return false;

4524 return ResetFormActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4525 }

4526

4527 bool isImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

4528 return true;

4529 }

4530

4531 bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfImportDataActionDictionary** data) {

4532 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4533 if (value == NULL) { return false; }

4534 if (data == NULL) { return true; }

4535 return mapImportDataActionDictionary(pdfDoc, value, (SkPdfImportDataActionDi ctionary**)data);

4536 }

4537

4538 bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfImportDataActionDi ctionary** data) {

4539 if (ImportDataActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4540 if (abr == NULL \|\| *abr == '\0') return false;

4541 return ImportDataActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4542 }

4543

4544 bool isJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

4545 return true;

4546 }

4547

4548 bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfJavascriptActionDictionary** data) {

4549 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4550 if (value == NULL) { return false; }

4551 if (data == NULL) { return true; }

4552 return mapJavascriptActionDictionary(pdfDoc, value, (SkPdfJavascriptActionDi ctionary**)data);

4553 }

4554

4555 bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfJavascriptActionDi ctionary** data) {

4556 if (JavascriptActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4557 if (abr == NULL \|\| *abr == '\0') return false;

4558 return JavascriptActionDictionaryFromDictionary(pdfDoc, dict, abr, data);

4559 }

4560

4561 bool isFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

4562 return true;

4563 }

4564

4565 bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfFDFTrailerDictionary** data) {

4566 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4567 if (value == NULL) { return false; }

4568 if (data == NULL) { return true; }

4569 return mapFDFTrailerDictionary(pdfDoc, value, (SkPdfFDFTrailerDictionary**)d ata);

4570 }

4571

4572 bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfFDFTrailerDictionary** d ata) {

4573 if (FDFTrailerDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4574 if (abr == NULL \|\| *abr == '\0') return false;

4575 return FDFTrailerDictionaryFromDictionary(pdfDoc, dict, abr, data);

4576 }

4577

4578 bool isFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

4579 return true;

4580 }

4581

4582 bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfFDFCatalogDictionary** data) {

4583 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4584 if (value == NULL) { return false; }

4585 if (data == NULL) { return true; }

4586 return mapFDFCatalogDictionary(pdfDoc, value, (SkPdfFDFCatalogDictionary**)d ata);

4587 }

4588

4589 bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfFDFCatalogDictionary** d ata) {

4590 if (FDFCatalogDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4591 if (abr == NULL \|\| *abr == '\0') return false;

4592 return FDFCatalogDictionaryFromDictionary(pdfDoc, dict, abr, data);

4593 }

4594

4595 bool isFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj ) {

4596 return true;

4597 }

4598

4599 bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictiona ry& dict, const char* key, SkPdfFDFDictionary** data) {

4600 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4601 if (value == NULL) { return false; }

4602 if (data == NULL) { return true; }

4603 return mapFDFDictionary(pdfDoc, value, (SkPdfFDFDictionary**)data);

4604 }

4605

4606 bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictiona ry& dict, const char* key, const char* abr, SkPdfFDFDictionary** data) {

4607 if (FDFDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4608 if (abr == NULL \|\| *abr == '\0') return false;

4609 return FDFDictionaryFromDictionary(pdfDoc, dict, abr, data);

4610 }

4611

4612 bool isEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, co nst PdfObject& podofoObj) {

4613 return true;

4614 }

4615

4616 bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* p dfDoc, const PdfDictionary& dict, const char* key, SkPdfEncryptedEmbeddedFileStr eamDictionary** data) {

4617 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4618 if (value == NULL) { return false; }

4619 if (data == NULL) { return true; }

4620 return mapEncryptedEmbeddedFileStreamDictionary(pdfDoc, value, (SkPdfEncrypt edEmbeddedFileStreamDictionary**)data);

4621 }

4622

4623 bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* p dfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncrypt edEmbeddedFileStreamDictionary** data) {

4624 if (EncryptedEmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, key, dat a)) return true;

4625 if (abr == NULL \|\| *abr == '\0') return false;

4626 return EncryptedEmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);

4627 }

4628

4629 bool isJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

4630 return true;

4631 }

4632

4633 bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfJavascriptDictionary** data) {

4634 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4635 if (value == NULL) { return false; }

4636 if (data == NULL) { return true; }

4637 return mapJavascriptDictionary(pdfDoc, value, (SkPdfJavascriptDictionary**)d ata);

4638 }

4639

4640 bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfJavascriptDictionary** d ata) {

4641 if (JavascriptDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4642 if (abr == NULL \|\| *abr == '\0') return false;

4643 return JavascriptDictionaryFromDictionary(pdfDoc, dict, abr, data);

4644 }

4645

4646 bool isFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj) {

4647 return true;

4648 }

4649

4650 bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, SkPdfFDFFieldDictionary** data) {

4651 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4652 if (value == NULL) { return false; }

4653 if (data == NULL) { return true; }

4654 return mapFDFFieldDictionary(pdfDoc, value, (SkPdfFDFFieldDictionary**)data) ;

4655 }

4656

4657 bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, const char* abr, SkPdfFDFFieldDictionary** data) {

4658 if (FDFFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4659 if (abr == NULL \|\| *abr == '\0') return false;

4660 return FDFFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);

4661 }

4662

4663 bool isIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podof oObj) {

4664 return true;

4665 }

4666

4667 bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, SkPdfIconFitDictionary** data) {

4668 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4669 if (value == NULL) { return false; }

4670 if (data == NULL) { return true; }

4671 return mapIconFitDictionary(pdfDoc, value, (SkPdfIconFitDictionary**)data);

4672 }

4673

4674 bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, const char* abr, SkPdfIconFitDictionary** data) {

4675 if (IconFitDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4676 if (abr == NULL \|\| *abr == '\0') return false;

4677 return IconFitDictionaryFromDictionary(pdfDoc, dict, abr, data);

4678 }

4679

4680 bool isFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podof oObj) {

4681 return true;

4682 }

4683

4684 bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, SkPdfFDFPageDictionary** data) {

4685 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4686 if (value == NULL) { return false; }

4687 if (data == NULL) { return true; }

4688 return mapFDFPageDictionary(pdfDoc, value, (SkPdfFDFPageDictionary**)data);

4689 }

4690

4691 bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDict ionary& dict, const char* key, const char* abr, SkPdfFDFPageDictionary** data) {

4692 if (FDFPageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4693 if (abr == NULL \|\| *abr == '\0') return false;

4694 return FDFPageDictionaryFromDictionary(pdfDoc, dict, abr, data);

4695 }

4696

4697 bool isFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj) {

4698 return true;

4699 }

4700

4701 bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, SkPdfFDFTemplateDictionary** data) {

4702 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4703 if (value == NULL) { return false; }

4704 if (data == NULL) { return true; }

4705 return mapFDFTemplateDictionary(pdfDoc, value, (SkPdfFDFTemplateDictionary** )data);

4706 }

4707

4708 bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, const char* abr, SkPdfFDFTemplateDictionary** data) {

4709 if (FDFTemplateDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4710 if (abr == NULL \|\| *abr == '\0') return false;

4711 return FDFTemplateDictionaryFromDictionary(pdfDoc, dict, abr, data);

4712 }

4713

4714 bool isFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const Pd fObject& podofoObj) {

4715 return true;

4716 }

4717

4718 bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFNamedPageReferenceDictionar y** data) {

4719 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4720 if (value == NULL) { return false; }

4721 if (data == NULL) { return true; }

4722 return mapFDFNamedPageReferenceDictionary(pdfDoc, value, (SkPdfFDFNamedPageR eferenceDictionary**)data);

4723 }

4724

4725 bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFNamedPageR eferenceDictionary** data) {

4726 if (FDFNamedPageReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) re turn true;

4727 if (abr == NULL \|\| *abr == '\0') return false;

4728 return FDFNamedPageReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);

4729 }

4730

4731 bool isFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

4732 return true;

4733 }

4734

4735 bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfFDFFileAnnotationDictionary** data ) {

4736 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4737 if (value == NULL) { return false; }

4738 if (data == NULL) { return true; }

4739 return mapFDFFileAnnotationDictionary(pdfDoc, value, (SkPdfFDFFileAnnotation Dictionary**)data);

4740 }

4741

4742 bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFFileAnnotation Dictionary** data) {

4743 if (FDFFileAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4744 if (abr == NULL \|\| *abr == '\0') return false;

4745 return FDFFileAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

4746 }

4747

4748 bool isSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& p odofoObj) {

4749 return true;

4750 }

4751

4752 bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, SkPdfSoundObjectDictionary** data) {

4753 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4754 if (value == NULL) { return false; }

4755 if (data == NULL) { return true; }

4756 return mapSoundObjectDictionary(pdfDoc, value, (SkPdfSoundObjectDictionary** )data);

4757 }

4758

4759 bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const Pdf Dictionary& dict, const char* key, const char* abr, SkPdfSoundObjectDictionary** data) {

4760 if (SoundObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4761 if (abr == NULL \|\| *abr == '\0') return false;

4762 return SoundObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);

4763 }

4764

4765 bool isMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoO bj) {

4766 return true;

4767 }

4768

4769 bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictio nary& dict, const char* key, SkPdfMovieDictionary** data) {

4770 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4771 if (value == NULL) { return false; }

4772 if (data == NULL) { return true; }

4773 return mapMovieDictionary(pdfDoc, value, (SkPdfMovieDictionary**)data);

4774 }

4775

4776 bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictio nary& dict, const char* key, const char* abr, SkPdfMovieDictionary** data) {

4777 if (MovieDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4778 if (abr == NULL \|\| *abr == '\0') return false;

4779 return MovieDictionaryFromDictionary(pdfDoc, dict, abr, data);

4780 }

4781

4782 bool isMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

4783 return true;

4784 }

4785

4786 bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieActivationDictionary** data) {

4787 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4788 if (value == NULL) { return false; }

4789 if (data == NULL) { return true; }

4790 return mapMovieActivationDictionary(pdfDoc, value, (SkPdfMovieActivationDict ionary**)data);

4791 }

4792

4793 bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieActivationDict ionary** data) {

4794 if (MovieActivationDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

4795 if (abr == NULL \|\| *abr == '\0') return false;

4796 return MovieActivationDictionaryFromDictionary(pdfDoc, dict, abr, data);

4797 }

4798

4799 bool isDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfO bject& podofoObj) {

4800 return true;

4801 }

4802

4803 bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, c onst PdfDictionary& dict, const char* key, SkPdfDocumentInformationDictionary** data) {

4804 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4805 if (value == NULL) { return false; }

4806 if (data == NULL) { return true; }

4807 return mapDocumentInformationDictionary(pdfDoc, value, (SkPdfDocumentInforma tionDictionary**)data);

4808 }

4809

4810 bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, c onst PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentInforma tionDictionary** data) {

4811 if (DocumentInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) retu rn true;

4812 if (abr == NULL \|\| *abr == '\0') return false;

4813 return DocumentInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);

4814 }

4815

4816 bool isMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject & podofoObj) {

4817 return true;

4818 }

4819

4820 bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMetadataStreamDictionary** data) {

4821 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4822 if (value == NULL) { return false; }

4823 if (data == NULL) { return true; }

4824 return mapMetadataStreamDictionary(pdfDoc, value, (SkPdfMetadataStreamDictio nary**)data);

4825 }

4826

4827 bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMetadataStreamDictio nary** data) {

4828 if (MetadataStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return tr ue;

4829 if (abr == NULL \|\| *abr == '\0') return false;

4830 return MetadataStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);

4831 }

4832

4833 bool isComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj) {

4834 return true;

4835 }

4836

4837 bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc , const PdfDictionary& dict, const char* key, SkPdfComponentsWithMetadataDiction ary** data) {

4838 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4839 if (value == NULL) { return false; }

4840 if (data == NULL) { return true; }

4841 return mapComponentsWithMetadataDictionary(pdfDoc, value, (SkPdfComponentsWi thMetadataDictionary**)data);

4842 }

4843

4844 bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc , const PdfDictionary& dict, const char* key, const char* abr, SkPdfComponentsWi thMetadataDictionary** data) {

4845 if (ComponentsWithMetadataDictionaryFromDictionary(pdfDoc, dict, key, data)) r eturn true;

4846 if (abr == NULL \|\| *abr == '\0') return false;

4847 return ComponentsWithMetadataDictionaryFromDictionary(pdfDoc, dict, abr, data) ;

4848 }

4849

4850 bool isPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

4851 return true;

4852 }

4853

4854 bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfPagePieceDictionary** data) {

4855 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4856 if (value == NULL) { return false; }

4857 if (data == NULL) { return true; }

4858 return mapPagePieceDictionary(pdfDoc, value, (SkPdfPagePieceDictionary**)dat a);

4859 }

4860

4861 bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfPagePieceDictionary** dat a) {

4862 if (PagePieceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4863 if (abr == NULL \|\| *abr == '\0') return false;

4864 return PagePieceDictionaryFromDictionary(pdfDoc, dict, abr, data);

4865 }

4866

4867 bool isApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

4868 return true;

4869 }

4870

4871 bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfApplicationDataDictionary** data) {

4872 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4873 if (value == NULL) { return false; }

4874 if (data == NULL) { return true; }

4875 return mapApplicationDataDictionary(pdfDoc, value, (SkPdfApplicationDataDict ionary**)data);

4876 }

4877

4878 bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfApplicationDataDict ionary** data) {

4879 if (ApplicationDataDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

4880 if (abr == NULL \|\| *abr == '\0') return false;

4881 return ApplicationDataDictionaryFromDictionary(pdfDoc, dict, abr, data);

4882 }

4883

4884 bool isStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

4885 return true;

4886 }

4887

4888 bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfStructureTreeRootDictionary** data ) {

4889 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4890 if (value == NULL) { return false; }

4891 if (data == NULL) { return true; }

4892 return mapStructureTreeRootDictionary(pdfDoc, value, (SkPdfStructureTreeRoot Dictionary**)data);

4893 }

4894

4895 bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureTreeRoot Dictionary** data) {

4896 if (StructureTreeRootDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4897 if (abr == NULL \|\| *abr == '\0') return false;

4898 return StructureTreeRootDictionaryFromDictionary(pdfDoc, dict, abr, data);

4899 }

4900

4901 bool isStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObje ct& podofoObj) {

4902 return true;

4903 }

4904

4905 bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, SkPdfStructureElementDictionary** data) {

4906 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4907 if (value == NULL) { return false; }

4908 if (data == NULL) { return true; }

4909 return mapStructureElementDictionary(pdfDoc, value, (SkPdfStructureElementDi ctionary**)data);

4910 }

4911

4912 bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, cons t PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureElementDi ctionary** data) {

4913 if (StructureElementDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

4914 if (abr == NULL \|\| *abr == '\0') return false;

4915 return StructureElementDictionaryFromDictionary(pdfDoc, dict, abr, data);

4916 }

4917

4918 bool isMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj) {

4919 return true;

4920 }

4921

4922 bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc , const PdfDictionary& dict, const char* key, SkPdfMarkedContentReferenceDiction ary** data) {

4923 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4924 if (value == NULL) { return false; }

4925 if (data == NULL) { return true; }

4926 return mapMarkedContentReferenceDictionary(pdfDoc, value, (SkPdfMarkedConten tReferenceDictionary**)data);

4927 }

4928

4929 bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc , const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkedConten tReferenceDictionary** data) {

4930 if (MarkedContentReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) r eturn true;

4931 if (abr == NULL \|\| *abr == '\0') return false;

4932 return MarkedContentReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data) ;

4933 }

4934

4935 bool isObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

4936 return true;

4937 }

4938

4939 bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfObjectReferenceDictionary** data) {

4940 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4941 if (value == NULL) { return false; }

4942 if (data == NULL) { return true; }

4943 return mapObjectReferenceDictionary(pdfDoc, value, (SkPdfObjectReferenceDict ionary**)data);

4944 }

4945

4946 bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfObjectReferenceDict ionary** data) {

4947 if (ObjectReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

4948 if (abr == NULL \|\| *abr == '\0') return false;

4949 return ObjectReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);

4950 }

4951

4952 bool isStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const P dfObject& podofoObj) {

4953 return true;

4954 }

4955

4956 bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc , const PdfDictionary& dict, const char* key, SkPdfStructureElementAccessDiction ary** data) {

4957 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4958 if (value == NULL) { return false; }

4959 if (data == NULL) { return true; }

4960 return mapStructureElementAccessDictionary(pdfDoc, value, (SkPdfStructureEle mentAccessDictionary**)data);

4961 }

4962

4963 bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc , const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureEle mentAccessDictionary** data) {

4964 if (StructureElementAccessDictionaryFromDictionary(pdfDoc, dict, key, data)) r eturn true;

4965 if (abr == NULL \|\| *abr == '\0') return false;

4966 return StructureElementAccessDictionaryFromDictionary(pdfDoc, dict, abr, data) ;

4967 }

4968

4969 bool isAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

4970 return true;

4971 }

4972

4973 bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAttributeObjectDictionary** data) {

4974 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4975 if (value == NULL) { return false; }

4976 if (data == NULL) { return true; }

4977 return mapAttributeObjectDictionary(pdfDoc, value, (SkPdfAttributeObjectDict ionary**)data);

4978 }

4979

4980 bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAttributeObjectDict ionary** data) {

4981 if (AttributeObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

4982 if (abr == NULL \|\| *abr == '\0') return false;

4983 return AttributeObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);

4984 }

4985

4986 bool isMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

4987 return true;

4988 }

4989

4990 bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkInformationDictionary** data) {

4991 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

4992 if (value == NULL) { return false; }

4993 if (data == NULL) { return true; }

4994 return mapMarkInformationDictionary(pdfDoc, value, (SkPdfMarkInformationDict ionary**)data);

4995 }

4996

4997 bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkInformationDict ionary** data) {

4998 if (MarkInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

4999 if (abr == NULL \|\| *abr == '\0') return false;

5000 return MarkInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);

5001 }

5002

5003 bool isArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& pod ofoObj) {

5004 return true;

5005 }

5006

5007 bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, SkPdfArtifactsDictionary** data) {

5008 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5009 if (value == NULL) { return false; }

5010 if (data == NULL) { return true; }

5011 return mapArtifactsDictionary(pdfDoc, value, (SkPdfArtifactsDictionary**)dat a);

5012 }

5013

5014 bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDi ctionary& dict, const char* key, const char* abr, SkPdfArtifactsDictionary** dat a) {

5015 if (ArtifactsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5016 if (abr == NULL \|\| *abr == '\0') return false;

5017 return ArtifactsDictionaryFromDictionary(pdfDoc, dict, abr, data);

5018 }

5019

5020 bool isStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

5021 return true;

5022 }

5023

5024 bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfStandardStructureDictionary** data ) {

5025 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5026 if (value == NULL) { return false; }

5027 if (data == NULL) { return true; }

5028 return mapStandardStructureDictionary(pdfDoc, value, (SkPdfStandardStructure Dictionary**)data);

5029 }

5030

5031 bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardStructure Dictionary** data) {

5032 if (StandardStructureDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5033 if (abr == NULL \|\| *abr == '\0') return false;

5034 return StandardStructureDictionaryFromDictionary(pdfDoc, dict, abr, data);

5035 }

5036

5037 bool isBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, co nst PdfObject& podofoObj) {

5038 return true;

5039 }

5040

5041 bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* p dfDoc, const PdfDictionary& dict, const char* key, SkPdfBlockLevelStructureEleme ntsDictionary** data) {

5042 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5043 if (value == NULL) { return false; }

5044 if (data == NULL) { return true; }

5045 return mapBlockLevelStructureElementsDictionary(pdfDoc, value, (SkPdfBlockLe velStructureElementsDictionary**)data);

5046 }

5047

5048 bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* p dfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBlockLe velStructureElementsDictionary** data) {

5049 if (BlockLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, key, dat a)) return true;

5050 if (abr == NULL \|\| *abr == '\0') return false;

5051 return BlockLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, abr, data);

5052 }

5053

5054 bool isInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, c onst PdfObject& podofoObj) {

5055 return true;

5056 }

5057

5058 bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInlineLevelStructureEle mentsDictionary** data) {

5059 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5060 if (value == NULL) { return false; }

5061 if (data == NULL) { return true; }

5062 return mapInlineLevelStructureElementsDictionary(pdfDoc, value, (SkPdfInline LevelStructureElementsDictionary**)data);

5063 }

5064

5065 bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInline LevelStructureElementsDictionary** data) {

5066 if (InlineLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, key, da ta)) return true;

5067 if (abr == NULL \|\| *abr == '\0') return false;

5068 return InlineLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, abr, data);

5069 }

5070

5071 bool isListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {

5072 return true;

5073 }

5074

5075 bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, SkPdfListAttributeDictionary** data) {

5076 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5077 if (value == NULL) { return false; }

5078 if (data == NULL) { return true; }

5079 return mapListAttributeDictionary(pdfDoc, value, (SkPdfListAttributeDictiona ry**)data);

5080 }

5081

5082 bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const P dfDictionary& dict, const char* key, const char* abr, SkPdfListAttributeDictiona ry** data) {

5083 if (ListAttributeDictionaryFromDictionary(pdfDoc, dict, key, data)) return tru e;

5084 if (abr == NULL \|\| *abr == '\0') return false;

5085 return ListAttributeDictionaryFromDictionary(pdfDoc, dict, abr, data);

5086 }

5087

5088 bool isTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

5089 return true;

5090 }

5091

5092 bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTableAttributesDictionary** data) {

5093 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5094 if (value == NULL) { return false; }

5095 if (data == NULL) { return true; }

5096 return mapTableAttributesDictionary(pdfDoc, value, (SkPdfTableAttributesDict ionary**)data);

5097 }

5098

5099 bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTableAttributesDict ionary** data) {

5100 if (TableAttributesDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

5101 if (abr == NULL \|\| *abr == '\0') return false;

5102 return TableAttributesDictionaryFromDictionary(pdfDoc, dict, abr, data);

5103 }

5104

5105 bool isWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const Pd fObject& podofoObj) {

5106 return true;

5107 }

5108

5109 bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureInformationDictionar y** data) {

5110 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5111 if (value == NULL) { return false; }

5112 if (data == NULL) { return true; }

5113 return mapWebCaptureInformationDictionary(pdfDoc, value, (SkPdfWebCaptureInf ormationDictionary**)data);

5114 }

5115

5116 bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureInf ormationDictionary** data) {

5117 if (WebCaptureInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) re turn true;

5118 if (abr == NULL \|\| *abr == '\0') return false;

5119 return WebCaptureInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);

5120 }

5121

5122 bool isWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

5123 return true;

5124 }

5125

5126 bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfWebCaptureDictionary** data) {

5127 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5128 if (value == NULL) { return false; }

5129 if (data == NULL) { return true; }

5130 return mapWebCaptureDictionary(pdfDoc, value, (SkPdfWebCaptureDictionary**)d ata);

5131 }

5132

5133 bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfWebCaptureDictionary** d ata) {

5134 if (WebCaptureDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5135 if (abr == NULL \|\| *abr == '\0') return false;

5136 return WebCaptureDictionaryFromDictionary(pdfDoc, dict, abr, data);

5137 }

5138

5139 bool isWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

5140 return true;

5141 }

5142

5143 bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfWebCapturePageSetDictionary** data ) {

5144 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5145 if (value == NULL) { return false; }

5146 if (data == NULL) { return true; }

5147 return mapWebCapturePageSetDictionary(pdfDoc, value, (SkPdfWebCapturePageSet Dictionary**)data);

5148 }

5149

5150 bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCapturePageSet Dictionary** data) {

5151 if (WebCapturePageSetDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5152 if (abr == NULL \|\| *abr == '\0') return false;

5153 return WebCapturePageSetDictionaryFromDictionary(pdfDoc, dict, abr, data);

5154 }

5155

5156 bool isWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfOb ject& podofoObj) {

5157 return true;

5158 }

5159

5160 bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, co nst PdfDictionary& dict, const char* key, SkPdfWebCaptureImageSetDictionary** da ta) {

5161 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5162 if (value == NULL) { return false; }

5163 if (data == NULL) { return true; }

5164 return mapWebCaptureImageSetDictionary(pdfDoc, value, (SkPdfWebCaptureImageS etDictionary**)data);

5165 }

5166

5167 bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, co nst PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureImageS etDictionary** data) {

5168 if (WebCaptureImageSetDictionaryFromDictionary(pdfDoc, dict, key, data)) retur n true;

5169 if (abr == NULL \|\| *abr == '\0') return false;

5170 return WebCaptureImageSetDictionaryFromDictionary(pdfDoc, dict, abr, data);

5171 }

5172

5173 bool isSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

5174 return true;

5175 }

5176

5177 bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfSourceInformationDictionary** data ) {

5178 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5179 if (value == NULL) { return false; }

5180 if (data == NULL) { return true; }

5181 return mapSourceInformationDictionary(pdfDoc, value, (SkPdfSourceInformation Dictionary**)data);

5182 }

5183

5184 bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfSourceInformation Dictionary** data) {

5185 if (SourceInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5186 if (abr == NULL \|\| *abr == '\0') return false;

5187 return SourceInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);

5188 }

5189

5190 bool isURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj) {

5191 return true;

5192 }

5193

5194 bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, SkPdfURLAliasDictionary** data) {

5195 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5196 if (value == NULL) { return false; }

5197 if (data == NULL) { return true; }

5198 return mapURLAliasDictionary(pdfDoc, value, (SkPdfURLAliasDictionary**)data) ;

5199 }

5200

5201 bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, const char* abr, SkPdfURLAliasDictionary** data) {

5202 if (URLAliasDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5203 if (abr == NULL \|\| *abr == '\0') return false;

5204 return URLAliasDictionaryFromDictionary(pdfDoc, dict, abr, data);

5205 }

5206

5207 bool isWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

5208 return true;

5209 }

5210

5211 bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandDictionary** data ) {

5212 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5213 if (value == NULL) { return false; }

5214 if (data == NULL) { return true; }

5215 return mapWebCaptureCommandDictionary(pdfDoc, value, (SkPdfWebCaptureCommand Dictionary**)data);

5216 }

5217

5218 bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureCommand Dictionary** data) {

5219 if (WebCaptureCommandDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5220 if (abr == NULL \|\| *abr == '\0') return false;

5221 return WebCaptureCommandDictionaryFromDictionary(pdfDoc, dict, abr, data);

5222 }

5223

5224 bool isWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, cons t PdfObject& podofoObj) {

5225 return true;

5226 }

5227

5228 bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdf Doc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandSettingsD ictionary** data) {

5229 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5230 if (value == NULL) { return false; }

5231 if (data == NULL) { return true; }

5232 return mapWebCaptureCommandSettingsDictionary(pdfDoc, value, (SkPdfWebCaptur eCommandSettingsDictionary**)data);

5233 }

5234

5235 bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdf Doc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptur eCommandSettingsDictionary** data) {

5236 if (WebCaptureCommandSettingsDictionaryFromDictionary(pdfDoc, dict, key, data) ) return true;

5237 if (abr == NULL \|\| *abr == '\0') return false;

5238 return WebCaptureCommandSettingsDictionaryFromDictionary(pdfDoc, dict, abr, da ta);

5239 }

5240

5241 bool isBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfO bject& podofoObj) {

5242 return true;

5243 }

5244

5245 bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, c onst PdfDictionary& dict, const char* key, SkPdfBoxColorInformationDictionary** data) {

5246 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5247 if (value == NULL) { return false; }

5248 if (data == NULL) { return true; }

5249 return mapBoxColorInformationDictionary(pdfDoc, value, (SkPdfBoxColorInforma tionDictionary**)data);

5250 }

5251

5252 bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, c onst PdfDictionary& dict, const char* key, const char* abr, SkPdfBoxColorInforma tionDictionary** data) {

5253 if (BoxColorInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) retu rn true;

5254 if (abr == NULL \|\| *abr == '\0') return false;

5255 return BoxColorInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);

5256 }

5257

5258 bool isBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podo foObj) {

5259 return true;

5260 }

5261

5262 bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, SkPdfBoxStyleDictionary** data) {

5263 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5264 if (value == NULL) { return false; }

5265 if (data == NULL) { return true; }

5266 return mapBoxStyleDictionary(pdfDoc, value, (SkPdfBoxStyleDictionary**)data) ;

5267 }

5268

5269 bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDic tionary& dict, const char* key, const char* abr, SkPdfBoxStyleDictionary** data) {

5270 if (BoxStyleDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5271 if (abr == NULL \|\| *abr == '\0') return false;

5272 return BoxStyleDictionaryFromDictionary(pdfDoc, dict, abr, data);

5273 }

5274

5275 bool isPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const Pd fObject& podofoObj) {

5276 return true;

5277 }

5278

5279 bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkAnnotationDictionar y** data) {

5280 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5281 if (value == NULL) { return false; }

5282 if (data == NULL) { return true; }

5283 return mapPrinterMarkAnnotationDictionary(pdfDoc, value, (SkPdfPrinterMarkAn notationDictionary**)data);

5284 }

5285

5286 bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkAn notationDictionary** data) {

5287 if (PrinterMarkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) re turn true;

5288 if (abr == NULL \|\| *abr == '\0') return false;

5289 return PrinterMarkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

5290 }

5291

5292 bool isPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

5293 return true;

5294 }

5295

5296 bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkFormDictionary** data) {

5297 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5298 if (value == NULL) { return false; }

5299 if (data == NULL) { return true; }

5300 return mapPrinterMarkFormDictionary(pdfDoc, value, (SkPdfPrinterMarkFormDict ionary**)data);

5301 }

5302

5303 bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkFormDict ionary** data) {

5304 if (PrinterMarkFormDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

5305 if (abr == NULL \|\| *abr == '\0') return false;

5306 return PrinterMarkFormDictionaryFromDictionary(pdfDoc, dict, abr, data);

5307 }

5308

5309 bool isSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

5310 return true;

5311 }

5312

5313 bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfSeparationDictionary** data) {

5314 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5315 if (value == NULL) { return false; }

5316 if (data == NULL) { return true; }

5317 return mapSeparationDictionary(pdfDoc, value, (SkPdfSeparationDictionary**)d ata);

5318 }

5319

5320 bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfSeparationDictionary** d ata) {

5321 if (SeparationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5322 if (abr == NULL \|\| *abr == '\0') return false;

5323 return SeparationDictionaryFromDictionary(pdfDoc, dict, abr, data);

5324 }

5325

5326 bool isPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObj ect& podofoObj) {

5327 return true;

5328 }

5329

5330 bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, SkPdfPDF_XOutputIntentDictionary** data ) {

5331 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5332 if (value == NULL) { return false; }

5333 if (data == NULL) { return true; }

5334 return mapPDF_XOutputIntentDictionary(pdfDoc, value, (SkPdfPDF_XOutputIntent Dictionary**)data);

5335 }

5336

5337 bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, con st PdfDictionary& dict, const char* key, const char* abr, SkPdfPDF_XOutputIntent Dictionary** data) {

5338 if (PDF_XOutputIntentDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5339 if (abr == NULL \|\| *abr == '\0') return false;

5340 return PDF_XOutputIntentDictionaryFromDictionary(pdfDoc, dict, abr, data);

5341 }

5342

5343 bool isTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const Pd fObject& podofoObj) {

5344 return true;

5345 }

5346

5347 bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAnnotationDictionar y** data) {

5348 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5349 if (value == NULL) { return false; }

5350 if (data == NULL) { return true; }

5351 return mapTrapNetworkAnnotationDictionary(pdfDoc, value, (SkPdfTrapNetworkAn notationDictionary**)data);

5352 }

5353

5354 bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNetworkAn notationDictionary** data) {

5355 if (TrapNetworkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) re turn true;

5356 if (abr == NULL \|\| *abr == '\0') return false;

5357 return TrapNetworkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);

5358 }

5359

5360 bool isTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, co nst PdfObject& podofoObj) {

5361 return true;

5362 }

5363

5364 bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* p dfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAppearanceStr eamDictionary** data) {

5365 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5366 if (value == NULL) { return false; }

5367 if (data == NULL) { return true; }

5368 return mapTrapNetworkAppearanceStreamDictionary(pdfDoc, value, (SkPdfTrapNet workAppearanceStreamDictionary**)data);

5369 }

5370

5371 bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* p dfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNet workAppearanceStreamDictionary** data) {

5372 if (TrapNetworkAppearanceStreamDictionaryFromDictionary(pdfDoc, dict, key, dat a)) return true;

5373 if (abr == NULL \|\| *abr == '\0') return false;

5374 return TrapNetworkAppearanceStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);

5375 }

5376

5377 bool isOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& po dofoObj) {

5378 return true;

5379 }

5380

5381 bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, SkPdfOpiVersionDictionary** data) {

5382 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5383 if (value == NULL) { return false; }

5384 if (data == NULL) { return true; }

5385 return mapOpiVersionDictionary(pdfDoc, value, (SkPdfOpiVersionDictionary**)d ata);

5386 }

5387

5388 bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfD ictionary& dict, const char* key, const char* abr, SkPdfOpiVersionDictionary** d ata) {

5389 if (OpiVersionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;

5390 if (abr == NULL \|\| *abr == '\0') return false;

5391 return OpiVersionDictionaryFromDictionary(pdfDoc, dict, abr, data);

5392 }

5393

5394 bool isMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObjec t& podofoObj) {

5395 std::string Subtype;

5396 if (!podofoObj.IsDictionary()) return false;

5397 if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;

5398 if ((Subtype != "MMType1")) return false;

5399

5400 return true;

5401 }

5402

5403 bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMultiMasterFontDictionary** data) {

5404 const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(ke y)), true);

5405 if (value == NULL) { return false; }

5406 if (data == NULL) { return true; }

5407 return mapMultiMasterFontDictionary(pdfDoc, value, (SkPdfMultiMasterFontDict ionary**)data);

5408 }

5409

5410 bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMultiMasterFontDict ionary** data) {

5411 if (MultiMasterFontDictionaryFromDictionary(pdfDoc, dict, key, data)) return t rue;

5412 if (abr == NULL \|\| *abr == '\0') return false;

5413 return MultiMasterFontDictionaryFromDictionary(pdfDoc, dict, abr, data);

5414 }

OLD	NEW