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