text: /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  #pragma once
  
  #ifndef GEODE_INTEGRATION_TEST_DELTAEX_H_
  #define GEODE_INTEGRATION_TEST_DELTAEX_H_
  
  #include "fw_dunit.hpp"
  #include <ace/OS.h>
  #include <memory>
  #include <geode/PdxSerializable.hpp>
  #include <geode/PdxWriter.hpp>
  #include <geode/PdxReader.hpp>
  #include <geode/Delta.hpp>
  
  #include "CacheHelper.hpp"
  
  namespace { // NOLINT(google-build-namespaces)
  
  using apache::geode::client::DataInput;
  using apache::geode::client::DataOutput;
  using apache::geode::client::DataSerializable;
  using apache::geode::client::Delta;
  using apache::geode::client::InvalidDeltaException;
  using apache::geode::client::PdxReader;
  using apache::geode::client::PdxSerializable;
  using apache::geode::client::PdxWriter;
  
  class DeltaEx : public DataSerializable, public Delta {
   public:
    int counter;
    bool isDelta;
  
   public:
    static int toDeltaCount;
    static int toDataCount;
    static int fromDeltaCount;
    static int fromDataCount;
    static int cloneCount;
    DeltaEx() : Delta(), counter(1), isDelta(false) {}
    explicit DeltaEx(int count) : Delta(), counter(count), isDelta(false) {}
    DeltaEx(const DeltaEx& rhs) = default;
  
    virtual bool hasDelta() const override { return isDelta; }
    virtual void toDelta(DataOutput& out) const override {
      out.writeInt(counter);
      toDeltaCount++;
    }
  
    virtual void fromDelta(DataInput& in) override {
      LOG("From delta gets called");
      int32_t val = in.readInt32();
      if (fromDeltaCount == 1) {
        fromDeltaCount++;
        LOG("Invalid Delta expetion thrown");
        throw InvalidDeltaException("aaannn");
      }
      counter += val;
      fromDeltaCount++;
    }
    virtual void toData(DataOutput& output) const override {
      output.writeInt(counter);
      toDataCount++;
    }
    virtual void fromData(DataInput& input) override {
      counter = input.readInt32();
      fromDataCount++;
    }
    std::shared_ptr<Delta> clone() const override {
      cloneCount++;
      return std::make_shared<DeltaEx>(*this);
    }
    ~DeltaEx() noexcept override {}
    void setDelta(bool delta) { this->isDelta = delta; }
    static std::shared_ptr<Serializable> create() {
      return std::make_shared<DeltaEx>();
    }
  };
  
  class PdxDeltaEx : public PdxSerializable, public Delta {
   public:
    int m_counter;
    bool m_isDelta;
  
   public:
    static int m_toDeltaCount;
    static int m_toDataCount;
    static int m_fromDeltaCount;
    static int m_fromDataCount;
    static int m_cloneCount;
    PdxDeltaEx() : Delta(), m_counter(1), m_isDelta(false) {}
    explicit PdxDeltaEx(int count)
        : Delta(), m_counter(count), m_isDelta(false) {}
    PdxDeltaEx(const PdxDeltaEx& rhs)
        : Delta(), m_counter(rhs.m_counter), m_isDelta(rhs.m_isDelta) {}
    virtual bool hasDelta() const override { return m_isDelta; }
    virtual void toDelta(DataOutput& out) const override {
      out.writeInt(m_counter);
      m_toDeltaCount++;
    }
  
    virtual void fromDelta(DataInput& in) override {
      LOG("From delta gets called");
      int32_t val = in.readInt32();
      if (m_fromDeltaCount == 1) {
        m_fromDeltaCount++;
        LOG("Invalid Delta expetion thrown");
        throw InvalidDeltaException("aaannn");
      }
      m_counter += val;
      m_fromDeltaCount++;
    }
  
    const std::string& getClassName() const override {
      static std::string className = "PdxTests.PdxDeltaEx";
      return className;
    }
  
    using PdxSerializable::toData;
  
    void toData(PdxWriter& pw) const override {
      pw.writeInt("counter", m_counter);
      m_toDataCount++;
    }
  
    using PdxSerializable::fromData;
  
    void fromData(PdxReader& pr) override {
      m_counter = pr.readInt("counter");
      m_fromDataCount++;
    }
  
    static std::shared_ptr<PdxSerializable> createDeserializable() {
      return std::make_shared<PdxDeltaEx>();
    }
  
    std::shared_ptr<Delta> clone() const override {
      m_cloneCount++;
      return std::make_shared<PdxDeltaEx>(*this);
    }
  
    ~PdxDeltaEx() noexcept override {}
  
    void setDelta(bool delta) { this->m_isDelta = delta; }
  
    std::string toString() const override {
      char idbuf[1024];
      sprintf(idbuf, "PdxDeltaEx :: [counter=%d]  [isDelta=%d]", m_counter,
              m_isDelta);
      return idbuf;
    }
  };
  
  }  // namespace
  
  #endif  // GEODE_INTEGRATION_TEST_DELTAEX_H_
  