# StreamCacheServer

## Types

| Config

## Type Aliases

std::function< void( `LogCategory` cat, std::string const &message)> | `LogCallback`
std::function< void(int cat, std::string const &message)> | `LwsLogCallback`
std::function< void(std::string const &message)> | `MessageCallback`
std::function< void(uint32_t rx, uint32_t tx, `StreamTerminatorState` terminator)> | `DataCallback`
std::function< void()> | `NotifyCallback`

## Functions

TS3D_API_EXPORT | `StreamCacheServer`
TS3D_API_EXPORT | `~StreamCacheServer`
TS3D_API_EXPORT | `StreamCacheServer`
TS3D_API_EXPORT StreamCacheServer & | `operator=`
| `StreamCacheServer`
StreamCacheServer & | `operator=`
TS3D_API_EXPORT bool | `Init`
TS3D_API_EXPORT void | `Tick`
TS3D_API_EXPORT void | `Stop`

## Detailed Description

class `StreamCacheServer`

  Allows an application to connect to a web-viewer client and stream CAD model data to it

  Public Types

  using `LogCallback` = std::function<void(LogCategory cat, std::string const &message)>

    Function signature used for configuring stream-cache diagnostic logging callbacks

  using `LwsLogCallback` = std::function<void(int cat, std::string const &message)>

    Function signature used for configuring the libwebsockets logging callback.

  using `MessageCallback` = std::function<void(std::string const &message)>

    Function signature used for configuring stream-cache callbacks

  using `DataCallback` = std::function<void(uint32_t rx, uint32_t tx, StreamTerminatorState terminator)>

    Function signature used for configuring stream-cache I/O stats callbacks

  using `NotifyCallback` = std::function<void()>

    Function signature used for configuring stream-cache notify callbacks

  Public Functions

  TS3D_API_EXPORT `StreamCacheServer`()
  TS3D_API_EXPORT `~StreamCacheServer`()
  TS3D_API_EXPORT `StreamCacheServer`(StreamCacheServer&&)
  `TS3D_API_EXPORT StreamCacheServer & operator= (StreamCacheServer &&)`
  `StreamCacheServer`(StreamCacheServer const&) = delete
  StreamCacheServer &`operator=`(StreamCacheServer const&) = delete
  `TS3D_API_EXPORT bool Init (Config const &config, std::string &errorMessage)`

    Initializes the stream-cache using the given configuration. This must be called before the stream-cache can accept incoming connections and perform any model streaming, and must only be called once.

    Parameters: | config – The configuration to be used for the stream-cache server. errorMessage – Will contain an error message if the initialization failed, otherwise will be returned as empty.
    Returns: | true if the initialization succeeded, else false.

  `TS3D_API_EXPORT void Tick (std::chrono::milliseconds timeout=std::chrono::milliseconds{ -1 })`

    Performs a stream-cache processing cycle which will service the client connection and stream out model data. The function will return after completion of the cycle which is relatively short, and is therefore intended to be called repeatedly from within a loop.

    After the cycle is complete, if a positive timeout value was set either via the configuration ‘tickTimeout’ setting, or by the ‘timeout’ function argument, then the function will sleep for that specified amount of time. This will ensure the current thread yields and allows other threads processing time.

    Parameters: | timeout – Optional parameter that, when set to a positive value, will override the configuration ‘tickTimeout’ value and cause the tick() function to sleep at the end of its processing cycle.

  `TS3D_API_EXPORT void Stop ()`

    Shuts down the stream-cache and performs any final cleanup. After calling this, the tick() function should not be called again.

  struct `Config`

    Use to configure the various settings used by the stream-cache.

    Public Members

    uint16_t `port` = 0

      A networking port used for websocket communications with the web-viewer client.

    RenderingLocation `enabledRenderingLocations` = RenderingLocation::RenderingLocationDefault

      Determines if client and/or server rendering is allowed. It’s valid to set either mode, or both. The web-viewer will request the type of rendering when it first connects, and will only succeeded if the matching type has been enabled with this setting.

    std::string `license`

      A valid HOOPS Visualize Web license must be specified

    SC::Store::MemoryDevice *`memoryDevice` = nullptr

      An optional stream-cache memory device which is useful for sandboxing file I/O within application memory. See sc_store.h for more information. If this is set to a valid memory device, the paths defined by ‘workspaceDir’ and ‘modelSearchDirs’ must point to directories within this device. If it is null, then those directories will be interpreted within the standard filesystem or inside the given fileSystem if not null.

    SC::IO::AbstractFilesystem *`fileSystem` = nullptr

      An optional custom file system interface to customize how the server read and write files. Will be ignored if memoryDevice is already defined. See sc_io.h for more information.

    std::string `workspaceDir`

      An optional path to a directory that will be used for temporary storage. If this setting is empty, the current working directory will be used.

    std::string `modelSearchDirs`

      A list of directory paths to be used when searching for a model file. This is a single string with each directory path concatenated, and using a single semi-colon character to separate each path.

    std::string `modelFile`

      An optional relative-only file path that, when set to a non-empty string, will override any model requested by the web-viewer client. This should be a model file name that exists within the specified ‘modelSearchDirs’ setting. ie. “bnc”.

    std::string `sessionToken`

      An optional token that must be shared with the web-viewer client. The string is simply compared for equality against the session token provided by the client, thus there is no format specification.

    std::string `sslCertificateFile`

      A file path to an SSL certificate, which is needed to support the ‘wss’ protocol.

    std::string `sslPrivateKeyFile`

      A file path to an SSL private key, which is needed to support the ‘wss’ protocol.

    uint32_t `ssrGpuIndex` = std::numeric_limits<uint32_t>::max()

      Optional 0-based index for specifying which GPU to be used. If set to ‘std::numeric_limits<uint32_t>::max()’, then the server will use the default GPU

    std::chrono::milliseconds `tickTimeout` = std::chrono::milliseconds{-1}

      Indicates the amount of time that the tick() function will sleep for after performing a work cycle. The value here will set the internal default used when the tick() function is called with no value. It can be overridden by providing an explicit value to the tick() function. A negative value will result in the tick() call not sleeping after the work cycle.

    bool `kickOnNewConnection` = false

      When true, this indicates that this stream-cache session should should allow a new web-viewer connection to take priority over the existing connection. If this happens, the existing connection will be closed, and the new connection can proceed.

    std::string `rpcLogFileWrite`

      Specifies an optional file path that will be used to record server-side rendering commands for later replay via the ‘rpcLogFileRead’ setting.

    std::string `rpcLogFileRead`

      Specifies an optional file path to a server-side rendering log session that will be replayed upon a “bounding” event trigger

    bool `verboseLogging` = false

      If true, increased diagnostic messages will be sent to the onDebug callback.

    LwsLogCategory `lwsLogLevel` = LwsLogCategoryNone

      This will set the enabled log-levels for the internal libwebsocket library. It can be a bitwise-or of LwsLogCategory values.

    LwsLogCallback `onLwsLog`

      Optional function that will receive the libwebsocket log messages that were enabled by the ‘lowLogLevel’ setting.

    LogCallback `onLog`

      Optional function that will receive a stream-cache log messages

    MessageCallback `onDisconnect`

      Optional function that will be called upon a client disconnect. The message indicates why the client disconnected.

    DataCallback `onData`

      Optional function that will be called with incremental data transmit and receive statistics.

    NotifyCallback `onInitialUse`

      Optional function that will be called upon the initial client connection

    bool `ssrEgl` = false

      If true, and the server is running on a Linux system, will use EGL for OpenGL context creation in the case of Server Side Rendering. The use of this option is recommended for headless server environments which are equipped with graphics cards.

Conversation saved
HOOPSY BETA

### Hello! I'm HOOPSY

Your Docs generative AI assistant. Ask me anything about HOOPS Visualize Web or choose a sample question below to start a conversation:

What is HOOPS Visualize Web?
What are the latest release notes for HOOPS Visualize Web?
How do I start evaluating HOOPS Visualize Web?
How do I write my first sample application?
How can I get assistance?

HOOPSY may store conversations according to OpenAI's policy. Responses may not always be accurate.

HOOPSY is thinking...