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