include/registry/reader.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_REGISTRY_READER_HXX
  21 #define INCLUDED_REGISTRY_READER_HXX
  22
  23 #include <registry/typereg_reader.hxx>
  24 #include <registry/refltype.hxx>
  25 #include <registry/types.hxx>
  26 #include <registry/version.h>
  27
  28 #include <rtl/ustring.hxx>
  29 #include <sal/types.h>
  30
  31 #include <new>
  32
  33 namespace typereg {
  34
  35 /**
  36    A type reader working on a binary blob that represents a UNOIDL type.
  37
  38    <p>Instances of this class are not multi-thread&ndash;safe.</p>
  39
  40    @since UDK 3.2.0
  41  */
  42 class Reader {
  43 public:
  44     /**
  45        Creates a type reader.
  46
  47        <p>If the given binary blob is malformed, or of a version larger than
  48        <code>maxVersion</code>, the created type reader is flagged as
  49        invalid.</p>
  50
  51        @param buffer the binary blob representing the type; must point to at
  52        least <code>length</code> bytes, and need only be byte-aligned
  53
  54        @param length the size in bytes of the binary blob representing the type
  55
  56        @exception std::bad_alloc is raised if an out-of-memory condition occurs
  57      */
  58     Reader(void const * buffer, sal_uInt32 length)
  59     {
  60         if (!typereg_reader_create(buffer, length, &m_handle))
  61         {
  62             throw std::bad_alloc();
  63         }
  64     }
  65
  66     /**
  67        Shares a type reader between two <code>Reader</code> instances.
  68
  69        @param other another <code>Reader</code> instance
  70      */
  71     Reader(Reader const & other): m_handle(other.m_handle) {
  72         typereg_reader_acquire(m_handle);
  73     }
  74
  75     /**
  76        Destroys this <code>Reader</code> instance.
  77
  78        <p>The underlying type reader is only destroyed if this instance was its
  79        last user.</p>
  80      */
  81     ~Reader() {
  82         typereg_reader_release(m_handle);
  83     }
  84
  85     /**
  86        Replaces the underlying type reader.
  87
  88        @param other any <code>Reader</code> instance
  89
  90        @return this <code>Reader</code> instance
  91      */
  92     Reader & operator =(Reader const & other) {
  93         Reader temp(other);
  94         std::swap(m_handle, temp.m_handle);
  95         return *this;
  96     }
  97
  98     /**
  99        Returns whether this type reader is valid.
 100
 101        @return true iff this type reader is valid
 102      */
 103     bool isValid() const {
 104         return m_handle != nullptr;
 105     }
 106
 107     /**
 108        Returns the binary blob version of this type reader.
 109
 110        @return the version of the binary blob from which this type reader was
 111        constructed; if this type reader is invalid,
 112        <code>TYPEREG_VERSION_0</code> is returned
 113      */
 114     typereg_Version getVersion() const {
 115         return typereg_reader_getVersion(m_handle);
 116     }
 117
 118     /**
 119        Returns the documentation of this type reader.
 120
 121        @return the documentation of this type reader; if this type reader is
 122        invalid, an empty string is returned
 123
 124        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 125      */
 126     OUString getDocumentation() const {
 127         rtl_uString * s = nullptr;
 128         typereg_reader_getDocumentation(m_handle, &s);
 129         if (s == nullptr) {
 130             throw std::bad_alloc();
 131         }
 132         return OUString(s, SAL_NO_ACQUIRE);
 133     }
 134
 135     /**
 136        Returns the file name of this type reader.
 137
 138        @return the file name of this type reader; if this type reader is
 139        invalid, an empty string is returned
 140
 141        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 142        @deprecated
 143      */
 144     OUString getFileName() const {
 145         rtl_uString * s = nullptr;
 146         typereg_reader_getFileName(m_handle, &s);
 147         if (s == nullptr) {
 148             throw std::bad_alloc();
 149         }
 150         return OUString(s, SAL_NO_ACQUIRE);
 151     }
 152
 153     /**
 154        Returns the type class of this type reader.
 155
 156        <p>This function will always return the type class without the internal
 157        <code>RT_TYPE_PUBLISHED</code> flag set.  Use <code>isPublished</code> to
 158        determine whether this type reader is published.</p>
 159
 160        @return the type class of this type reader; if this type reader is
 161        invalid, <code>RT_TYPE_INVALID</code> is returned
 162      */
 163     RTTypeClass getTypeClass() const {
 164         return typereg_reader_getTypeClass(m_handle);
 165     }
 166
 167     /**
 168        Returns whether this type reader is published.
 169
 170        @return whether this type reader is published; if this type reader is
 171        invalid, <code>false</code> is returned
 172      */
 173     bool isPublished() const {
 174         return typereg_reader_isPublished(m_handle);
 175     }
 176
 177     /**
 178        Returns the type name of this type reader.
 179
 180        @return the type name of this type reader; if this type reader is
 181        invalid, an empty string is returned
 182
 183        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 184      */
 185     OUString getTypeName() const {
 186         rtl_uString * s = nullptr;
 187         typereg_reader_getTypeName(m_handle, &s);
 188         if (s == nullptr) {
 189             throw std::bad_alloc();
 190         }
 191         return OUString(s, SAL_NO_ACQUIRE);
 192     }
 193
 194     /**
 195        Returns the number of super types of this type reader.
 196
 197        @return the number of super types of this type reader; if this type
 198        reader is invalid, zero is returned
 199      */
 200     sal_uInt16 getSuperTypeCount() const {
 201         return typereg_reader_getSuperTypeCount(m_handle);
 202     }
 203
 204     /**
 205        Returns the type name of a super type of this type reader.
 206
 207        @param index a valid index into the range of super types of this type
 208        reader
 209
 210        @return the type name of the given super type
 211
 212        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 213      */
 214     OUString getSuperTypeName(sal_uInt16 index) const {
 215         rtl_uString * s = nullptr;
 216         typereg_reader_getSuperTypeName(m_handle, &s, index);
 217         if (s == nullptr) {
 218             throw std::bad_alloc();
 219         }
 220         return OUString(s, SAL_NO_ACQUIRE);
 221     }
 222
 223     /**
 224        Returns the number of fields of this type reader.
 225
 226        @return the number of fields of this type reader; if this type reader is
 227        invalid, zero is returned
 228      */
 229     sal_uInt16 getFieldCount() const {
 230         return typereg_reader_getFieldCount(m_handle);
 231     }
 232
 233     /**
 234        Returns the documentation of a field of this type reader.
 235
 236        @param index a valid index into the range of fields of this type reader
 237
 238        @return the documentation of the given field
 239
 240        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 241      */
 242     OUString getFieldDocumentation(sal_uInt16 index) const {
 243         rtl_uString * s = nullptr;
 244         typereg_reader_getFieldDocumentation(m_handle, &s, index);
 245         if (s == nullptr) {
 246             throw std::bad_alloc();
 247         }
 248         return OUString(s, SAL_NO_ACQUIRE);
 249     }
 250
 251     /**
 252        Returns the file name of a field of this type reader.
 253
 254        @param index a valid index into the range of fields of this type reader
 255
 256        @return the file name of the given field
 257
 258        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 259        @deprecated
 260      */
 261     OUString getFieldFileName(sal_uInt16 index) const {
 262         rtl_uString * s = nullptr;
 263         typereg_reader_getFieldFileName(m_handle, &s, index);
 264         if (s == nullptr) {
 265             throw std::bad_alloc();
 266         }
 267         return OUString(s, SAL_NO_ACQUIRE);
 268     }
 269
 270     /**
 271        Returns the flags of a field of this type reader.
 272
 273        @param index a valid index into the range of fields of this type reader
 274
 275        @return the flags of the given field
 276      */
 277     RTFieldAccess getFieldFlags(sal_uInt16 index) const {
 278         return typereg_reader_getFieldFlags(m_handle, index);
 279     }
 280
 281     /**
 282        Returns the name of a field of this type reader.
 283
 284        @param index a valid index into the range of fields of this type reader
 285
 286        @return the name of the given field
 287
 288        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 289      */
 290     OUString getFieldName(sal_uInt16 index) const {
 291         rtl_uString * s = nullptr;
 292         typereg_reader_getFieldName(m_handle, &s, index);
 293         if (s == nullptr) {
 294             throw std::bad_alloc();
 295         }
 296         return OUString(s, SAL_NO_ACQUIRE);
 297     }
 298
 299     /**
 300        Returns the type name of a field of this type reader.
 301
 302        @param index a valid index into the range of fields of this type reader
 303
 304        @return the type name of the given field
 305
 306        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 307      */
 308     OUString getFieldTypeName(sal_uInt16 index) const {
 309         rtl_uString * s = nullptr;
 310         typereg_reader_getFieldTypeName(m_handle, &s, index);
 311         if (s == nullptr) {
 312             throw std::bad_alloc();
 313         }
 314         return OUString(s, SAL_NO_ACQUIRE);
 315     }
 316
 317     /**
 318        Returns the value of a field of this type reader.
 319
 320        @param index a valid index into the range of fields of this type reader
 321
 322        @return the value of the given field
 323
 324        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 325      */
 326     RTConstValue getFieldValue(sal_uInt16 index) const {
 327         RTConstValue v;
 328         if (!typereg_reader_getFieldValue(
 329                 m_handle, index, &v.m_type, &v.m_value))
 330         {
 331             throw std::bad_alloc();
 332         }
 333         return v;
 334     }
 335
 336     /**
 337        Returns the number of methods of this type reader.
 338
 339        @return the number of methods of this type reader; if this type reader is
 340        invalid, zero is returned
 341      */
 342     sal_uInt16 getMethodCount() const {
 343         return typereg_reader_getMethodCount(m_handle);
 344     }
 345
 346     /**
 347        Returns the documentation of a method of this type reader.
 348
 349        @param index a valid index into the range of methods of this type reader
 350
 351        @return the documentation of the given method
 352
 353        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 354      */
 355     OUString getMethodDocumentation(sal_uInt16 index) const {
 356         rtl_uString * s = nullptr;
 357         typereg_reader_getMethodDocumentation(m_handle, &s, index);
 358         if (s == nullptr) {
 359             throw std::bad_alloc();
 360         }
 361         return OUString(s, SAL_NO_ACQUIRE);
 362     }
 363
 364     /**
 365        Returns the flags of a method of this type reader.
 366
 367        @param index a valid index into the range of methods of this type reader
 368
 369        @return the flags of the given method
 370      */
 371     RTMethodMode getMethodFlags(sal_uInt16 index) const {
 372         return typereg_reader_getMethodFlags(m_handle, index);
 373     }
 374
 375     /**
 376        Returns the name of a method of this type reader.
 377
 378        @param index a valid index into the range of methods of this type reader
 379
 380        @return the name of the given method
 381
 382        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 383      */
 384     OUString getMethodName(sal_uInt16 index) const {
 385         rtl_uString * s = nullptr;
 386         typereg_reader_getMethodName(m_handle, &s, index);
 387         if (s == nullptr) {
 388             throw std::bad_alloc();
 389         }
 390         return OUString(s, SAL_NO_ACQUIRE);
 391     }
 392
 393     /**
 394        Returns the return type name of a method of this type reader.
 395
 396        @param index a valid index into the range of methods of this type reader
 397
 398        @return the return type name of the given method
 399
 400        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 401      */
 402     OUString getMethodReturnTypeName(sal_uInt16 index) const {
 403         rtl_uString * s = nullptr;
 404         typereg_reader_getMethodReturnTypeName(m_handle, &s, index);
 405         if (s == nullptr) {
 406             throw std::bad_alloc();
 407         }
 408         return OUString(s, SAL_NO_ACQUIRE);
 409     }
 410
 411     /**
 412        Returns the number of parameters of a method of this type reader.
 413
 414        @param index a valid index into the range of methods of this type reader
 415
 416        @return the number of parameters of the given method
 417      */
 418     sal_uInt16 getMethodParameterCount(sal_uInt16 index) const {
 419         return typereg_reader_getMethodParameterCount(m_handle, index);
 420     }
 421
 422     /**
 423        Returns the flags of a parameter of a method of this type reader.
 424
 425        @param methodIndex a valid index into the range of methods of this type
 426        reader
 427
 428        @param parameterIndex a valid index into the range of parameters of the
 429        given method
 430
 431        @return the flags of the given method parameter
 432      */
 433     RTParamMode getMethodParameterFlags(
 434         sal_uInt16 methodIndex, sal_uInt16 parameterIndex) const
 435     {
 436         return typereg_reader_getMethodParameterFlags(
 437             m_handle, methodIndex, parameterIndex);
 438     }
 439
 440     /**
 441        Returns the name of a parameter of a method of this type reader.
 442
 443        @param methodIndex a valid index into the range of methods of this type
 444        reader
 445
 446        @param parameterIndex a valid index into the range of parameters of the
 447        given method
 448
 449        @return the name of the given method parameter
 450
 451        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 452      */
 453     OUString getMethodParameterName(
 454         sal_uInt16 methodIndex, sal_uInt16 parameterIndex) const
 455     {
 456         rtl_uString * s = nullptr;
 457         typereg_reader_getMethodParameterName(
 458             m_handle, &s, methodIndex, parameterIndex);
 459         if (s == nullptr) {
 460             throw std::bad_alloc();
 461         }
 462         return OUString(s, SAL_NO_ACQUIRE);
 463     }
 464
 465     /**
 466        Returns the type name of a parameter of a method of this type reader.
 467
 468        @param methodIndex a valid index into the range of methods of this type
 469        reader
 470
 471        @param parameterIndex a valid index into the range of parameters of the
 472        given method
 473
 474        @return the type name of the given method parameter
 475
 476        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 477      */
 478     OUString getMethodParameterTypeName(
 479         sal_uInt16 methodIndex, sal_uInt16 parameterIndex) const
 480     {
 481         rtl_uString * s = nullptr;
 482         typereg_reader_getMethodParameterTypeName(
 483             m_handle, &s, methodIndex, parameterIndex);
 484         if (s == nullptr) {
 485             throw std::bad_alloc();
 486         }
 487         return OUString(s, SAL_NO_ACQUIRE);
 488     }
 489
 490     /**
 491        Returns the number of exceptions of a method of this type reader.
 492
 493        @param index a valid index into the range of methods of this type reader
 494
 495        @return the number of exceptions of the given method
 496      */
 497     sal_uInt16 getMethodExceptionCount(sal_uInt16 index) const {
 498         return typereg_reader_getMethodExceptionCount(m_handle, index);
 499     }
 500
 501     /**
 502        Returns the type name of an exception of a method of this type reader.
 503
 504        @param methodIndex a valid index into the range of methods of this type
 505        reader
 506
 507        @param exceptionIndex a valid index into the range of exceptions of the
 508        given method
 509
 510        @return the type name of the given method exception
 511
 512        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 513      */
 514     OUString getMethodExceptionTypeName(
 515         sal_uInt16 methodIndex, sal_uInt16 exceptionIndex) const
 516     {
 517         rtl_uString * s = nullptr;
 518         typereg_reader_getMethodExceptionTypeName(
 519             m_handle, &s, methodIndex, exceptionIndex);
 520         if (s == nullptr) {
 521             throw std::bad_alloc();
 522         }
 523         return OUString(s, SAL_NO_ACQUIRE);
 524     }
 525
 526     /**
 527        Returns the number of references of this type reader.
 528
 529        @return the number of references of this type reader; if this type reader
 530        is invalid, zero is returned
 531      */
 532     sal_uInt16 getReferenceCount() const {
 533         return typereg_reader_getReferenceCount(m_handle);
 534     }
 535
 536     /**
 537        Returns the documentation of a reference of this type reader.
 538
 539        @param index a valid index into the range of references of this type
 540        reader
 541
 542        @return the documentation of the given reference
 543
 544        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 545      */
 546     OUString getReferenceDocumentation(sal_uInt16 index) const {
 547         rtl_uString * s = nullptr;
 548         typereg_reader_getReferenceDocumentation(m_handle, &s, index);
 549         if (s == nullptr) {
 550             throw std::bad_alloc();
 551         }
 552         return OUString(s, SAL_NO_ACQUIRE);
 553     }
 554
 555     /**
 556        Returns the flags of a reference of this type reader.
 557
 558        @param index a valid index into the range of references of this type
 559        reader
 560
 561        @return the flags of the given reference
 562      */
 563     RTFieldAccess getReferenceFlags(sal_uInt16 index) const {
 564         return typereg_reader_getReferenceFlags(m_handle, index);
 565     }
 566
 567     /**
 568        Returns the sort of a reference of this type reader.
 569
 570        @param index a valid index into the range of references of this type
 571        reader
 572
 573        @return the sort of the given reference
 574      */
 575     RTReferenceType getReferenceSort(sal_uInt16 index) const {
 576         return typereg_reader_getReferenceSort(m_handle, index);
 577     }
 578
 579     /**
 580        Returns the type name of a reference of this type reader.
 581
 582        @param index a valid index into the range of references of this type
 583        reader
 584
 585        @return the type name of the given reference
 586
 587        @exception std::bad_alloc is raised if an out-of-memory condition occurs
 588      */
 589     OUString getReferenceTypeName(sal_uInt16 index) const {
 590         rtl_uString * s = nullptr;
 591         typereg_reader_getReferenceTypeName(m_handle, &s, index);
 592         if (s == nullptr) {
 593             throw std::bad_alloc();
 594         }
 595         return OUString(s, SAL_NO_ACQUIRE);
 596     }
 597
 598 private:
 599     void * m_handle;
 600 };
 601
 602 }
 603
 604 #endif
 605
 606 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */