From 90dce779008dd154d2f231d79fdd82f5bbe7f32b Mon Sep 17 00:00:00 2001 From: stephen-dixon <68229525+stephen-dixon@users.noreply.github.com> Date: Fri, 18 Oct 2024 15:48:05 +0100 Subject: [PATCH] Updating Docs (#48) * initial notes added to docs for installing clients * completing manual build instructions for the uda client for all platformsv of interest in the documentation * removing some old build instructions from readme.md and instead referencing updated instructions in the docs * updating readme * adding a new page 'api_changes' to the documentation * Fix typos in api_changes.md * Update client_installation.md --- README.md | 235 +++++------------------ docs/api_changes.md | 82 ++++++++ docs/client_installation.md | 347 +++++++++++++++++++++++++++++++++- docs/creating_plugins.md | 3 +- docs/development.md | 1 + docs/server_installation.md | 7 +- source/client/legacy_accAPI.h | 6 +- 7 files changed, 490 insertions(+), 191 deletions(-) create mode 100644 docs/api_changes.md diff --git a/README.md b/README.md index ebd7c986..1e2866fa 100755 --- a/README.md +++ b/README.md @@ -13,10 +13,6 @@ See LICENCE.txt for details. ## Getting UDA -UDA binaries can be downloaded from: - - - The source code can be downloaded from: https://github.com/ukaea/UDA/releases/ @@ -25,7 +21,17 @@ The UDA git repository can be cloned: git clone git@github.com:ukaea/UDA.git -## Building from source +## Getting the UDA client + +The easiest way to obtain the client is to pip install the python wrapper (pyuda), wheels are uploaded for every tagged release from version 2.7.6. Further details are available on [pypi](https://pypi.org/project/uda/). + +```sh +pip install uda +``` + +For any other use cases please see the documentation to build from source [here](https://ukaea.github.io/UDA/client_installation/). + +## Building UDA Server from source ### Dependencies @@ -35,184 +41,47 @@ UDA requires the following to avail in order to build: | --- | --- | --- | | cmake | \> 3.0 | | | OpenSSL | | | -| PostgreSQL | | | | LibXml2 | | | -| LibMemcached | | to enable caching | -| swig | 3.0.0 | Python & HTTP wrappers | -| python | \> 3.0 | Python & HTTP wrappers | +| libfmt | | | +| spdlog | | | +| capnproto | | | | boost | | C++, Python & HTTP wrappers | -| java | | Java wrapper | -| hdf5 | | hdf5 plugin | -| netcdf | | netcdf plugin | -| MDSplus | | MDS+ plugin | - -#### Windows - -> Note: If you want to use Visual Studio 2019 to compile UDA, please refer to sections [Visual Studio](#visual-studio) and [vcpkg](#vcpkg) below - -Building extlibs (running in Powershell): - - cd extlib - mkdir build - cd build - cmake.exe .. -G"MinGW Makefiles" -DBUILD_SHARED_LIBS=ON - mingw32-make.exe - cd .. - .\install.bat - -Building extlibs (running in MinGW64 Shell): - - cd extlib/portablexdr-4.9.1 - ./configure - make - cd .. - ./install.sh - -Building extlibs (running in VS2019 x64 Native Tools): - - cd extlib - mkdir build - cd build - cmake.exe .. -G"Visual Studio 16 2019" - msbuild.exe ALL_BUILD.vcxproj /p:configuration=release /p:platform=x64 - cd .. - install.bat - -Tested and built on Windows 10 (built using MinGW 64-bit, running in Powershell): - - mkdir build - cd build - ..\scripts\cmake-win.bat - mingw32-make.exe - mingw32-make.exe install - -Tested and built on Windows 10 (built using MinGW 64-bit, running in MinGW64 Shell): - - mkdir build - cd build - cmake .. -G"Unix Makefiles" -DBUILD_SHARED_LIBS=ON -DTARGET_TYPE=OTHER - make - make install - -Tested and built on Windows 10 (built using VS2019 x64 Native Tools): - - mkdir build - cd build - cmake.exe .. -G"Visual Studio 16 2019" -DCMAKE_TOOLCHAIN_FILE="C:\vcpkg\scripts\buildsystems\vcpkg.cmake" -DNO_MODULES=ON -DTARGET_TYPE=OTHER -DBUILD_SHARED_LIBS=ON - msbuild ALL_BUILD.vcxproj /p:configuration=release /p:platform=x64 - msbuild INSTALL.vcxproj /p:configuration=release /p:platform=x64 - -Running Python client: - - $python_dir = (Get-Item (Get-Command python).Source).DirectoryName - rm $python_dir\Lib\site-packages\pyuda - copy -Recurse .\include\pyuda $python_dir\Lib\site-packages\ - cp .\extlib\lib\libxdr.dll $python_dir\Lib\site-packages\pyuda\ - - Set-Item -Path env:UDA_HOST -Value "idam3.mast.ccfe.ac.uk" - Set-Item -Path env:UDA_HOST -Value "56565" - python - -#### CentOS - -Packages needed for CentOS - - $ LANG=C sudo yum -y groupinstall 'Development Tools' - $ sudo yum -y install openssl-devel boost-devel swig-devel python-devel \ - postgresql-devel libxml2-devel gsl-devel libgcrypt-devel bzip2-devel \ - java-1.8.0-openjdk-devel - -#### Ubuntu - - sudo apt-get install git python3-dev libssl-dev libboost-dev python3-numpy python3-matplotlib - -#### OSX - -### Running cmake configuration - -To configure the UDA build you first need to run cmake: - - cmake -B -H. -DTARGET_TYPE:STRING= - -Where `` is the build directory to create and `` is the target specific configuration to use. The -different targets available are `MAST`, `ITER` and `OTHER`. These are available in the `cmake/Config` directory with -the file name `target-.cmake`. To add a new target simply copy one of these files and rename to the desired target name. - -An example configuration command is: - - cmake -Bbuild -H. -DTARGET_TYPE:STRING=OTHER - -By default UDA will configure to build in client-server mode with both the client and server being built. - -To only build the client use: - - cmake -DCLIENT_ONLY:BOOL=TRUE ... - -To build UDA in fat-client mode use: - - cmake -DFAT_BUILD:BOOL=TRUE ... - -### Building - - make -C - -### Installing - - make -C install - -### Packaging - -On Linux system: - - make -C package - -On Windows system (MinGW): - - make -C package - -On Windows system (VS2019): - - msbuild.exe INSTALL.vcxproj /p:configuration=release /p:platform=x64 - -## Visual Studio - -UDA can be compiled with Visaul Studio 2019. -To do that, Vidual Studio need to be iunstalled witrh at least the following packages: - -- C++ Desktop development tools -- CMake tools -- Python 3.7 -- MFC and ATL libraries -- English language pack (even if you choose another language) -- Windows 10 SDK v10.0.17134.0 - -## vcpkg - -vcpkg if a library manager designed by Microsoft to procure standard libraries for Visual Studio. - -It supports CMake toolchain, easily usable with UDA CMakeList.txt files. - -To use vcpkg, follow theses steps: - - git clone https://github.com/Microsoft/vcpkg - cd vcpkg - bootstrap-vcpkg.bat - -After that, vcpkg tool is ready to acquire libraries. -For UDA, severals libraries are mandatory, the following command download, compile and install them : - - vcpkg install libxml2:x64-windows openssl:x64-windows boost:x64-windows python3:x64-windows dlfcn-win32:x64-windows libpq:x64-windows netcdf-c:x64-windows blitz:x64-windows - -## Other Notes - -Ninja installation for CentOS: - - git clone https://github.com/ninja-build/ninja.git - - cd ninja - ./configure.py --bootstrap - export PATH="${HOME}/ninja:${PATH}" - -Add the following to your .bashrc file: +| LibMemcached | | to enable caching | +| python | \> 3.0 | Python wrapper | + +An example installation for ubuntu 22.10 would be as follows. + +Start by install all system-level dependencies. +```sh +sudo apt update && sudo apt install -y +git +libboost-dev +libboost-program-options-dev +libssl-dev +cmake +build-essential +pkg-config +libxml2-dev +libspdlog-dev +ninja-build +capnproto +libcapnp-dev +python3-dev +python3-pip +python3-venv +``` + +Configure the cmake project. +```sh +cmake -G Ninja -B build . \ +-DBUILD_SHARED_LIBS=ON \ +-DSSLAUTHENTICATION=ON \ +-DCLIENT_ONLY=OFF \ +-DENABLE_CAPNP=ON \ +-DCMAKE_INSTALL_PREFIX=install +``` + +```sh +cmake --build build -j --config Release --target install +``` - export PYTHONPATH=/usr/local/include diff --git a/docs/api_changes.md b/docs/api_changes.md new file mode 100644 index 00000000..17a15629 --- /dev/null +++ b/docs/api_changes.md @@ -0,0 +1,82 @@ +--- +layout: default +title: API changes +nav_order: 6 +--- + +# API changes + +This page aims to detail specific changes to the UDA client API, as well as describing how deprecations will be managed. + + +## Notable release history + +| UDA version | Description of API changes | +|:------------|:---------------------------| +| 2.7.0 | Some accidental breaking api changes are introduced, including some name changes from idam to uda, and the introduction of a new `client_flags` argument to some functions | +| 2.7.6 | A legacy mapping header is introduced which reintroduces the syntax that was lost in 2.7.0, while keeping the option to use new updated names (such as udaFree instead of idamFree) | +| (planned) 3.0.0 | Removal of all references to legacy "idam" name in all api functions. Imposing consistent naming convention in all API functions. Legacy API mapping header to be updated to permit continued use of old names for a more forgiving deprecation of old syntax | + + +## The legacy api headers + +Where old functions names are deprecated the old syntax may still be available in a header file mapping the old syntax to the new. This will allow codes to continue to build against newer UDA library versions until they are ready to update. + +The naming convention for these header files is that they mirror the existing headers they correspond to but with the word legacy added. For example to create a name mapping for a function which is declared in the `client.h` file, such as `udaFree`, the new header will be called `legacy_client.h`. To make use of a previous API function signature that is being replaced, client code simply needs to include the corresponding legacy header. + +The full set of existing legacy api header files will be described below. + +### legacy_client.h +This header contains the mappings for all functions from `client/client.h` The format of the file is as shown below and simply provides a mapping from the new names (`udaFree`) back to the deprecated syntax (`idamFree`). By including this header in client code, the old names are made available again. + +```c++ +LIBRARY_API inline void idamFree(int handle) +{ + udaFree(handle); +} + +LIBRARY_API inline void idamFreeAll() +{ + udaFreeAll(); +} + +``` + +### legacy_accAPI.h +This header contains the mappings for all functions from `clent/accAPI.h` whose definitions were changed in release 2.7.0. Note that to implement this header some API functions had to be changed to pre-empt the new v3.0 syntax (such as `udaUnlockThread` instead of `unlockUdaThread` ). It's also worth being aware of the two options available: either to enable the interface using the extra `client_flags` argument or the one without. The version without `client_flags` is the default and the other behaviour can be enabled by setting a compile flag called `UDA_CLIENT_FLAGS_API`. + +```c++ +#ifdef UDA_CLIENT_FLAGS_API + + LIBRARY_API inline DATA_BLOCK* acc_getCurrentDataBlock(CLIENT_FLAGS* client_flags) + { + return udaGetCurrentDataBlock(); + } + + LIBRARY_API inline void unlockUdaThread(CLIENT_FLAGS* client_flags) + { + udaUnlockThread(); + } + + LIBRARY_API inline void freeIdamThread(CLIENT_FLAGS* client_flags) + { + udaFreeThread(); + } + +#else + + LIBRARY_API inline DATA_BLOCK* acc_getCurrentDataBlock() + { + return udaGetCurrentDataBlock(); + } + + LIBRARY_API inline void unlockUdaThread() + { + udaUnlockThread(); + } + + LIBRARY_API inline void freeIdamThread() + { + udaFreeThread(); + } +``` diff --git a/docs/client_installation.md b/docs/client_installation.md index 06b67cf2..1318dd3a 100644 --- a/docs/client_installation.md +++ b/docs/client_installation.md @@ -1,6 +1,351 @@ --- layout: default title: Installing a UDA client +nav_order: 3 --- -TODO: Instructions for installing UDA client \ No newline at end of file +# UDA client installation +{:.no_toc} + +To access data from any remote site hosting an UDA server you will only need to have the UDA client installed on your local machine. +The client-only build is supported on Linux, MacOS, and Windows. + +The UDA client is a C library which exposes a number of API functions for requesting and unpacking data from a remote UDA server. +There are a number of client wrappers which provide an UDA interface in different programming languages, such as Python and C++, +often with a more user-friendly, object-oriented layer over the basic C-API. + +In general, the underlying UDA client library must be fully built and then any number of additional language wrappers can +be built on-top. With the exception on the python wrapper, building any additional wrappers is completely handled by the +project CMake configuration. It's worth noting, however, that pre-built Docker images or python wheels may already be +available for your platform. + +For python specifically, wheels are built for a range of architecure/OS/python-version combinations and all tagged releases +past version 2.7.6 are available to pip install through pypi [here](https://pypi.org/project/uda/). Windows is supported +from version 2.8.0. + +The range of available dockerfiles are stored in the UDA repository [here](https://github.com/ukaea/UDA/tree/main/docker), +although no pre-built images are hosted publicly yet. + +Please raise an [issue](https://github.com/ukaea/uda/issues) on the UDA github repository for feature requests to support +additional client wrapper langauges or additinal platforms for python wheels or docker images. + +## Contents +{:.no_toc} +1. TOC +{:toc} + +## Installing the python pyuda client from pypi + +```sh +python3 -m venv venv +source venv/bin/activate +python -m pip install --upgrade pip +python -m pip install uda +``` + +The python syntax to request a data item would then be: +```py +import pyuda +pyuda.Client.port = 56565 # or custom server port number +pyuda.Client.server = + +client = pyuda.Client() +data_object = client.get('signal-name', source) + +``` + +## Building a docker image + +```sh +wget https://github.com/ukaea/UDA/archive/refs/tags/2.7.6.tar.gz +tar -xzf 2.7.6.tar.gz +cd UDA-2.7.6/docker +docker build -t -f client.ubuntu.22.04.dockerfile +``` + +## Building the client from source + +The following sections describe the installation procedure for the main operating systems supported. +Alternatively see the [CI scripts](https://github.com/ukaea/UDA/blob/main/.github/workflows/cmake.yml) in the UDA +repository for the latest build instructions used to test each release on ubuntu, MacOS, and Windows. +The [docker files](https://github.com/ukaea/UDA/tree/main/docker) can also be a useful reference for other Linux flavours. + +### Ubuntu + +Install dependencies from system package manager. +```sh +sudo apt update && sudo apt install -y \ +git \ +libboost-dev \ +libboost-program-options-dev \ +libssl-dev \ +cmake \ +build-essential \ +libxml2-dev \ +libspdlog-dev \ +ninja-build \ +capnproto \ +libcapnp-dev \ +python3-dev \ +python3-pip \ +python3-venv \ +``` + +Configure the cmake project with desired options. +```sh +cmake -G Ninja -B build . \ + -DBUILD_SHARED_LIBS=ON \ + -DSSLAUTHENTICATION=ON \ + -DCLIENT_ONLY=ON \ + -DENABLE_CAPNP=ON \ + -DCMAKE_INSTALL_PREFIX=install +``` + +Build and install +```sh +cmake --build build -j --config Release --target install +``` + +### Alma + +```sh + dnf install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm && \ + dnf install -y \ + boost-devel \ + openssl-devel \ + libxml2-devel \ + libtirpc-devel \ + fmt fmt-devel \ + spdlog spdlog-devel \ + capnproto capnproto-devel +``` + +Configure the cmake project with desired options +```sh +cmake -B build . \ + -DBUILD_SHARED_LIBS=ON \ + -DSSLAUTHENTICATION=ON \ + -DCLIENT_ONLY=ON \ + -DENABLE_CAPNP=ON \ + -DCMAKE_INSTALL_PREFIX=install +``` + +Build and install +```sh +cmake --build build -j --config Release --target install +``` + +### Centos-7 + +```sh +yum update -y && +yum install -y wget openssl-devel libxml2-devel libtirpc-devel +``` +Build additional dependencies from source +```sh +cd /tmp + +# libfmt +wget https://github.com/fmtlib/fmt/archive/refs/tags/10.0.0.tar.gz +tar xzf 10.0.0.tar.gz +cd fmt-10.0.0 +cmake -Bbuild -H. -DCMAKE_INSTALL_PREFIX=/usr/local -DBUILD_SHARED_LIBS=ON +cmake --build build -j --config Release --target install + +# spdlog +wget https://github.com/gabime/spdlog/archive/refs/tags/v1.11.0.tar.gz +tar xzf v1.11.0.tar.gz +cd spdlog-1.11.0 +cmake -Bbuild -H. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local -DBUILD_SHARED_LIBS=ON +cmake --build build -j --config Release --target install + +# capnproto +wget https://github.com/capnproto/capnproto/archive/refs/tags/v0.10.4.tar.gz +tar xzf v0.10.4.tar.gz +cd capnproto-0.10.4 +cmake -Bbuild -H. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local -DBUILD_SHARED_LIBS=ON +cmake --build build +cmake --install build + +# boost +wget https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.tar.gz +tar xzf boost_1_80_0.tar.gz +cd boost_1_80_0 +./bootstrap.sh --prefix=/usr/local +./b2 --without-python --prefix=/usr/local install +``` + +Configure the cmake project with desired options +```sh +cmake -B build . \ + -DBUILD_SHARED_LIBS=ON \ + -DSSLAUTHENTICATION=ON \ + -DCLIENT_ONLY=ON \ + -DENABLE_CAPNP=ON \ + -DCMAKE_INSTALL_PREFIX=install +``` + +Build and install +```sh +cmake --build build -j --config Release --target install +``` + + +### MacOS +install dependencies using homebrew + +```sh +brew update-reset && brew install \ +git \ +boost \ +openssl \ +cmake \ +pkg-config \ +libxml2 \ +spdlog \ +ninja \ +capnp \ +``` + +Configure the cmake project with desired options +```sh +cmake -G Ninja -B build . \ + -DBUILD_SHARED_LIBS=ON \ + -DSSLAUTHENTICATION=ON \ + -DCLIENT_ONLY=ON \ + -DENABLE_CAPNP=ON \ + -DCMAKE_INSTALL_PREFIX=install +``` + +Build and install +```sh +cmake --build build -j --config Release --target install +``` + +### Windows (MSVC) +install dependencies using vcpkg +```sh +vcpkg install --triplet x64-windows-static-md ` +libxml2 ` +capnproto ` +boost-program-options ` +boost-format ` +boost-algorithm ` +boost-multi-array ` +openssl ` +dlfcn-win32 ` +spdlog +``` + +build the xdr/rpc library bundled with uda for windows +```sh +cmake -Bextlib/build ./extlib ` +-DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake ` +-DVCPKG_TARGET_TRIPLET="x64-windows-static-md" ` +-DVCPKG_HOST_TRIPLET="x64-windows-static-md" ` +-DCMAKE_GENERATOR_PLATFORM=x64 ` +-DBUILD_SHARED_LIBS=OFF ` +-DCMAKE_INSTALL_PREFIX=extlib/install + +cmake --build extlib/build -j --config Release --target install +``` + +configure the cmake project +```sh +$Env:XDR_ROOT = 'extlib/install' +$Env:CMAKE_PREFIX_PATH = 'C:/vcpkg/installed/x64-windows-static-md' +$Env:Boost_DIR = 'C:/vcpkg/installed/x64-windows-static-md/share/boost' +$Env:LibXml2_DIR = 'C:/vcpkg/installed/x64-windows-static-md/share/libxml2' +$Env:CapnProto_DIR = 'C:/vcpkg/installed/x64-windows-static-md/share/capnproto' +$Env:fmt_DIR = 'C:/vcpkg/installed/x64-windows-static-md/share/fmt' + +cmake -Bbuild . ` +-DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake ` +-DVCPKG_TARGET_TRIPLET="x64-windows-static-md" ` +-DVCPKG_HOST_TRIPLET="x64-windows-static-md" ` +-DCMAKE_GENERATOR_PLATFORM=x64 ` +-DBUILD_SHARED_LIBS=ON ` +-DSSLAUTHENTICATION=ON ` +-DCLIENT_ONLY=ON ` +-DENABLE_CAPNP=ON ` +-DNO_JAVA_WRAPPER=ON ` +-DNO_CXX_WRAPPER=ON ` +-DNO_IDL_WRAPPER=ON ` +-DNO_CLI=ON ` +-DNO_MEMCACHE=ON ` +-DCMAKE_INSTALL_PREFIX=install +``` + +Build and install +```sh +cmake --build build -j --config Release --target install +``` + +### Windows (MinGW) + +Install dependencies using vcpkg +```sh +vcpkg install --triplet x64-mingw-static ` +libxml2 ` +capnproto ` +boost-program-options ` +boost-format ` +boost-algorithm ` +boost-multi-array ` +openssl ` +dlfcn-win32 ` +spdlog ` +``` + +build the xdr/rpc library bundled with uda for windows +```sh +cd extlib +cmake -B build -G "MinGW Makefiles" . ` +-DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake ` +-DCMAKE_INSTALL_PREFIX=install +cmake --build build -j --config Release --target install + +``` + +Configure the cmake project with desired options +```sh +$Env:XDR_ROOT = 'extlib/install' +cmake -B build . ` + -DBUILD_SHARED_LIBS=ON ` + -DSSLAUTHENTICATION=ON ` + -DCLIENT_ONLY=ON ` + -DENABLE_CAPNP=ON ` + -DCMAKE_INSTALL_PREFIX=install + +``` + +Build and install +```sh +cmake --build build -j --config Release --target install +``` + + + +## Testing client build using the UDA CLI + +```sh +cd /bin +./uda_cli --host --port 56565 --request "help::help()" --source "" +``` + +## Building the pyuda python wrapper + +After successful client library build there will be a directory called `python_installer` from which you can pip install pyuda, this command will also compile the cython part of the pyuda module. + +```sh +cd /python_installer +python3 -m venv venv +source venv/bin/activate +python3 -m pip install --upgrade pip wheel +python3 -m pip install "numpy<2" cython six +python3 -m pip install . + +# test +python3 -c 'import pyuda; print(pyuda.__version__)' +``` + diff --git a/docs/creating_plugins.md b/docs/creating_plugins.md index bc56a98c..8a0da05d 100644 --- a/docs/creating_plugins.md +++ b/docs/creating_plugins.md @@ -1,6 +1,7 @@ --- layout: default title: Creating a UDA plugin +nav_order: 2 --- ## UDA plugin @@ -125,4 +126,4 @@ requests. The plugin object is static as data can be cached between calls to avo for example holding onto file handles to avoid re-opening files. You can use the structure as provided or implement the functionality however you desire as long as each call -to the entry function handles the function requested and returns an error code accordingly. \ No newline at end of file +to the entry function handles the function requested and returns an error code accordingly. diff --git a/docs/development.md b/docs/development.md index 730d5827..1b893136 100644 --- a/docs/development.md +++ b/docs/development.md @@ -1,6 +1,7 @@ --- layout: default title: UDA Development +nav_order: 5 --- TODO: UDA Development instructions diff --git a/docs/server_installation.md b/docs/server_installation.md index 8620ed75..bd92dc99 100644 --- a/docs/server_installation.md +++ b/docs/server_installation.md @@ -1,13 +1,14 @@ --- layout: default title: Server Installation +nav_order: 4 --- ## Prerequisites | Name | Minimum Version | |-------------------|--------------------------| -| C++ compiler | c++11 compliant compiler | +| C++ compiler | c++17 compliant compiler | | CMake | 3.0 | | Boost | 1.65 | | OpenSSL version 1 | 1.1 | @@ -17,7 +18,7 @@ title: Server Installation ## Supported OSs -UDA has been build on Linux, macOS and Windows. +The UDA server can been build on Linux and macOS. Note that the server will not run on Windows; only the client installation is supported. ## Builing UDA @@ -54,4 +55,4 @@ cmake --build build ```bash cmake --install build -``` \ No newline at end of file +``` diff --git a/source/client/legacy_accAPI.h b/source/client/legacy_accAPI.h index 0e285133..4cad3ae0 100644 --- a/source/client/legacy_accAPI.h +++ b/source/client/legacy_accAPI.h @@ -12,7 +12,7 @@ extern "C" { #ifdef UDA_CLIENT_FLAGS_API // #warning "Using legacy API names with redundant \"client_flags\" arguments, these will be deprecated in future" - LIBRARY_API inline DATA_BLOCK* acc_getCurrentDataBlock(CLIENT_FLAGS* client_flags) + LIBRARY_API inline DATA_BLOCK* acc_getCurrentDataBlock(CLIENT_FLAGS* client_flags) { return udaGetCurrentDataBlock(); } @@ -59,7 +59,7 @@ extern "C" { LIBRARY_API inline void resetIdamProperties(CLIENT_FLAGS* client_flags) { - udaResetProperties(); + udaResetProperties(); } CLIENT_BLOCK saveIdamProperties(const CLIENT_FLAGS* client_flags) @@ -141,7 +141,7 @@ extern "C" { LIBRARY_API inline void resetIdamProperties() { - udaResetProperties(); + udaResetProperties(); } LIBRARY_API inline CLIENT_BLOCK saveIdamProperties()