text:
#ifndef AUDIO_CODING_MODULE_IMPL_H
#define AUDIO_CODING_MODULE_IMPL_H

#include "acm_codec_database.h"
#include "acm_neteq.h"
#include "acm_resampler.h"
#include "common_types.h"
#include "engine_configurations.h"

namespace webrtc {

class ACMDTMFDetection;
class ACMGenericCodec;
class CriticalSectionWrapper;
class RWLockWrapper;

//#define TIMED_LOGGING

#ifdef TIMED_LOGGING
    #include "../test/timedtrace.h"
#endif

#ifdef ACM_QA_TEST
#   include <stdio.h>
#endif

class AudioCodingModuleImpl : public AudioCodingModule
{
public:
    // constructor
    AudioCodingModuleImpl(
        const WebRtc_Word32 id);

    // destructor
    ~AudioCodingModuleImpl();

    // get version information for ACM and all components
    WebRtc_Word32 Version(
        WebRtc_Word8*   version,
        WebRtc_UWord32& remainingBufferInBytes,
        WebRtc_UWord32& position) const;

    // change the unique identifier of this object
    virtual WebRtc_Word32 ChangeUniqueId(
        const WebRtc_Word32 id);

    // returns the number of milliseconds until the module want
    // a worker thread to call Process
    WebRtc_Word32 TimeUntilNextProcess();

    // Process any pending tasks such as timeouts
    WebRtc_Word32 Process();

    // used in conference to go to and from active encoding, hence
    // in and out of mix
    WebRtc_Word32 SetMode(
        const bool passive);

    /////////////////////////////////////////
    //   Sender
    //

    // initialize send codec
    WebRtc_Word32 InitializeSender();

    // reset send codec
    WebRtc_Word32 ResetEncoder();

    // can be called multiple times for Codec, CNG, RED
    WebRtc_Word32 RegisterSendCodec(
        const CodecInst& sendCodec);

    // get current send codec
    WebRtc_Word32 SendCodec(
        CodecInst& currentSendCodec) const;

    // get current send freq
    WebRtc_Word32 SendFrequency() const;

    // Get encode bitrate
    // Adaptive rate codecs return their current encode target rate, while other codecs
    // return there longterm avarage or their fixed rate.
    WebRtc_Word32 SendBitrate() const;

    // set available bandwidth, inform the encoder about the
    // estimated bandwidth received from the remote party
    virtual WebRtc_Word32 SetReceivedEstimatedBandwidth(
        const WebRtc_Word32 bw);

    // register a transport callback which will be
    // called to deliver the encoded buffers
    WebRtc_Word32 RegisterTransportCallback(
        AudioPacketizationCallback* transport);

    // Used by the module to deliver messages to the codec module/application
    // AVT(DTMF)
    WebRtc_Word32 RegisterIncomingMessagesCallback(
        AudioCodingFeedback* incomingMessagesCallback,
        const ACMCountries cpt);

     // Add 10MS of raw (PCM) audio data to the encoder
    WebRtc_Word32 Add10MsData(
        const AudioFrame& audioFrame);

    // set background noise mode for NetEQ, on, off or fade
    WebRtc_Word32 SetBackgroundNoiseMode(
        const ACMBackgroundNoiseMode mode);

    // get current background noise mode
    WebRtc_Word32 BackgroundNoiseMode(
        ACMBackgroundNoiseMode& mode);

    /////////////////////////////////////////
    // (FEC) Forward Error Correction
    //

    // configure FEC status i.e on/off
    WebRtc_Word32 SetFECStatus(
        const bool enable);

    // Get FEC status
    bool FECStatus() const;

    /////////////////////////////////////////
    //   (VAD) Voice Activity Detection
    //   and
    //   (CNG) Comfort Noise Generation
    //

    WebRtc_Word32 SetVAD(
        const bool             enableDTX = true,
        const bool             enableVAD = false,
        const ACMVADMode vadMode   = VADNormal);

    WebRtc_Word32 VAD(
        bool&             dtxEnabled,
        bool&             vadEnabled,
        ACMVADMode& vadMode) const;

    WebRtc_Word32 RegisterVADCallback(
        ACMVADCallback* vadCallback);

    // Get VAD status on the incoming stream
    bool ReceiveVADStatus() const;

    // configure VAD status i.e on/off on the incoming stream
    WebRtc_Word16 SetReceiveVADStatus(
        const bool enable);

    // Get VAD aggressiveness on the incoming stream
    ACMVADMode ReceiveVADMode() const;

    // Configure VAD aggressiveness on the incoming stream
    WebRtc_Word16 SetReceiveVADMode(
        const ACMVADMode mode);

    /////////////////////////////////////////
    //   Receiver
    //

    // initialize receiver, resets codec database etc
    WebRtc_Word32 InitializeReceiver();

    // reset the decoder state
    WebRtc_Word32 ResetDecoder();

    // get current receive freq
    WebRtc_Word32 ReceiveFrequency() const;

    // get current playout freq
    WebRtc_Word32 PlayoutFrequency() const;

    // register possible reveive codecs, can be called multiple times,
    // for codecs, CNG, DTMF, RED
    WebRtc_Word32 RegisterReceiveCodec(
        const CodecInst& receiveCodec);

    // get current received codec
    WebRtc_Word32 ReceiveCodec(
        CodecInst& currentReceiveCodec) const;

    // incoming packet from network parsed and ready for decode
    WebRtc_Word32 IncomingPacket(
        const WebRtc_Word8*    incomingPayload,
        const WebRtc_Word32    payloadLength,
        const WebRtcRTPHeader& rtpInfo);

    // Incoming payloads, without rtp-info, the rtp-info will be created in ACM.
    // One usage for this API is when pre-encoded files are pushed in ACM.
    WebRtc_Word32 IncomingPayload(
        const WebRtc_Word8*  incomingPayload,
        const WebRtc_Word32  payloadLength,
        const WebRtc_UWord8  payloadType,
        const WebRtc_UWord32 timestamp = 0);

    // Minimum playout dealy (Used for lip-sync)
    WebRtc_Word32 SetMinimumPlayoutDelay(
        const WebRtc_Word32 timeMs);

    // current play out delay
    WebRtc_Word32 Delay(WebRtc_UWord16& delayMs) const;

    // configure Dtmf playout status i.e on/off playout the incoming outband Dtmf tone
    WebRtc_Word32 SetDtmfPlayoutStatus(
        const bool enable);

    // Get Dtmf playout status
    bool DtmfPlayoutStatus() const;

    // Estimate the Bandwidth based on the incoming stream
    // This is also done in the RTP module
    // need this for one way audio where the RTCP send the BW estimate
    WebRtc_Word32 DecoderEstimatedBandwidth() const;

    // Set playout mode voice, fax
    WebRtc_Word32 SetPlayoutMode(
        const AudioPlayoutMode mode);

    // Get playout mode voice, fax
    AudioPlayoutMode PlayoutMode() const;

    // Get playout timestamp
    WebRtc_Word32 PlayoutTimestamp(
        WebRtc_UWord32& timestamp);

    // Get 10 milliseconds of raw audio data to play out
    // automatic resample to the requested frequency if > 0
    WebRtc_Word32 PlayoutData10Ms(
        const WebRtc_Word32   desiredFreqHz,
        AudioFrame            &audioFrame);

    /////////////////////////////////////////
    //   Statistics
    //

    WebRtc_Word32  NetworkStatistics(
        ACMNetworkStatistics& statistics) const;

    WebRtc_Word32  JitterStatistics(
        ACMJitterStatistics& jitterStatistics) const;

    WebRtc_Word32  PreferredBufferSize(
        WebRtc_UWord16& prefbufsize) const;

    WebRtc_Word32  ResetJitterStatistics() const;

    void DestructEncoderInst(void* ptrInst);

    WebRtc_Word16 AudioBuffer(WebRtcACMAudioBuff& audioBuff);

    // GET RED payload for iSAC. The method id called
    // when 'this' ACM is default ACM.
    WebRtc_Word32 REDPayloadISAC(
        const WebRtc_Word32  isacRate,
        const WebRtc_Word16  isacBwEstimate,
        WebRtc_UWord8*       payload,
        WebRtc_Word16*       payloadLenByte);

    WebRtc_Word16 SetAudioBuffer(WebRtcACMAudioBuff& audioBuff);

    WebRtc_UWord32 EarliestTimestamp() const;

    WebRtc_Word32 LastEncodedTimestamp(WebRtc_UWord32& timestamp) const;

    WebRtc_Word32 ReplaceInternalDTXWithWebRtc(
        const bool useWebRtcDTX);

    WebRtc_Word32 IsInternalDTXReplacedWithWebRtc(
        bool& usesWebRtcDTX);

    WebRtc_Word32 SetISACMaxRate(
        const WebRtc_UWord32 rateBitPerSec);

    WebRtc_Word32 SetISACMaxPayloadSize(
        const WebRtc_UWord16 payloadLenBytes);

    WebRtc_Word32 ConfigISACBandwidthEstimator(
        const WebRtc_UWord8  initFrameSizeMsec,
        const WebRtc_UWord16 initRateBitPerSec,
        const bool           enforceFrameSize = false);

    WebRtc_Word32 UnregisterReceiveCodec(
        const WebRtc_Word16 payloadType);

protected:
    void UnregisterSendCodec();

    WebRtc_Word32 UnregisterReceiveCodecSafe(
        const WebRtc_Word16 codecID);

    ACMGenericCodec* CreateCodec(
        const CodecInst& codec);

    WebRtc_Word16 DecoderParamByPlType(
        const WebRtc_UWord8    payloadType,
        WebRtcACMCodecParams&  codecParams) const;

    WebRtc_Word16 DecoderListIDByPlName(
        const WebRtc_Word8*  payloadName,
        const WebRtc_UWord16 sampFreqHz = 0) const;

    WebRtc_Word32 InitializeReceiverSafe();

    bool HaveValidEncoder(const WebRtc_Word8* callerName) const;

    WebRtc_Word32 RegisterRecCodecMSSafe(
        const CodecInst& receiveCodec,
        WebRtc_Word16         codecId,
        WebRtc_Word16         mirrorId,
        ACMNetEQ::JB          jitterBuffer);

private:
    AudioPacketizationCallback*    _packetizationCallback;
    WebRtc_Word32                  _id;
    WebRtc_UWord32                 _lastTimestamp;
    WebRtc_UWord32                 _lastInTimestamp;
    CodecInst                      _sendCodecInst;
    CodecInst                      _cngNB;
    CodecInst                      _cngWB;
    CodecInst                      _cngSWB;
    CodecInst                      _RED;
    bool                           _REDRegistered;
    CodecInst                      _DTMF;
    bool                           _DTMFRegistered;
    bool                           _vadEnabled;
    bool                           _dtxEnabled;
    ACMVADMode                     _vadMode;
    ACMGenericCodec*               _codecs[MAX_NR_OF_CODECS];
    ACMGenericCodec*               _slaveCodecs[MAX_NR_OF_CODECS];
    WebRtc_Word16                  _mirrorCodecIdx[MAX_NR_OF_CODECS];
    bool                           _stereoReceive[MAX_NR_OF_CODECS];
    bool                           _stereoSend;
    WebRtc_Word32                  _currentSendCodecIdx;
    bool                           _sendCodecRegistered;
    ACMResampler                   _inputResampler;
    ACMResampler                   _outputResampler;
    ACMNetEQ                       _netEq;
    CriticalSectionWrapper*        _acmCritSect;
    ACMVADCallback*                _vadCallback;
    WebRtc_UWord8                  _lastRecvAudioCodecPlType;

    // RED/FEC
    bool                           _isFirstRED;
    bool                           _fecEnabled;
    WebRtc_UWord8*                 _redBuffer;
    RTPFragmentationHeader*        _fragmentation;
    WebRtc_UWord32                 _lastFECTimestamp;
    WebRtc_UWord8                  _redPayloadType;
    // if no RED is registered as receive codec this
    // will have an invalid value.
    WebRtc_UWord8                  _receiveREDPayloadType;

    // This is to keep track of CN instances where we can send DTMFs
    WebRtc_UWord8                  _previousPayloadType;

    // This keeps track of payload types associated with _codecs[].
    // We define it as signed variable and initialize with -1 to indicate
    // unused elements.
    WebRtc_Word16                  _registeredPlTypes[MAX_NR_OF_CODECS];

    // Used when payloads are pushed into ACM without any RTP info
    // One example is when pre-encoded bit-stream is pushed from
    // a file.
    WebRtcRTPHeader*               _dummyRTPHeader;
    WebRtc_UWord16                 _recvPlFrameSizeSmpls;

    bool                           _receiverInitialized;
    ACMDTMFDetection*              _dtmfDetector;

    AudioCodingFeedback*           _dtmfCallback;
    WebRtc_Word16                  _lastDetectedTone;
    CriticalSectionWrapper*        _callbackCritSect;
#ifdef TIMED_LOGGING
    TimedTrace                     _trace;
#endif

#ifdef ACM_QA_TEST
    FILE* _outgoingPL;
    FILE* _incomingPL;
#endif

};

} // namespace webrtc

#endif


text:
<root>
  <facet id="jst.jsf">
    <node name="libprov">
      <attribute name="provider-id" value="jsf-user-library-provider"/>
    </node>
  </facet>
</root>

redpajama_set_name: RedPajamaGithub


text:
require 'spec_helper'

describe 'pm2::nodejs' do
  cached(:chef_run) { ChefSpec::Runner.new.converge(described_recipe) }
  cached(:node) { chef_run.node }

  it 'include the nodejs recipe' do
    expect(chef_run).to include_recipe('nodejs')
  end
end


text:
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/.idea/allotrope-js.iml" filepath="$PROJECT_DIR$/.idea/allotrope-js.iml" />
    </modules>
  </component>
</project>


text:
  * Brandon S Allbery [GitHub][geekosaur], IRC: `geekosaur`, [GPG][gpg:geekosaur]

  * Brent Yorgey [GitHub][byorgey], IRC: `byorgey`

  * Daniel Wagner [GitHub][dmwit], [Twitter][twitter:dmwit], IRC: `dmwit`

  * Sibi Prabakaran [GitHub][psibi], [Twitter][twitter:psibi], IRC: `sibi`

  * Tomáš Janoušek [GitHub][liskin], [Twitter][twitter:liskin], IRC: `liskin`, [GPG][gpg:liskin]

  * Tony Zorman [GitHub][slotThe], IRC: `Solid`, [GPG][gpg:slotThe]

[geekosaur]: https://github.com/geekosaur
[byorgey]: https://github.com/byorgey
[dmwit]: https://github.com/dmwit
[psibi]: https://github.com/psibi
[liskin]: https://github.com/liskin
[slotThe]: https://github.com/slotThe

[gpg:geekosaur]: https://github.com/geekosaur.gpg
[gpg:liskin]: https://github.com/liskin.gpg
[gpg:slotThe]: https://github.com/slotThe.gpg

[twitter:dmwit]: https://twitter.com/dmwit13
[twitter:psibi]: https://twitter.com/psibi
[twitter:liskin]: https://twitter.com/Liskni_si

## Hall of Fame (past maintainers/developers)

  * Adam Vogt [GitHub](https://github.com/aavogt)

  * Peter Simons [GitHub](https://github.com/peti), [Twitter](https://twitter.com/OriginalPeti)

  * Spencer Janssen [GitHub](https://github.com/spencerjanssen)

  * Don Stewart [GitHub](https://github.com/donsbot), [Twitter](https://twitter.com/donsbot)

  * Jason Creighton [GitHub](https://github.com/JasonCreighton)

  * David Roundy [GitHub](https://github.com/droundy)

  * Daniel Schoepe [GitHub](https://github.com/dschoepe)

  * Eric Mertens [GitHub](https://github.com/glguy)

  * Nicolas Pouillard [GitHub](https://github.com/np)

  * Roman Cheplyaka [GitHub](https://github.com/UnkindPartition)

  * Gwern Branwen [GitHub](https://github.com/gwern)

  * Lukas Mai [GitHub](https://github.com/mauke)

  * Braden Shepherdson [GitHub](https://github.com/shepheb)

  * Devin Mullins [GitHub](https://github.com/twifkak)

  * David Lazar [GitHub](https://github.com/davidlazar)

  * Peter J. Jones [GitHub](https://github.com/pjones)

## Release Procedures

When the time comes to release another version of xmonad and xmonad-contrib:

  1. Update the version number in all the `*.cabal` files and let the CI
     verify that it all builds together.

  2. Review documentation files and make sure they are accurate:

     - [`README.md`](README.md)
     - [`CHANGES.md`](CHANGES.md) (bump version, set date)
     - [`INSTALL.md`](INSTALL.md)
     - [`man/xmonad.1.markdown.in`](man/xmonad.1.markdown.in)
     - [haddocks](https://xmonad.github.io/xmonad-docs/)

     If the manpage changes, wait for the CI to rebuild the rendered outputs.

  3. Update the website:

     - Draft a [new release announcement][web-announce].
     - Check install instructions, guided tour, keybindings cheat sheet, …

  4. Make sure that `tested-with:` covers several recent releases of GHC, that
     `.github/workflows/haskell-ci.yml` had been updated to test all these GHC
     versions and that `.github/workflows/stack.yml` tests with several recent
     revisions of [Stackage][] LTS.

  5. Trigger the Haskell-CI workflow and fill in the candidate version number.
     This will upload a release candidate to Hackage.

     - https://github.com/xmonad/xmonad/actions/workflows/haskell-ci.yml
     - https://github.com/xmonad/xmonad-contrib/actions/workflows/haskell-ci.yml

     Check that everything looks good. If not, push fixes and do another
     candidate. When everything's ready, create a release on GitHub:

     - https://github.com/xmonad/xmonad/releases/new
     - https://github.com/xmonad/xmonad-contrib/releases/new

     CI will automatically upload the final release to Hackage.

     See [haskell-ci-hackage.patch][] for details about the Hackage automation.

  6. Post announcement to:

     - [xmonad.org website](https://github.com/xmonad/xmonad-web/tree/gh-pages/news/_posts)
     - [XMonad mailing list](https://mail.haskell.org/mailman/listinfo/xmonad)
     - [Haskell Cafe](https://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe)
     - [Haskell Discourse](https://discourse.haskell.org/)
     - [Twitter](https://twitter.com/xmonad)
     - [Reddit](https://www.reddit.com/r/xmonad/)

     See [old announcements][old-announce] ([even older][older-announce]) for inspiration.

  7. Bump version for development (add `.9`) and prepare fresh sections in
     [`CHANGES.md`](CHANGES.md).

[packdeps]: https://hackage.haskell.org/package/packdeps
[Stackage]: https://www.stackage.org/
[haskell-ci-hackage.patch]: .github/workflows/haskell-ci-hackage.patch
[web-announce]: https://github.com/xmonad/xmonad-web/tree/gh-pages/news/_posts
[old-announce]: https://github.com/xmonad/xmonad-web/blob/gh-pages/news/_posts/2021-10-27-xmonad-0-17-0.md
[older-announce]: https://github.com/xmonad/xmonad-web/tree/55614349421ebafaef4a47424fcb16efa80ff768

## Website and Other Accounts

* The [xmonad twitter] is tended to by [liskin].

* The [xmonad.org] domain is owned by [eyenx] and the website itself is
  deployed via GitHub Pages.  It can be updated by making a pull request
  against the [xmonad-web] repository.

[eyenx]: https://github.com/eyenx
[xmonad-web]: https://github.com/xmonad/xmonad-web/
[xmonad.org]: https://xmonad.org/
[xmonad twitter]: https://twitter.com/xmonad


text:
// Copyright 2021 Jon Skeet. All rights reserved.
// Use of this source code is governed by the Apache License 2.0,
// as found in the LICENSE.txt file.

namespace OscMixerControl
{
    public enum TimeFactor
    {
        /// <summary>
        /// About 200 updates over 10 seconds.
        /// </summary>
        Fast = 0,

        /// <summary>
        /// About 100 updates over 10 seconds.
        /// </summary>
        Medium = 2,

        /// <summary>
        /// About 5 updates over 10 seconds.
        /// </summary>
        Slow = 40,

        /// <summary>
        /// About 3 updates over 10 seconds.
        /// </summary>
        VerySlow = 80
    }
}


text:
.App-logo {
  animation: App-logo-spin infinite 20s linear;
  height: 80px;
}

.App-header {
  background-color: #222;
  height: 150px;
  padding: 20px;
  color: white;
}

@keyframes App-logo-spin {
  from { transform: rotate(0deg); }
  to { transform: rotate(360deg); }
}


text:
package eleme.openapi.sdk.api.service;

import eleme.openapi.sdk.api.annotation.Service;
import eleme.openapi.sdk.api.base.BaseNopService;
import eleme.openapi.sdk.api.exception.ServiceException;
import eleme.openapi.sdk.oauth.response.Token;
import eleme.openapi.sdk.config.Config;
import eleme.openapi.sdk.api.entity.packs.*;
import eleme.openapi.sdk.api.enumeration.packs.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;

/**
 * 签约服务
 */
@Service("eleme.packs")
public class PacksService extends BaseNopService {
    public PacksService(Config config,Token token) {
        super(config, token, PacksService.class);
    }

    /**
     * 查询店铺当前生效合同类型
     *
     * @param shopId 店铺id
     * @return 当前店铺生效的服务包合同类型名称
     * @throws ServiceException 服务异常
     */
    public ShopContract getEffectServicePackContract(Long shopId) throws ServiceException {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("shopId", shopId);
        return call("eleme.packs.getEffectServicePackContract", params);
    }
}


text:
package org.codelibs.elasticsearch.taste.similarity;

import org.codelibs.elasticsearch.taste.common.Weighting;
import org.codelibs.elasticsearch.taste.model.DataModel;

import com.google.common.base.Preconditions;

/**
 *

 * An implementation of the Pearson correlation. For users X and Y, the following values are calculated:
 *

 *
 *

 *
sumX2: sum of the square of all X's preference values

 *
sumY2: sum of the square of all Y's preference values

 *
sumXY: sum of the product of X and Y's preference value for all items for which both X and Y express a
 * preference

 *

 *
 *

 * The correlation is then:
 *
 *

 * {@code sumXY / sqrt(sumX2 * sumY2)}
 *

 *
 *

 * Note that this correlation "centers" its data, shifts the user's preference values so that each of their
 * means is 0. This is necessary to achieve expected behavior on all data sets.
 *

 *
 *

 * This correlation implementation is equivalent to the cosine similarity since the data it receives
 * is assumed to be centered -- mean is 0. The correlation may be interpreted as the cosine of the angle
 * between the two vectors defined by the users' preference values.
 *

 *
 *

 * For cosine similarity on uncentered data, see {@link UncenteredCosineSimilarity}.
 *

 */
public final class PearsonCorrelationSimilarity extends AbstractSimilarity {

    /**
     * @throws IllegalArgumentException if {@link DataModel} does not have preference values
     */
    public PearsonCorrelationSimilarity(final DataModel dataModel) {
        this(dataModel, Weighting.UNWEIGHTED);
    }

    /**
     * @throws IllegalArgumentException if {@link DataModel} does not have preference values
     */
    public PearsonCorrelationSimilarity(final DataModel dataModel,
            final Weighting weighting) {
        super(dataModel, weighting, true);
        Preconditions.checkArgument(dataModel.hasPreferenceValues(),
                "DataModel doesn't have preference values");
    }

    @Override
    double computeResult(final int n, final double sumXY, final double sumX2,
            final double sumY2, final double sumXYdiff2) {
        if (n == 0) {
            return Double.NaN;
        }
        // Note that sum of X and sum of Y don't appear here since they are assumed to be 0;
        // the data is assumed to be centered.
        final double denominator = Math.sqrt(sumX2) * Math.sqrt(sumY2);
        if (denominator == 0.0) {
            // One or both parties has -all- the same ratings;
            // can't really say much similarity under this measure
            return Double.NaN;
        }
        return sumXY / denominator;
    }

}


text:
[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v3.0.0...v3.0.1)

**Merged pull requests:**

- Simplify download URL generation [\#31](https://github.com/chef-partners/dcos-cookbook/pull/31) ([wolf31o2](https://github.com/wolf31o2))

## [v3.0.0](https://github.com/chef-partners/dcos-cookbook/tree/v3.0.0)

**BREAKING CHANGES**

This cookbook has dropped support for DC/OS versions prior to 1.10.0, which are no longer supported by Mesosphere.

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v2.2.0...v3.0.0)

**Merged pull requests:**

- Drop support for DC/OS older than 1.10 [\#29](https://github.com/chef-partners/dcos-cookbook/pull/29) ([wolf31o2](https://github.com/wolf31o2))
- Support DC/OS 1.12.2, 1.11.10, and 1.10.11 [\#30](https://github.com/chef-partners/dcos-cookbook/pull/30) ([wolf31o2](https://github.com/wolf31o2))

## [v2.2.0](https://github.com/chef-partners/dcos-cookbook/tree/v2.2.0)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v2.1.0...v2.2.0)

**Merged pull requests:**

- Support DC/OS 1.12.1, 1.11.8, and 1.11.9 [\#28](https://github.com/chef-partners/dcos-cookbook/pull/28) ([wolf31o2](https://github.com/wolf31o2))

## [v2.1.0](https://github.com/chef-partners/dcos-cookbook/tree/v2.1.0)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v2.0.2...v2.1.0)

**Merged pull requests:**

- Support DC/OS 1.12.0 and 1.11.7 [\#27](https://github.com/chef-partners/dcos-cookbook/pull/27) ([wolf31o2](https://github.com/wolf31o2))

## [v2.0.2](https://github.com/chef-partners/dcos-cookbook/tree/v2.0.2)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v2.0.1...v2.0.2)

**Merged pull requests:**

- Support DC/OS 1.11.5 and 1.11.6 [\#26](https://github.com/chef-partners/dcos-cookbook/pull/26) ([wolf31o2](https://github.com/wolf31o2))

## [v2.0.1](https://github.com/chef-partners/dcos-cookbook/tree/v2.0.1)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v2.0.0...v2.0.1)

**Merged pull requests:**

- Support DC/OS 1.11.4, and latest 1.9 and 1.10 [\#25](https://github.com/chef-partners/dcos-cookbook/pull/25) ([wolf31o2](https://github.com/wolf31o2))

## [v2.0.0](https://github.com/chef-partners/dcos-cookbook/tree/v2.0.0)

**BREAKING CHANGES**

This cookbook has upgraded its dependencies and now requires at least Chef 12.15+

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v1.3.2...v2.0.0)

**Merged pull requests:**

- Use latest docker cookbook [\#24](https://github.com/chef-partners/dcos-cookbook/pull/24) ([wolf31o2](https://github.com/wolf31o2))

## [v1.3.2](https://github.com/chef-partners/dcos-cookbook/tree/v1.3.2)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v1.3.1...v1.3.2)

**Merged pull requests:**

- Support DC/OS 1.11.3 [\#23](https://github.com/chef-partners/dcos-cookbook/pull/23) ([wolf31o2](https://github.com/wolf31o2))

## [v1.3.1](https://github.com/chef-partners/dcos-cookbook/tree/v1.3.1)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v1.3.0...v1.3.1)

**Merged pull requests:**

- Support DC/OS 1.11.2 [\#22](https://github.com/chef-partners/dcos-cookbook/pull/22) ([wolf31o2](https://github.com/wolf31o2))

## [v1.3.0](https://github.com/chef-partners/dcos-cookbook/tree/v1.3.0)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v1.2.3...v1.3.0)

**Merged pull requests:**

- Recipe for DC/OS CLI [\#17](https://github.com/chef-partners/dcos-cookbook/pull/17) ([wolf31o2](https://github.com/wolf31o2))
- Updates from session w/ Justin Lee [\#20](https://github.com/chef-partners/dcos-cookbook/pull/20) ([wolf31o2](https://github.com/wolf31o2)) ([justinrlee](https://github.com/justinrlee))
- Allow disabling scripts using nil source [\#21](https://github.com/chef-partners/dcos-cookbook/pull/21) ([wolf31o2](https://github.com/wolf31o2))

## [v1.2.3](https://github.com/chef-partners/dcos-cookbook/tree/v1.2.3)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v1.2.2...v1.2.3)

**Merged pull requests:**

- Guard cloud fault-domain-detect script when onprem [\#16](https://github.com/chef-partners/dcos-cookbook/pull/16) ([wolf31o2](https://github.com/wolf31o2))
- Helper: dcos_cluster_address [\#18](https://github.com/chef-partners/dcos-cookbook/pull/18) ([wolf31o2](https://github.com/wolf31o2))
- Support DC/OS 1.10.6 and 1.11.1 [\#19](https://github.com/chef-partners/dcos-cookbook/pull/19) ([wolf31o2](https://github.com/wolf31o2))

## [v1.2.2](https://github.com/chef-partners/dcos-cookbook/tree/v1.2.2)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v1.2.1...v1.2.2)

**Merged pull requests:**

- Create a preflight-check execute block [\#15](https://github.com/chef-partners/dcos-cookbook/pull/15) ([wolf31o2](https://github.com/wolf31o2))

## [v1.2.1](https://github.com/chef-partners/dcos-cookbook/tree/v1.2.1)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v1.2.0...v1.2.1)

**Merged pull requests:**

- Remove zookeeper Gem requirements [\#14](https://github.com/chef-partners/dcos-cookbook/pull/14) ([wolf31o2](https://github.com/wolf31o2))

## [v1.2.0](https://github.com/chef-partners/dcos-cookbook/tree/v1.2.0)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v1.1.0...v1.2.0)

**Merged pull requests:**

- Add dcos_user custom resource [\#10](https://github.com/chef-partners/dcos-cookbook/pull/10) ([rbanffy](https://github.com/rbanffy))
- Support DC/OS Enterprise [\#13](https://github.com/chef-partners/dcos-cookbook/pull/13) ([wolf31o2](https://github.com/wolf31o2))

## [v1.1.0](https://github.com/chef-partners/dcos-cookbook/tree/v1.1.0)

[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v1.0.0...v1.1.0)

**Merged pull requests:**

- Support latest DC/OS 1.9 and 1.10 versions [\#9](https://github.com/chef-partners/dcos-cookbook/pull/9) ([wolf31o2](https://github.com/wolf31o2))

## [v1.0.0](https://github.com/chef-partners/dcos-cookbook/tree/v1.0.0) (2017-11-13)
[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v0.3.1...v1.0.0)

**Merged pull requests:**

- Support multiple versions of DC/OS [\#8](https://github.com/chef-partners/dcos-cookbook/pull/8) ([wolf31o2](https://github.com/wolf31o2))

## [v0.3.1](https://github.com/chef-partners/dcos-cookbook/tree/v0.3.1) (2017-08-21)
[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/v0.3.0...v0.3.1)

**Closed issues:**

- Add option for Stable release [\#5](https://github.com/chef-partners/dcos-cookbook/issues/5)

**Merged pull requests:**

- Update cookbook to modern standards [\#7](https://github.com/chef-partners/dcos-cookbook/pull/7) ([wolf31o2](https://github.com/wolf31o2))

## [v0.3.0](https://github.com/chef-partners/dcos-cookbook/tree/v0.3.0) (2017-04-13)
[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/0.2.0...v0.3.0)

**Merged pull requests:**

- Added earlyaccess flip [\#6](https://github.com/chef-partners/dcos-cookbook/pull/6) ([jjasghar](https://github.com/jjasghar))
- Correction to Attribute Value for Public Slave [\#4](https://github.com/chef-partners/dcos-cookbook/pull/4) ([jparten](https://github.com/jparten))

## [0.2.0](https://github.com/chef-partners/dcos-cookbook/tree/0.2.0) (2016-05-10)
[Full Changelog](https://github.com/chef-partners/dcos-cookbook/compare/0.1...0.2.0)

**Merged pull requests:**

- Updates source URL for the dcos\_generate\_config.sh to match dcos.io docs [\#3](https://github.com/chef-partners/dcos-cookbook/pull/3) ([mattray](https://github.com/mattray))

## [0.1](https://github.com/chef-partners/dcos-cookbook/tree/0.1) (2016-04-19)
**Merged pull requests:**

- Initial release [\#1](https://github.com/chef-partners/dcos-cookbook/pull/1) ([mattray](https://github.com/mattray))

\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*


text:
const assemble = require('assemble')
const favicons = require('favicons')
const shell    = require('gulp-shell')

// Favicons generation
// ///////////////////////////////////////////////////////////////////////////////

assemble.task('favicons', function () {
  favicons({
    files: {
        src: null,                // Path(s) for file to produce the favicons. `string` or `object`
        dest: null,               // Path for writing the favicons to. `string`
        html: null,               // Path(s) for HTML file to write or append metadata. `string` or `array`
        iconsPath: null,          // Path for overriding default icons path. `string`
        androidManifest: null,    // Path for an existing android_chrome_manifest.json. `string`
        browserConfig: null,      // Path for an existing browserconfig.xml. `string`
        firefoxManifest: null,    // Path for an existing manifest.webapp. `string`
        yandexManifest: null      // Path for an existing yandex-browser-manifest.json. `string`
    },
    icons: {
        android: true,            // Create Android homescreen icon. `boolean`
        appleIcon: true,          // Create Apple touch icons. `boolean`
        appleStartup: true,       // Create Apple startup images. `boolean`
        coast: true,              // Create Opera Coast icon. `boolean`
        favicons: true,           // Create regular favicons. `boolean`
        firefox: true,            // Create Firefox OS icons. `boolean`
        opengraph: true,          // Create Facebook OpenGraph. `boolean`
        windows: true,            // Create Windows 8 tiles. `boolean`
        yandex: true              // Create Yandex browser icon. `boolean`
    },
    settings: {
        appName: null,            // Your application's name. `string`
        appDescription: null,     // Your application's description. `string`
        developer: null,          // Your (or your developer's) name. `string`
        developerURL: null,       // Your (or your developer's) URL. `string`
        version: 1.0,             // Your application's version number. `number`
        background: null,         // Background colour for flattened icons. `string`
        index: null,              // Path for the initial page on the site. `string`
        url: null,                // URL for your website. `string`
        silhouette: false,        // Turn the logo into a white silhouette for Windows 8. `boolean`
        logging: false            // Print logs to console? `boolean`
    },
    favicon_generation: null,     // Complete JSON overwrite for the favicon_generation object. `object`
  }, function (err, metadata) {
    if (err) throw err;
    console.log(metadata, 'Metadata produced during the build process')
  })
})

// Image minification
// ///////////////////////////////////////////////////////////////////////////////

// Using command line binaries in lieu of gulp-imagemin. More control and
// less dependencies

assemble.task('crush:png', shell.task([
  'echo Starting pngquant ... png images',
  'pngquant -f --ext .png --speed 1 --quality 70-95 *.png',
  'echo Finished pngquant'
], {cwd: 'build/assets/img'}))

assemble.task('crush:jpg', shell.task([
  'echo Starting adept ... jpg imgages',
  'for x in *.jpg; do adept $x; done',
  'echo Finished adept'
], {cwd: 'build/assets/img'}))

assemble.task('crush:svg', shell.task([
  'svgo -f svg'
], {cwd: 'build/assets/img'}))

assemble.task('crush', shell.task([
  'echo Starting ImageOptim ... final processing',
  'open -a ImageOptim .',
  'echo Background processing started.'
], {cwd: 'build/assets/img'}))


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="Suite for creating groups and contacts">
  <test verbose="2" name="Create contacts">
    <classes>
      <class name="com.example.tests.contacts.ContactCreationTests"/>
    </classes>
  </test>
  <test verbose="2" name="Create groups">
    <classes>
      <class name="com.example.tests.groups.GroupCreationTests"/>
    </classes>
  </test>
</suite>


text:
package org.apereo.cas.adaptors.radius.authentication;

import org.apereo.cas.adaptors.radius.web.flow.BaseRadiusMultifactorAuthenticationTests;
import org.apereo.cas.authentication.AuthenticationHandler;
import org.apereo.cas.authentication.CoreAuthenticationTestUtils;
import org.apereo.cas.web.support.WebUtils;

import lombok.val;
import net.jradius.dictionary.Attr_State;
import net.jradius.packet.attribute.value.StringValue;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.mock.web.MockServletContext;
import org.springframework.webflow.context.ExternalContextHolder;
import org.springframework.webflow.context.servlet.ServletExternalContext;
import org.springframework.webflow.execution.RequestContextHolder;
import org.springframework.webflow.test.MockRequestContext;

import javax.security.auth.login.FailedLoginException;
import java.util.List;
import java.util.Map;

import static org.junit.jupiter.api.Assertions.*;

/**
 * This is {@link RadiusTokenAuthenticationHandlerTests}.
 *
 * @author Misagh Moayyed
 * @since 6.3.0
 */
@SpringBootTest(classes = BaseRadiusMultifactorAuthenticationTests.SharedTestConfiguration.class,
    properties = {
        "cas.authn.mfa.radius.server.protocol=PAP",
        "cas.authn.mfa.radius.client.shared-secret=testing123",
        "cas.authn.mfa.radius.client.inet-address=localhost"
    })
@Tag("Radius")
public class RadiusTokenAuthenticationHandlerTests {

    @Autowired
    @Qualifier("radiusTokenAuthenticationHandler")
    private AuthenticationHandler authenticationHandler;

    @Test
    public void verifyOperation() throws Exception {
        val c = new RadiusTokenCredential("Mellon");

        assertTrue(authenticationHandler.supports(c));
        assertTrue(authenticationHandler.supports(c.getClass()));

        val context = new MockRequestContext();
        val request = new MockHttpServletRequest();
        val response = new MockHttpServletResponse();
        context.setExternalContext(new ServletExternalContext(new MockServletContext(), request, response));
        RequestContextHolder.setRequestContext(context);
        ExternalContextHolder.setExternalContext(context.getExternalContext());

        assertThrows(FailedLoginException.class, () -> authenticationHandler.authenticate(c));

        val principal = CoreAuthenticationTestUtils.getPrincipal("casuser",
            Map.of(Attr_State.NAME, List.of(new StringValue("value"))));
        val authn = CoreAuthenticationTestUtils.getAuthentication(principal);
        WebUtils.putAuthentication(authn, context);
        val result = authenticationHandler.authenticate(c);
        assertNotNull(result);
    }
}


text:
package org.apache.ode.jbi;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;

import javax.jbi.JBIException;
import javax.jbi.component.ComponentContext;
import javax.jbi.messaging.DeliveryChannel;
import javax.jbi.messaging.NormalizedMessage;
import javax.jbi.servicedesc.ServiceEndpoint;
import javax.sql.DataSource;
import javax.transaction.TransactionManager;
import javax.wsdl.Definition;
import javax.wsdl.Operation;
import javax.wsdl.factory.WSDLFactory;
import javax.xml.namespace.QName;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ode.agents.memory.SizingAgent;
import org.apache.ode.bpel.dao.BpelDAOConnectionFactory;
import org.apache.ode.bpel.engine.BpelServerImpl;
import org.apache.ode.bpel.engine.ProcessAndInstanceManagementImpl;
import org.apache.ode.bpel.iapi.Endpoint;
import org.apache.ode.bpel.iapi.EndpointReference;
import org.apache.ode.bpel.iapi.ProcessConf;
import org.apache.ode.bpel.o.OPartnerLink;
import org.apache.ode.bpel.o.OProcess;
import org.apache.ode.bpel.o.Serializer;
import org.apache.ode.bpel.pmapi.InstanceManagement;
import org.apache.ode.bpel.pmapi.ProcessManagement;
import org.apache.ode.jbi.msgmap.Mapper;
import org.apache.ode.jbi.util.WSDLFlattener;
import org.apache.ode.scheduler.simple.SimpleScheduler;
import org.apache.ode.store.ProcessStoreImpl;
import org.w3c.dom.Document;

/**
 * Encapsulation of all the junk needed to get the BPEL engine running.
 *
 * @author mszefler
 */
final public class OdeContext {
    private static final Log __log = LogFactory.getLog(OdeContext.class);

    public static final QName PM_SERVICE_NAME = new QName("http://www.apache.org/ode/pmapi", "ProcessManagementService");
    public static final String PM_PORT_NAME = "ProcessManagementPort";

    public static final QName IM_SERVICE_NAME = new QName("http://www.apache.org/ode/pmapi", "InstanceManagementService");
    public static final String IM_PORT_NAME = "InstanceManagementPort";

    /** static singleton */
    private static OdeContext __self;

    private ComponentContext _context;

    private TransactionManager _txm;

    private Map<QName, Document> _descriptorCache = new ConcurrentHashMap<QName, Document>();

    /** Ordered list of message mappers */
    private ArrayList<Mapper> _mappers = new ArrayList<Mapper>();

    /** Mapper by class name. */
    private Map<String, Mapper> _mappersByClassName = new HashMap<String, Mapper>();

    OdeConsumer _consumer;

    JbiMessageExchangeProcessor _jbiMessageExchangeProcessor = new JbiMessageExchangeEventRouter(this);

    BpelServerImpl _server;

    EndpointReferenceContextImpl _eprContext;

    MessageExchangeContextImpl _mexContext;

    SimpleScheduler _scheduler;

    ExecutorService _executorService;

    BpelDAOConnectionFactory _daocf;

    OdeConfigProperties _config;

    DataSource _dataSource;

    ProcessStoreImpl _store;

    ServiceEndpoint _processManagementEndpoint;
    ServiceEndpoint _instanceManagementEndpoint;

    JbiMessageExchangeProcessor _processManagementProcessor;
    JbiMessageExchangeProcessor _instanceManagementProcessor;

    ProcessManagement _processManagement;
    InstanceManagement _instanceManagement;

    /** Mapping of Endpoint to OdeService */
    private Map<Endpoint, OdeService> _activeOdeServices = new ConcurrentHashMap<Endpoint, OdeService>();
    private Map<OdeService, EndpointReference> _serviceEprMap = new HashMap<OdeService, EndpointReference>();

    /**
     * Gets the delivery channel.
     *
     * @return delivery channel
     */
    public DeliveryChannel getChannel() {
        DeliveryChannel chnl = null;

        if (_context != null) {
            try {
                chnl = _context.getDeliveryChannel();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        return chnl;
    }

    /**
     * Sets the Component context.
     *
     * @param ctx
     *            component context.
     */
    public void setContext(ComponentContext ctx) {
        _context = ctx;
    }

    public ComponentContext getContext() {
        return _context;
    }

    public static OdeContext getInstance() {
        synchronized (OdeContext.class) {
            if (__self == null) {
                __self = new OdeContext();
            }
        }
        return __self;
    }

    public void addEndpointDoc(QName svcname, Document df) {
        _descriptorCache.put(svcname, df);
    }

    public Document getServiceDescription(QName svcName) {
        return _descriptorCache.get(svcName);
    }

    public TransactionManager getTransactionManager() {
        if (_txm == null) {
            return (TransactionManager) getContext().getTransactionManager();
        }

        return _txm;
    }

    public void setTransactionManager(TransactionManager txm) {
        _txm = txm;
    }

    public synchronized MyEndpointReference activateEndpoint(QName pid, Endpoint endpoint) throws Exception {
        if (__log.isDebugEnabled()) {
            __log.debug("Activate endpoint: " + endpoint);
        }

        OdeService service=_activeOdeServices.get(endpoint);
        if(service == null)
        	service = new OdeService(this, endpoint);
        try {
            ProcessConf pc = _store.getProcessConfiguration(pid);
            InputStream is = pc.getCBPInputStream();
            OProcess compiledProcess = null;
            try {
                Serializer ofh = new Serializer(is);
                compiledProcess = ofh.readOProcess();
            } finally {
                is.close();
            }
            QName portType = null;
            for (Map.Entry<String, Endpoint> provide : pc.getProvideEndpoints().entrySet()) {
                if (provide.getValue().equals(endpoint)) {
                    OPartnerLink plink = compiledProcess.getPartnerLink(provide.getKey());
                    portType = plink.myRolePortType.getQName();
                    break;
                }
            }
            if (portType == null) {
                if (__log.isDebugEnabled()) {
                    __log.debug("Could not find PortType for endpoint");
                }
            } else {
                Definition def = pc.getDefinitionForService(endpoint.serviceName);
                if (def == null) {
                    __log.debug("Could not find definition for service: " + endpoint.serviceName);
                } else {
                    def = new WSDLFlattener(def).getDefinition(portType);
                    Document doc = WSDLFactory.newInstance().newWSDLWriter().getDocument(def);
                    addEndpointDoc(endpoint.serviceName, doc);
                }
            }
        } catch (Exception e) {
            __log.warn("Exception during endpoint activation", e);
        }
        MyEndpointReference myepr = new MyEndpointReference(service);
        service.activate();
        _activeOdeServices.put(endpoint, service);
        _serviceEprMap.put(service, myepr);
        return myepr;

    }

    public synchronized void  deactivateEndpoint(Endpoint endpoint) throws Exception {
        OdeService svc = _activeOdeServices.get(endpoint);

        if (svc != null) {
            _serviceEprMap.remove(svc);
            svc.deactivate();
            if(svc.getCount() < 1 ) {
        	_activeOdeServices.remove(endpoint);
            }
        }
    }

    public OdeService getService(Endpoint endpoint) {
        return _activeOdeServices.get(endpoint);
    }

    public OdeService getService(QName serviceName) {
        for (Map.Entry<Endpoint,OdeService> e : _activeOdeServices.entrySet()){
            if (e.getKey().serviceName.equals(serviceName))
                return e.getValue();
        }
        return null;
    }

    public Mapper findMapper(NormalizedMessage nmsMsg, Operation op) {
        ArrayList<Mapper> maybe = new ArrayList<Mapper>();

        for (Mapper m : _mappers) {
            Mapper.Recognized result = m.isRecognized(nmsMsg, op);
            switch (result) {
            case TRUE:
                return m;
            case FALSE:
                continue;
            case UNSURE:
                maybe.add(m);
                break;
            }
        }

        if (maybe.size() == 0)
            return null;
        if (maybe.size() == 1)
            return maybe.get(0);

        __log.warn("Multiple mappers may match input message for operation " + op.getName());
        // Get the first match.
        return maybe.get(0);
    }

    public Mapper getMapper(String name) {
        return _mappersByClassName.get(name);
    }

    public void registerMapper(Mapper mapper) {
        _mappers.add(mapper);
        _mappersByClassName.put(mapper.getClass().getName(), mapper);
    }

    public Mapper getDefaultMapper() {
        return _mappers.get(0);
    }

    void activatePMAPIs() throws JBIException {
        ProcessAndInstanceManagementImpl pm = new ProcessAndInstanceManagementImpl(_server, _store);
        _processManagement = pm;
        _instanceManagement = pm;
        _processManagementEndpoint = getContext().activateEndpoint(PM_SERVICE_NAME, PM_PORT_NAME);
        _instanceManagementEndpoint = getContext().activateEndpoint(IM_SERVICE_NAME, IM_PORT_NAME);
        _processManagementProcessor = new DynamicMessageExchangeProcessor<ProcessManagement>(pm, getChannel());
        _instanceManagementProcessor = new DynamicMessageExchangeProcessor<InstanceManagement>(pm, getChannel());
    }

    void deactivatePMAPIs() throws JBIException {
        if (_processManagementEndpoint != null) {
            try {
                getContext().deactivateEndpoint(_processManagementEndpoint);
            } catch (Exception e) {
                __log.error("Error deactivating ProcessManagement service", e);
            }
        }
        if (_instanceManagementEndpoint != null) {
            try {
                getContext().deactivateEndpoint(_instanceManagementEndpoint);
            } catch (Exception e) {
                __log.error("Error deactivating InstanceManagement service", e);
            }
        }
    }

    public long calculateSizeOfService(EndpointReference epr) {
    	if (epr != null) {
	    	for (OdeService odeService : _serviceEprMap.keySet()) {
	    		EndpointReference serviceEpr = _serviceEprMap.get(odeService);
	    		if (serviceEpr != null && epr.equals(serviceEpr)) {
					return SizingAgent.deepSizeOf(odeService);
	    		}
	    	}
    	}
    	return 0;
    }
}


text:
docker-zookeeper
================

To build and run:

    sudo docker build -t $USER/zookeeper github.com/disintegrator/docker-zookeeper
    sudo docker run --name zk $USER/zookeeper

To start a shell that can talk to a running zookeeper instance with name zk:

    sudo docker run --link zk:zk --rm --entrypoint="/bin/bash" $USER/zookeeper -l


text:
<head>
   <style>
    body {
        padding: 0;
        margin: 0;
    }
    #menu {
        position: absolute;
        z-index: 100;
        padding: 10px 0 0 10px;
    }
    </style>
</head>

<body>
    <div id="menu">
        <button id="play">Play</button>
        <button id="stop">Stop</button>
        <button id="time"></button>
        <button>Click and drag left to right to scrub</button>
    </div>

    <script src="js/RequestAnimationFrame.js"></script>
    <script src="js/utils.js"></script>
    <script language="javascript" src="../build/ijeoma.js"></script>
    <script language="javascript">
    setup();
    draw();

    function setup() {
        var rectH = window.innerHeight;

        rect1 = document.createElement('div');
        rect1.style.cssText = 'position: absolute; left:0; width:50%; height:' + rectH + 'px;';
        rect1.startColor = randomColor();
        rect1.endColor = randomColor();

        rect2 = document.createElement('div');
        rect2.style.cssText = 'position: absolute; left:50%; width:50%; height:' + rectH + 'px;';
        rect2.startColor = randomColor();
        rect2.endColor = randomColor();

        document.body.appendChild(rect1);
        document.body.appendChild(rect2);

        time = document.getElementById('time')

        parallel = new MOTION.Parallel()
            .add(new MOTION.Tween(rect1, 'y', [-rectH, rectH], 1500).onUpdate(function() {
                rect1.style.top = rect1.y + 'px';
                rect1.style.backgroundColor = lerpColor(rect1.startColor, rect1.endColor, this.getPosition()).toString();
            }))
            .add(new MOTION.Tween(rect2, 'y', [rectH, -rectH], 1500).onUpdate(function() {
                rect2.style.top = rect2.y + 'px';
                rect2.style.backgroundColor = lerpColor(rect2.startColor, rect2.endColor, this.getPosition()).toString();
            }))
            .onUpdate(function() {
                time.innerHTML = this.time() | 0;
            })
            .onEnd(function() {
                rect1.startColor = randomColor();
                rect1.endColor = randomColor();

                rect2.startColor = randomColor();
                rect2.endColor = randomColor();

                this.play();
            })
            .play();

        document.getElementById('play').onclick = function() {
            parallel.play()
        }
        document.getElementById('stop').onclick = function() {
            parallel.stop()
        }

        flag = false;

        document.onmousedown = function(e) {
            flag = true;
            parallel.pause();
        }

        document.onmousemove = function(e) {
            if (flag)
                parallel.seek(e.clientX / window.innerWidth)
        }

        document.onmouseup = function(e) {
            flag = false;
            parallel.resume();
        }
    }

    function draw(time) {
        requestAnimationFrame(draw);
        MOTION.update(time);
    }
    </script>
</body>


text:
title: Overview
page_title: Overview - WinForms Converter
description: This article shows what the winforms converter represents and what it supports.
slug: winforms/installation-deployment-and-distribution/visual-studio-extensions/winforms-converter
tags: convert, winforms, radcontrols
published: True
position: 0
---

# WinForms Converter

This tool allows you to convert the standard .NET Windows Forms controls for all projects in a particular solution to their equivalent in Telerik UI for WinForms. It aims to speed up the conversion process and save time when such projects are modernized. The tool is built on top of the [Roslyn](https://roslyn.codeplex.com/) compiler platform.

>caption Figure 1: Sample application converted to use the Telerik controls.

![winforms-converter-overview001](images/winforms-converter-overview001.png)

Here are the main capabilities:

* __Large number of supported controls__ - complete list of the converted controls is available here: [Supported Controls]({%slug winforms/installation-deployment-and-distribution/visual-studio-extensions/supported-controls%}). You can chose which controls to convert as well.

* __Real-Time differences__ - after the project is converted you can view the differences in Visual Studio.

* __Auto BackUp Support__ - by default, the tool creates a project backup. You can find it in the project folder.

* __Conversion Log__ - Conversion log is created when the process is completed. It contains a complete list of all converted files.

* __Convert to a specific version__ - you can choose to which version of __Telerik UI for WinForms__ you want to convert.

* Visual Basic and C# projects are supported.

Before proceeding further, make sure that you meet the [Requirements]({%slug winforms/winforms-converter/requirements%}) for the Converter Tool.

## See Also

* [Step-by-step tutorial]({%slug winforms/winforms-converter/step-by-step-tutorial%})
* [Requirements]({%slug winforms/winforms-converter/requirements%})


text:
using Microsoft.Extensions.Logging;

namespace Eurofurence.App.Server.Services.Abstractions
{
    public static class LogEvents
    {
        public static EventId Audit = new EventId(1, "Audit");
        public static EventId CollectionGame = new EventId(2, "CollectionGame");
    }
}


text:
void DelayLoop (void);

//*****************************************************************************
//! Reads single word data result of Local to Remote IPC command
//!
//! \param pvData is a pointer to the 16/32-bit variable where the result data
//! will be stored.
//! \param usLength designates 16- or 32-bit read.
//! \param ulStatusFlag indicates the Local to Remote CPU Flag number mask used
//!  to report the status of the command sent back from the Remote CPU. If
//!  a status flag was not used with the command call, set this parameter to 0.
//!
//! Allows the caller to read the 16/32-bit data result of non-blocking IPC
//! functions from the IPCREMOTEREPLY register if the status flag is cleared
//! indicating the IPC command was successfully interpreted. If the status flag
//! is not cleared, the command was not recognized, and the function will
//! return STATUS_FAIL. To determine what data is read from a call to this
//! function, see the descriptions of the non-blocking IPC functions.
//! The \e usLength parameter accepts the following values: \b
//! IPC_LENGTH_16_BITS or \b IPC_LENGTH_32_BITS. The  \e ulStatusFlag parameter
//! accepts any of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b NO_FLAG.
//! The function returns \b STATUS_PASS or \b STATUS_FAIL.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteLtoRGetResult (void *pvData, uint16_t usLength, uint32_t ulStatusFlag)
{
    uint16_t returnStatus;

    // If Remote System never acknowledged Status Task, indicates command
    // failure.
    if (IpcRegs.IPCFLG.all & ulStatusFlag)
    {
        returnStatus = STATUS_FAIL;
    }
    else
    {
        // Read data.
        if (usLength == IPC_LENGTH_16_BITS)
        {
            *(uint16_t *)pvData = IpcRegs.IPCREMOTEREPLY;
        }
        else if (usLength == IPC_LENGTH_32_BITS)
        {
            *(uint32_t *)pvData =  IpcRegs.IPCREMOTEREPLY;
        }

        returnStatus = STATUS_PASS;
    }

    return returnStatus;
}

//*****************************************************************************
//! Reads either a 16- or 32-bit data word from the remote CPU System address
//!
//! \param ulFlag specifies Local to Remote IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulAddress specifies the remote address to read from
//! \param usLength designates 16- or 32-bit read (1 = 16-bit, 2 = 32-bit)
//! \param ulStatusFlag indicates the Local to Remote Flag number mask used to
//!  report the status of the command sent back from the remote system.
//!
//! This function will allow the Local CPU System to read 16/32-bit data from
//! the Remote CPU System into the IPCREMOTEREPLY register. After calling this
//! function, a call to \e IPCLiteLtoRGetResult() will read the data value in
//! the IPCREMOTEREPLY register into a 16- or 32-bit variable in the local CPU
//! application.
//! The \e usLength parameter accepts the following values: \b
//! IPC_LENGTH_16_BITS or \b IPC_LENGTH_32_BITS. The \e ulStatusFlag parameter
//! accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b
//! NO_FLAG. The function returns \b STATUS_PASS if the command is successful
//! or \b STATUS_FAIL if the request or status flags are unavailable.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteLtoRDataRead(uint32_t ulFlag, uint32_t ulAddress, uint16_t usLength,
                    uint32_t ulStatusFlag)
{
    uint16_t returnStatus;

    // Return false if IPC Local to Remote request or status flags are not available.
    if (IpcRegs.IPCFLG.all & (ulFlag | ulStatusFlag))
    {
        returnStatus = STATUS_FAIL;
    }
    else
    {
        // Set up read command, address, and word length.
        if (usLength == IPC_LENGTH_16_BITS)
        {
            IpcRegs.IPCSENDCOM = IPC_DATA_READ_16;
        }
        else if (usLength == IPC_LENGTH_32_BITS)
        {
            IpcRegs.IPCSENDCOM = IPC_DATA_READ_32;
        }
        IpcRegs.IPCSENDADDR = ulAddress;

        // Force IPC event on selected request task and enable status-checking.
        IpcRegs.IPCSET.all |= (ulFlag | ulStatusFlag);

        returnStatus = STATUS_PASS;
    }

    return returnStatus;
}

//*****************************************************************************
//! Sets the designated bits in a 16/32-bit data word at the remote CPU system
//! address
//!
//! \param ulFlag specifies Local to Remote IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulAddress specifies the Remote address to write to.
//! \param ulMask specifies the 16/32-bit mask for bits which should be set at
//!  remote ulAddress. For 16-bit mask, only the lower 16-bits of ulMask are
//!  considered.
//! \param usLength specifies the length of the \e ulMask (1 = 16-bit, 2 =
//! 32-bit).
//! \param ulStatusFlag indicates the Local to Remote Flag number mask used to report the
//! status of the command sent back from the Remote system.
//!
//! This function will allow the Local CPU system to set bits specified by the
//! \e usMask variable in a 16/32-bit word on the Remote CPU system. The data
//! word at /e ulAddress after the set bits command is then read into the
//! IPCREMOTEREPLY register. After calling this function, a call to \e
//! IPCLiteLtoRGetResult() will read the data value in the IPCREMOTEREPLY register
//! into a 16/32-bit variable in the Local CPU application.
//! The \e usLength parameter accepts the following values: \b
//! IPC_LENGTH_16_BITS or \b IPC_LENGTH_32_BITS. The \e ulStatusFlag parameter
//! accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b
//! NO_FLAG. The function returns \b STATUS_PASS if the command is successful
//! or \b STATUS_FAIL if the request or status flags are unavailable.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteLtoRSetBits(uint32_t ulFlag, uint32_t ulAddress, uint32_t ulMask,
                   uint16_t usLength, uint32_t ulStatusFlag)
{
    uint16_t returnStatus;

    // Return false if IPC Local to Remote request or status flags are not available.
    if (IpcRegs.IPCFLG.all & (ulFlag | ulStatusFlag))
    {
        returnStatus = STATUS_FAIL;
    }
    else
    {
        if (usLength == IPC_LENGTH_16_BITS)
        {
            // Set up 16-bit set bits command, address, and mask.
            IpcRegs.IPCSENDCOM = IPC_SET_BITS_16;
            IpcRegs.IPCSENDADDR = ulAddress;
            IpcRegs.IPCSENDDATA = ulMask & (0x0000FFFF);
        }
        else if (usLength == IPC_LENGTH_32_BITS)
        {
            // Set up 32-bit set bits command, address, and mask.
            IpcRegs.IPCSENDCOM = IPC_SET_BITS_32;
            IpcRegs.IPCSENDADDR = ulAddress;
            IpcRegs.IPCSENDDATA = ulMask;
        }

        // Force IPC event on selected request task and enable status-checking.
        IpcRegs.IPCSET.all |= (ulFlag | ulStatusFlag);

        returnStatus = STATUS_PASS;
    }

    return returnStatus;
}

//*****************************************************************************
//! Sets the designated bits in a 16/32-bit write-protected data word at
//! the Remote CPU system address
//!
//! \param ulFlag specifies Local to Remote IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulAddress specifies the Remote CPU write-protected address to write to.
//! \param ulMask specifies the 16/32-bit mask for bits which should be set at
//!  Remote CPU ulAddress.For 16-bit mask, only the lower 16-bits of ulMask are
//!  considered.
//! \param usLength specifies the length of the \e ulMask (1 = 16-bit, 2 =
//! 32-bit).
//! \param ulStatusFlag indicates the Local to Remote Flag number mask used to report the
//! status of the command sent back from the Master system.
//!
//! This function will allow the Local CPU system to set bits specified by the
//! \e usMask variable in a write-protected 16/32-bit word on the REmote CPU
//! system.
//! The data word at /e ulAddress after the set bits command is then read into
//! the IPCREMOTEREPLY register. After calling this function, a call to
//! \e IPCLiteLtoRGetResult() will read the data value in the IPCREMOTEREPLY
//! register into a 16/32-bit variable in the Local application.
//! The \e usLength parameter accepts the following values: \b
//! IPC_LENGTH_16_BITS or \b IPC_LENGTH_32_BITS. The \e ulStatusFlag parameter
//! accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b
//! NO_FLAG. The function returns \b STATUS_PASS if the command is successful
//! or \b STATUS_FAIL if the request or status flags are unavailable.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteLtoRSetBits_Protected (uint32_t ulFlag, uint32_t ulAddress, uint32_t ulMask,
                              uint16_t usLength, uint32_t ulStatusFlag)
{
    uint16_t returnStatus;

    // Return false if IPC Local to Remote request or status flags are not available.
    if (IpcRegs.IPCFLG.all & (ulFlag | ulStatusFlag))
    {
        returnStatus = STATUS_FAIL;
    }
    else
    {
        if (usLength == IPC_LENGTH_16_BITS)
        {
            // Set up 16-bit set bits command, address, and mask.
            IpcRegs.IPCSENDCOM = IPC_SET_BITS_16_PROTECTED;
            IpcRegs.IPCSENDADDR = ulAddress;
            IpcRegs.IPCSENDDATA = ulMask & (0x0000FFFF);
        }
        else if (usLength == IPC_LENGTH_32_BITS)
        {
            // Set up 32-bit set bits command, address, and mask.
            IpcRegs.IPCSENDCOM = IPC_SET_BITS_32_PROTECTED;
            IpcRegs.IPCSENDADDR = ulAddress;
            IpcRegs.IPCSENDDATA = ulMask;
        }

        // Force IPC event on selected request task and enable status-checking.
        IpcRegs.IPCSET.all |= (ulFlag | ulStatusFlag);

        returnStatus = STATUS_PASS;
    }

    return returnStatus;
}

//*****************************************************************************
//! Sets the designated bits in a 16/32-bit data word at the remote CPU system
//! address
//!
//! \param ulFlag specifies Local to Remote IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulAddress specifies the Remote CPU address to write to.
//! \param ulMask specifies the 16/32-bit mask for bits which should be set at
//! the remote CPU ulAddress. (For 16-bit mask, only the lower 16-bits of ulMask are
//! considered.
//! \param usLength specifies the length of the \e ulMask (1 = 16-bit, 2 =
//! 32-bit).
//! \param ulStatusFlag indicates the Local to Remote Flag number mask used to report the
//! status of the command sent back from the Master system.
//!
//! This function will allow the Local CPU system to set bits specified by the
//! \e usMask variable in a 16/32-bit word on the Remote CPU system. The data
//! word at /e ulAddress after the set bits command is then read into the
//! IPCREMOTEREPLY register. After calling this function, a call to \e
//! IPCLiteLtoRGetResult() will read the data value in the IPCREMOTEREPLY register
//! into a 16/32-bit variable in the Local CPU application.
//! The \e usLength parameter accepts the following values: \b
//! IPC_LENGTH_16_BITS or \b IPC_LENGTH_32_BITS. The \e ulStatusFlag parameter
//! accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b
//! NO_FLAG. The function returns \b STATUS_PASS if the command is successful
//! or \b STATUS_FAIL if the request or status flags are unavailable.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteLtoRClearBits(uint32_t ulFlag, uint32_t ulAddress, uint32_t ulMask,
                     uint16_t usLength, uint32_t ulStatusFlag)
{
    uint16_t returnStatus;

    // Return false if IPC Local to Remote request or status flags are not available.
    if (IpcRegs.IPCFLG.all & (ulFlag | ulStatusFlag))
    {
        returnStatus = STATUS_FAIL;
    }
    else
    {
        if (usLength == IPC_LENGTH_16_BITS)
        {
            // Set up 16-bit set bits command, address, and mask.
            IpcRegs.IPCSENDCOM = IPC_CLEAR_BITS_16;
            IpcRegs.IPCSENDADDR = ulAddress;
            IpcRegs.IPCSENDDATA = ulMask & (0x0000FFFF);
        }
        else if (usLength == IPC_LENGTH_32_BITS)
        {
            // Set up 32-bit set bits command, address, and mask.
            IpcRegs.IPCSENDCOM = IPC_CLEAR_BITS_32;
            IpcRegs.IPCSENDADDR = ulAddress;
            IpcRegs.IPCSENDDATA = ulMask;
        }

        // Force IPC event on selected request task and enable status-checking.
        IpcRegs.IPCSET.all |= (ulFlag | ulStatusFlag);

        returnStatus = STATUS_PASS;
    }

    return returnStatus;
}

//*****************************************************************************
//! Clears the designated bits in a 16/32-bit write-protected data word at
//! Remote CPU system address
//!
//! \param ulFlag specifies Local to Remote IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulAddress specifies the Remote CPU write-protected address to write to.
//! \param ulMask specifies the 16/32-bit mask for bits which should be cleared
//! at Remote CPU ulAddress.For 16-bit mask, only the lower 16-bits of ulMask are
//! considered.
//! \param usLength specifies the length of the \e ulMask (1 = 16-bit, 2 =
//! 32-bit).
//! \param ulStatusFlag indicates the Local to Remote Flag number mask used to report the
//! status of the command sent back from the Master system.
//!
//! This function will allow the Local CPU system to clear bits specified by
//! the \e usMask variable in a write-protected 16/32-bit word on the Remote CPU
//! system.
//! The data word at /e ulAddress after the clear bits command is then read into
//! the IPCREMOTEREPLY register. After calling this function, a call to
//! \e IPCLiteLtoRGetResult() will read the data value in the IPCREMOTEREPLY
//! register into a 16/32-bit variable in the Local CPU application.
//! The \e usLength parameter accepts the following values: \b
//! IPC_LENGTH_16_BITS or \b IPC_LENGTH_32_BITS. The \e ulStatusFlag parameter
//! accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b
//! NO_FLAG. The function returns \b STATUS_PASS if the command is successful
//! or \b STATUS_FAIL if the request or status flags are unavailable.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteLtoRClearBits_Protected (uint32_t ulFlag, uint32_t ulAddress, uint32_t ulMask,
                                uint16_t usLength, uint32_t ulStatusFlag)
{
    uint16_t returnStatus;

    // Return false if IPC Local to Remote request or status flags are not available.
    if (IpcRegs.IPCFLG.all & (ulFlag | ulStatusFlag))
    {
        returnStatus = STATUS_FAIL;
    }
    else
    {
        if (usLength == IPC_LENGTH_16_BITS)
        {
            // Set up 16-bit set bits command, address, and mask.
            IpcRegs.IPCSENDCOM = IPC_CLEAR_BITS_16_PROTECTED;
            IpcRegs.IPCSENDADDR = ulAddress;
            IpcRegs.IPCSENDDATA = ulMask & (0x0000FFFF);
        }
        else if (usLength == IPC_LENGTH_32_BITS)
        {
            // Set up 32-bit set bits command, address, and mask.
            IpcRegs.IPCSENDCOM = IPC_CLEAR_BITS_32_PROTECTED;
            IpcRegs.IPCSENDADDR = ulAddress;
            IpcRegs.IPCSENDDATA = ulMask;
        }

        // Force IPC event on selected request task and enable status-checking.
        IpcRegs.IPCSET.all |= (ulFlag | ulStatusFlag);

        returnStatus = STATUS_PASS;
    }

    return returnStatus;
}

//*****************************************************************************
//! Writes a 16/32-bit data word to Remote CPU System address
//!
//! \param ulFlag specifies Local to Remote IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulAddress specifies the Remote CPU address to write to
//! \param ulData specifies the 16/32-bit word which will be written. For 16-bit
//! words, only the lower 16-bits of ulData will be considered by the master
//! system.
//! \param usLength is the length of the word to write (0 = 16-bits, 1 =
//! 32-bits)
//! \param ulStatusFlag indicates the Local to Remote Flag number mask used to report the
//! status of the command sent back from the Remote CPU  system.
//!
//! This function will allow the Local CPU System to write a 16/32-bit word
//! via the \e ulData variable to an address on the Remote CPU System.
//! The \e usLength parameter accepts the following values: \b
//! IPC_LENGTH_16_BITS or \b IPC_LENGTH_32_BITS. The \e ulStatusFlag paramete
//! accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b
//! NO_FLAG. The function returns \b STATUS_PASS if the command is successful
//! or \b STATUS_FAIL if the request or status flags are unavailable.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteLtoRDataWrite(uint32_t ulFlag, uint32_t ulAddress, uint32_t ulData,
                     uint16_t usLength, uint32_t ulStatusFlag)
{
    uint16_t returnStatus;

    // Return false if IPC Local to Remote request or status flags are not available.
    if (IpcRegs.IPCFLG.all & (ulFlag | ulStatusFlag))
    {
        returnStatus = STATUS_FAIL;
    }
    else
    {
        // Set up data write command, address, and data. For 16-bit write, Master
        // system will
        // look at lower 16-bits only.
        if (usLength == IPC_LENGTH_16_BITS)
        {
            IpcRegs.IPCSENDCOM = IPC_DATA_WRITE_16;
        }
        else if (usLength == IPC_LENGTH_32_BITS)
        {
            IpcRegs.IPCSENDCOM = IPC_DATA_WRITE_32;
        }
        IpcRegs.IPCSENDADDR = ulAddress;
        IpcRegs.IPCSENDDATA = ulData;

        // Force IPC event on selected request task and enable status-checking
        IpcRegs.IPCSET.all |= (ulFlag | ulStatusFlag);

        returnStatus = STATUS_PASS;
    }

    return returnStatus;
}

//*****************************************************************************
//! Writes a 16/32-bit data word to a protected Remote CPU System address
//!
//! \param ulFlag specifies Local to Remote IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulAddress specifies the Remote CPU address to write to
//! \param ulData specifies the 16/32-bit word which will be written. For 16-bit
//! words, only the lower 16-bits of ulData will be considered by the master
//! system.
//! \param usLength is the length of the word to write (0 = 16-bits, 1 =
//! 32-bits)
//! \param ulStatusFlag indicates the Local to Remote Flag number mask used to report the
//! status of the command sent back from the Master  system.
//!
//! This function will allow the Local CPU System to write a 16/32-bit word
//! via the \e ulData variable to a write-protected address on the Remote CPU
//! System. The \e usLength parameter accepts the following values: \b
//! IPC_LENGTH_16_BITS or \b IPC_LENGTH_32_BITS. The \e ulStatusFlag parameter
//! accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b
//! NO_FLAG. The function returns \b STATUS_PASS if the command is successful
//! or \b STATUS_FAIL if the request or status flags are unavailable.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteLtoRDataWrite_Protected(uint32_t ulFlag, uint32_t ulAddress, uint32_t ulData,
                               uint16_t usLength, uint32_t ulStatusFlag)
{
    uint16_t returnStatus;

    // Return false if IPC Local to Remote request or status flags are not available.
    if (IpcRegs.IPCFLG.all & (ulFlag | ulStatusFlag))
    {
        returnStatus = STATUS_FAIL;
    }
    else
    {
        // Set up data write command, address, and data. For 16-bit write, Master
        // system will
        // look at lower 16-bits only.
        if (usLength == IPC_LENGTH_16_BITS)
        {
            IpcRegs.IPCSENDCOM = IPC_DATA_WRITE_16_PROTECTED;
        }
        else if (usLength == IPC_LENGTH_32_BITS)
        {
            IpcRegs.IPCSENDCOM = IPC_DATA_WRITE_32_PROTECTED;
        }
        IpcRegs.IPCSENDADDR = ulAddress;
        IpcRegs.IPCSENDDATA = ulData;

        // Force IPC event on selected request task and enable status-checking
        IpcRegs.IPCSET.all |= (ulFlag | ulStatusFlag);

        returnStatus = STATUS_PASS;
    }

    return returnStatus;
}

//*****************************************************************************
//! Calls a Remote CPU function with 1 optional parameter and an optional return value.
//!
//! \param ulFlag specifies Local to Remote IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulAddress specifies the Remote CPU function address
//! \param ulParam specifies the 32-bit optional parameter value
//! \param ulStatusFlag indicates the Local to Remote Flag number mask used to report the
//! status of the command sent back from the control  system.
//!
//! This function will allow the Local CPU system to call a function on the
//! Remote CPU. The \e ulParam variable is a single optional 32-bit parameter to pass to
//! the function. The \e ulFlag parameter accepts any one of the flag values
//! \b IPC_FLAG1 - \b IPC_FLAG32. The \e ulStatusFlag parameter accepts any
//! other one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b
//! NO_FLAG. The function returns \b STATUS_PASS if the command is successful
//! or \b STATUS_FAIL if the request or status flags are unavailable.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteLtoRFunctionCall(uint32_t ulFlag, uint32_t ulAddress, uint32_t ulParam,
                        uint32_t ulStatusFlag)
{
    uint16_t returnStatus;

    // Return false if IPC Remote to Local request or status flags are not available.
    if (IpcRegs.IPCFLG.all & (ulFlag | ulStatusFlag))
    {
        returnStatus = STATUS_FAIL;
    }
    else
    {
        // Set up function call command, address, and parameter.
        IpcRegs.IPCSENDCOM = IPC_FUNC_CALL;
        IpcRegs.IPCSENDADDR = ulAddress;
        IpcRegs.IPCSENDDATA = ulParam;

        // Force IPC event on selected request task and enable status-checking
        IpcRegs.IPCSET.all |= (ulFlag | ulStatusFlag);

        returnStatus = STATUS_PASS;
    }

    return returnStatus;
}

//*****************************************************************************
//! Slave Requests Master R/W/Exe Access to Shared SARAM.
//!
//! \param ulFlag specifies Local to Remote IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulMask specifies the 32-bit mask for the GSxMEMSEL RAM control
//! register to indicate which GSx SARAM blocks the Slave is requesting master
//! access to.
//! \param ulMaster specifies whether CPU1 or CPU2 should be the master of the GSx
//! RAM.
//! \param ulStatusFlag indicates the Local to Remote Flag number mask used to report the
//! status of the command sent back from the Master  system.
//!
//! This function will allow the slave CPU System to request slave or master
//! mastership of any of the GSx Shared SARAM blocks.
//! The \e ulMaster parameter accepts the following values: \b IPC_GSX_CPU2_MASTER
//! or \b IPC_GSX_CPU1_MASTER. The \e ulStatusFlag parameter accepts any one of the
//! flag values \b IPC_FLAG1 - \b IPC_FLAG32 and \b NO_FLAG. The function
//! returns \b STATUS_PASS if the command is successful or \b STATUS_FAIL if
//! the request or status flags are unavailable.
//! \note This function calls the \e IPCLiteLtoRSetBits_Protected() or the
//! \e IPCLiteLtoRClearBits_Protected function, and therefore in order to
//! process this function, the above 2 functions should be ready to be called on
//! the master system to process this command.
//!
//! \return status of command (0=success, 1=error)
//*****************************************************************************
uint16_t
IPCLiteReqMemAccess (uint32_t ulFlag, uint32_t ulMask, uint16_t ulMaster,
                     uint32_t ulStatusFlag)
{
    uint16_t status;
    uint32_t GSxMSEL_REGaddress = (uint32_t)(&MemCfgRegs.GSxMSEL.all);
    if (ulMaster == IPC_GSX_CPU2_MASTER)
    {
        status =
            IPCLiteLtoRSetBits_Protected (ulFlag, GSxMSEL_REGaddress, ulMask,
                                          IPC_LENGTH_32_BITS,
                                          ulStatusFlag);
    }
    else if (ulMaster == IPC_GSX_CPU1_MASTER)
    {
        status =
            IPCLiteLtoRClearBits_Protected (ulFlag, GSxMSEL_REGaddress, ulMask,
                                            IPC_LENGTH_32_BITS,
                                            ulStatusFlag);
    }

    return status;
}

//*****************************************************************************
//! Reads either a 16- or 32-bit data word from the Local CPU system address
//!
//! \param ulFlag specifies Remote to Local IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulStatusFlag indicates the Remote to Local Flag number mask used to report the
//! status of the command sent back from the control  system.
//!
//! This function will allow the Remote CPU system to read 16/32-bit data from
//! the Local CPU system. The \e ulFlag parameter accepts any one of the
//! flag values \b IPC_FLAG1 - \b IPC_FLAG32, and the \e ulStatusFlag parameter
//! accepts any other one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and
//! \b NO_FLAG.
//*****************************************************************************
void
IPCLiteRtoLDataRead(uint32_t ulFlag, uint32_t ulStatusFlag)
{

    uint32_t* pulRAddress;
    uint16_t* pusRAddress;

    // Wait until IPC Remote to Local request task is flagged
    while (!(IpcRegs.IPCSTS.all & ulFlag))
    {
    }

    // If the command and data length are correct for this function:
    // Then read from requested address and write 16/32-bit data
    // to IPCLOCALREPLY. Acknowledge the status flag
    // and the task flag.
    //
    if (IpcRegs.IPCRECVCOM == IPC_DATA_READ_16)
    {
        // Perform 16-bit read.
        pusRAddress = (uint16_t *)IpcRegs.IPCRECVADDR;
        IpcRegs.IPCLOCALREPLY = (uint32_t)(*pusRAddress);
        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }
    else if (IpcRegs.IPCRECVCOM == IPC_DATA_READ_32)
    {
        pulRAddress = (uint32_t *)IpcRegs.IPCRECVADDR;
        IpcRegs.IPCLOCALREPLY = *pulRAddress;
        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }

    // Otherwise, only acknowledge the task flag. (Indicates to Remote CPU there was an
    // error)
    else
    {
        IpcRegs.IPCACK.all |= (ulFlag);
    }
}

//*****************************************************************************
//! Sets the designated bits in a 16/32-bit data word at the Local CPU system
//! address
//!
//! \param ulFlag specifies Remote to Local IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulStatusFlag indicates the Remote to Local Flag number mask used to report the
//! status of the command sent back from the control system.
//!
//! This function will allow the Remote CPU system to set bits specified by a
//! mask variable in a 16/32-bit word on the Local CPU system, and then read
//! back the word into the IPCLOCALREPLY register. The \e ulFlag parameter
//! accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32, and the
//! \e ulStatusFlag parameter accepts any other one of the flag values \b
//! IPC_FLAG1 - \b IPC_FLAG32 and \b NO_FLAG.
//*****************************************************************************
void
IPCLiteRtoLSetBits(uint32_t ulFlag, uint32_t ulStatusFlag)
{

    uint16_t* pusAddress;
    uint32_t* pulAddress;

    // Wait until IPC Remote to Local request task is flagged
    while (!(IpcRegs.IPCSTS.all & ulFlag))
    {
    }

    // If the command is correct for this function:
    // Then set the mask bits at the requested address
    // and write back the 16/32-bit data to IPCLOCALREPLY.
    // Acknowledge the status flag and the task flag.
    //
    if (IpcRegs.IPCRECVCOM == IPC_SET_BITS_16)
    {
        pusAddress = (uint16_t *)IpcRegs.IPCRECVADDR;;
        *pusAddress |= (uint16_t)IpcRegs.IPCRECVDATA;
        IpcRegs.IPCLOCALREPLY = (uint32_t)*pusAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }
    else if (IpcRegs.IPCRECVCOM == IPC_SET_BITS_32)
    {
        pulAddress = (uint32_t *)IpcRegs.IPCRECVADDR;;
        *pulAddress |= (uint32_t)IpcRegs.IPCRECVDATA;
        IpcRegs.IPCLOCALREPLY = *pulAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }

    // Otherwise, only acknowledge the task flag. (Indicates to Remote CPU there was an
    // error)
    else
    {
        IpcRegs.IPCACK.all |= (ulFlag);
    }
}

//*****************************************************************************
//! Sets the designated bits in a 16-bit data word at the Local CPU system
//! write-protected address
//!
//! \param ulFlag specifies Remote to Local IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulStatusFlag indicates the Remote to Local Flag number mask used to report the
//! status of the command sent back from the control system.
//!
//! This function will allow the Remote CPU system to set bits specified by a
//! mask variable in a write-protected 16/32-bit word on the Local CPU system,
//! and then read back the word into the IPCLOCALREPLY register. The \e ulFlag
//! parameter accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32,
//! and the \e ulStatusFlag parameter accepts any other one of the flag values
//! \b IPC_FLAG1 - \b IPC_FLAG32 and \b NO_FLAG.
//*****************************************************************************
void
IPCLiteRtoLSetBits_Protected (uint32_t ulFlag, uint32_t ulStatusFlag)
{

    uint16_t* pusAddress;
    uint32_t* pulAddress;

    // Wait until IPC Remote to Local request task is flagged
    while (!(IpcRegs.IPCSTS.all & ulFlag))
    {
    }

    // If the command is correct for this function:
    // Then enable write access with EALLOW and
    // set the mask bits at the requested address.
    // Write back the 16-bit data to IPCLOCALREPLY.
    // Restore write-protection with EDIS.
    // Acknowledge the status flag and the task flag.
    //

    EALLOW;

    if (IpcRegs.IPCRECVCOM == IPC_SET_BITS_16_PROTECTED)
    {
        pusAddress = (uint16_t *)IpcRegs.IPCRECVADDR;
        *pusAddress |= (uint16_t)IpcRegs.IPCRECVDATA;
        IpcRegs.IPCLOCALREPLY = (uint32_t)*pusAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }
    else if (IpcRegs.IPCRECVCOM == IPC_SET_BITS_32_PROTECTED)
    {
        pulAddress = (uint32_t *)IpcRegs.IPCRECVADDR;
        *pulAddress |= (uint32_t)IpcRegs.IPCRECVDATA;
        IpcRegs.IPCLOCALREPLY = *pulAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }

    // Otherwise, only acknowledge the task flag. (Indicates to the Remote CPU there was an
    // error)
    //
    else
    {
        IpcRegs.IPCACK.all |= (ulFlag);
    }

    EDIS;

}

//*****************************************************************************
//! Clears the designated bits in a 16/32-bit data word at Local CPU system
//! address
//!
//! \param ulFlag specifies Remote to Local IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulStatusFlag indicates the Remote to Local Flag number mask used to report the
//! status of the command sent back from the control system.
//!
//! This function will allow the Remote CPU system to clear bits specified by a
//! mask variable in a 16/32-bit word on the Local CPU system, and then read
//! back the word into the IPCLOCALREPLY register. The \e ulFlag
//! parameter accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32,
//! and the \e ulStatusFlag parameter accepts any other one of the flag values
//! \b IPC_FLAG1 - \b IPC_FLAG32 and \b NO_FLAG.
//*****************************************************************************
void
IPCLiteRtoLClearBits(uint32_t ulFlag, uint32_t ulStatusFlag)
{

    uint16_t* pusAddress;
    uint32_t* pulAddress;

    // Wait until IPC Remote to Local request task is flagged
    while (!(IpcRegs.IPCSTS.all & ulFlag))
    {
    }

    // If the command is correct for this function:
    // Then clear the mask bits at the requested address
    // and write back the 16/32-bit data to IPCLOCALREPLY.
    // Acknowledge the status flag and the task flag.
    //
    if (IpcRegs.IPCRECVCOM == IPC_CLEAR_BITS_16)
    {
        pusAddress = (uint16_t *)IpcRegs.IPCRECVADDR;;
        *pusAddress &= ~((uint16_t)IpcRegs.IPCRECVDATA);
        IpcRegs.IPCLOCALREPLY = (uint32_t)*pusAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }
    else if (IpcRegs.IPCRECVCOM == IPC_CLEAR_BITS_32)
    {
        pulAddress = (uint32_t *)IpcRegs.IPCRECVADDR;
        *pulAddress &= ~((uint32_t)IpcRegs.IPCRECVDATA);
        IpcRegs.IPCLOCALREPLY = *pulAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }

    // Otherwise, only acknowledge the task flag. (Indicates to Remote CPU there was an
    // error)
    //
    else
    {
        IpcRegs.IPCACK.all |= (ulFlag);
    }
}

//*****************************************************************************
//! Clears the designated bits in a 16/32-bit data word at the Local CPU system
//! write-protected address
//!
//! \param ulFlag specifies Remote to Local IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulStatusFlag indicates the Remote to Local Flag number mask used to report the
//! status of the command sent back from the control system.
//!
//! This function will allow the Remote CPU system to clear bits specified by a
//! mask variable in a 16/32-bit word on the Local CPU system, and then read
//! back the word into the IPCLOCALREPLY register. The \e ulFlag
//! parameter accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32,
//! and the \e ulStatusFlag parameter accepts any other one of the flag values
//! \b IPC_FLAG1 - \b IPC_FLAG32 and \b NO_FLAG.
//*****************************************************************************
void
IPCLiteRtoLClearBits_Protected (uint32_t ulFlag, uint32_t ulStatusFlag)
{

    uint16_t* pusAddress;
    uint32_t* pulAddress;

    // Wait until IPC Remote to Local request task is flagged
    while (!(IpcRegs.IPCSTS.all & ulFlag))
    {
    }

    // If the command is correct for this function:
    // Then enable write access with EALLOW and
    // clear the mask bits at the requested address.
    // Write back the 16/32-bit data to IPCLOCALREPLY.
    // Restore the status of the EALLOW register.
    // Acknowledge the status flag and the task flag.
    //
    EALLOW;

    if (IpcRegs.IPCRECVCOM == IPC_CLEAR_BITS_16_PROTECTED)
    {

        pusAddress = (uint16_t *)IpcRegs.IPCRECVADDR;;
        *pusAddress &= ~((uint16_t)IpcRegs.IPCRECVDATA);
        IpcRegs.IPCLOCALREPLY = (uint32_t)*pusAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }
    else if (IpcRegs.IPCRECVCOM == IPC_CLEAR_BITS_32_PROTECTED)
    {

        pulAddress = (uint32_t *)IpcRegs.IPCRECVADDR;;
        *pulAddress &= ~((uint32_t)IpcRegs.IPCRECVDATA);
        IpcRegs.IPCLOCALREPLY = (uint32_t)*pulAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }

    // Otherwise, only acknowledge the task flag. (Indicates to Remote CPU there was an
    // error)
    //
    else
    {
        IpcRegs.IPCACK.all |= (ulFlag);
    }

    EDIS;
}

//*****************************************************************************
//! Writes a 16/32-bit data word to Local CPU system address
//!
//! \param ulFlag specifies Remote to Local IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulStatusFlag indicates the Remote to Local Flag number mask used to report the
//! status of the command sent back from the control system.
//!
//! This function will allow the Remote CPU system to write a 16/32-bit word
//! to an address on the Local CPU system. The \e ulFlag
//! parameter accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32,
//! and the \e ulStatusFlag parameter accepts any other one of the flag values
//! \b IPC_FLAG1 - \b IPC_FLAG32 and \b NO_FLAG.
//*****************************************************************************
void
IPCLiteRtoLDataWrite(uint32_t ulFlag, uint32_t ulStatusFlag)
{
    uint32_t* pulAddress;
    uint16_t* pusAddress;

    // Wait until IPC Remote to Local request task is flagged
    while (!(IpcRegs.IPCSTS.all & ulFlag))
    {
    }

    // If the command is correct for this function:
    // Then write the 16/32-bit data to the requested address
    // and write back the 16/32-bit data to IPCLOCALREPLY.
    // Acknowledge the status flag and the task flag.
    //
    if (IpcRegs.IPCRECVCOM == IPC_DATA_WRITE_16)
    {
        pusAddress = (uint16_t *)IpcRegs.IPCRECVADDR;;
        *pusAddress = (uint16_t)IpcRegs.IPCRECVDATA;
        IpcRegs.IPCLOCALREPLY = (uint32_t)*pusAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }
    else if (IpcRegs.IPCRECVCOM == IPC_DATA_WRITE_32)
    {
        pulAddress = (uint32_t *)IpcRegs.IPCRECVADDR;;
        *pulAddress = IpcRegs.IPCRECVDATA;
        IpcRegs.IPCLOCALREPLY = *pulAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);

    }

    // Otherwise, only acknowledge the task flag. (Indicates to Remote CPU there was an
    // error)
    //
    else
    {
        IpcRegs.IPCACK.all |= (ulFlag);
    }
}

//*****************************************************************************
//! Writes a 16/32-bit data word to a write-protected Local CPU system address
//!
//! \param ulFlag specifies Remote to Local IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulStatusFlag indicates the Remote to Local Flag number mask used to report the
//! status of the command sent back from the control system.
//!
//! This function will allow the Remote CPU system to write a 16/32-bit word
//! to an address on the Local CPU system. The \e ulFlag
//! parameter accepts any one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32,
//! and the \e ulStatusFlag parameter accepts any other one of the flag values
//! \b IPC_FLAG1 - \b IPC_FLAG32 and \b NO_FLAG.
//*****************************************************************************

void
IPCLiteRtoLDataWrite_Protected(uint32_t ulFlag, uint32_t ulStatusFlag)
{
    uint32_t* pulAddress;
    uint16_t* pusAddress;

    // Wait until IPC Remote to Local request task is flagged
    while (!(IpcRegs.IPCSTS.all & ulFlag))
    {
    }

    // If the command is correct for this function:
    // Then enable write access with EALLOW and
    // write the 16/32-bit data to the requested address
    // and write back the 16/32-bit data to IPCLOCALREPLY.
    // Acknowledge the status flag and the task flag.
    //
    EALLOW;

    if (IpcRegs.IPCRECVCOM == IPC_DATA_WRITE_16_PROTECTED)
    {
        pusAddress = (uint16_t *)IpcRegs.IPCRECVADDR;;
        *pusAddress = (uint16_t)IpcRegs.IPCRECVDATA;
        IpcRegs.IPCLOCALREPLY = (uint32_t)*pusAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }
    else if (IpcRegs.IPCRECVCOM == IPC_DATA_WRITE_32_PROTECTED)
    {
        pulAddress = (uint32_t *)IpcRegs.IPCRECVADDR;
        *pulAddress = IpcRegs.IPCRECVDATA;
        IpcRegs.IPCLOCALREPLY = *pulAddress;

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);

    }

    // Otherwise, only acknowledge the task flag. (Indicates to Remote CPU there was an
    // error)
    //
    else
    {
        IpcRegs.IPCACK.all |= (ulFlag);
    }

    // Restore write-protection status.
    //
    EDIS;
}

//*****************************************************************************
//! Calls a Local CPU function with a single optional parameter and return value.
//!
//! \param ulFlag specifies Remote to Local IPC Flag number mask used to indicate a
//! command is being sent.
//! \param ulStatusFlag indicates the Remote to Local Flag number mask used to report the
//! status of the command sent back from the control system.
//!
//! This function will allow the Remote CPU system to call a Local CPU function with a
//! a single optional parameter and places an optional return value in the
//! IPCLOCALREPLY register. The \e ulFlag parameter accepts any one of the flag
//! values \b IPC_FLAG1 - \b IPC_FLAG32, and  the \e ulStatusFlag parameter
//! accepts any other one of the flag values \b IPC_FLAG1 - \b IPC_FLAG32 and
//! \b NO_FLAG.
//*****************************************************************************
void
IPCLiteRtoLFunctionCall(uint32_t ulFlag, uint32_t ulStatusFlag)
{
    // Wait until IPC Remote to Local request task is flagged
    while (!(IpcRegs.IPCSTS.all & ulFlag))
    {
    }

    // If the command is correct for this function:
    // Then call function at requested address
    // and if there is a return value, insert into
    // IPCLOCALREPLY register.
    // Acknowledge the status flag and the task flag.
    //
    if (IpcRegs.IPCRECVCOM == IPC_FUNC_CALL)
    {
        tfIpcFuncCall func_call = (tfIpcFuncCall)IpcRegs.IPCRECVADDR;
        IpcRegs.IPCLOCALREPLY = func_call(IpcRegs.IPCRECVDATA);

        IpcRegs.IPCACK.all |= (ulStatusFlag | ulFlag);
    }

    // Otherwise, only acknowledge the task flag. (Indicates to Remote CPU there was an
    // error)
    //
    else
    {
        IpcRegs.IPCACK.all |= (ulFlag);
    }
}

void DelayLoop (void)
{
    __asm(" nop");
    __asm(" nop");
    __asm(" nop");
    __asm(" nop");
    __asm(" nop");
}

//*****************************************************************************
// Close the Doxygen group.
//! @}
//*****************************************************************************


text:
package org.familysearch.api.client.util;

/**
 * @author Ryan Heaton
 */
public enum MergeAnalysisFilter {

  CoupleRelationships,

  NonVitalConclusions,

  ParentChildRelationshipsAsChild,

  ParentChildRelationshipsAsParent,

  SourceReferences,

  VitalConclusions
}