text:
/*!
 * \brief Compute Op.
 * \file compute_op.cc
 */
#include <tvm/operation.h>
#include <tvm/arithmetic.h>
#include <tvm/ir.h>
#include <tvm/ir_visitor.h>
#include <tvm/ir_pass.h>
#include <unordered_set>
#include <string>
#include <utility>
#include "compute_op.h"
#include "op_util.h"
#include "../schedule/message_passing.h"
#include "../arithmetic/compute_expr.h"
#include "../arithmetic/int_set.h"

namespace tvm {

using namespace ir;

TVM_STATIC_IR_FUNCTOR(IRPrinter, vtable)
.set_dispatch<ComputeOpNode>([](const ComputeOpNode *op, IRPrinter *p) {
    p->stream << "compute(" << op->name << ", " << op << ")";
});

TVM_REGISTER_NODE_TYPE(ComputeOpNode);

/// Verify if ComputeOp is valid with respect to Reduce operations.
static void VerifyComputeOp(const ComputeOpNode *op);

inline bool ReduceEqual(const ir::Reduce* a, const ir::Reduce* b) {
  return (a->combiner.same_as(b->combiner)) &&
         (a->source.same_as(b->source)) &&
         (a->axis.same_as(b->axis)) &&
         (a->condition.same_as(b->condition));
}

int ComputeOpNode::num_outputs() const {
  return body.size();
}

Array<IterVar> BaseComputeOpNode::root_iter_vars() const {
  if (reduce_axis.size() == 0) return axis;
  Array<IterVar> ret = axis;
  for (IterVar iv : reduce_axis) {
    ret.push_back(iv);
  }
  return ret;
}

Type ComputeOpNode::output_dtype(size_t idx) const {
  CHECK_LT(idx, num_outputs());
  return body[idx].type();
}

Array<Expr> BaseComputeOpNode::output_shape(size_t idx) const {
  CHECK_LT(idx, num_outputs());
  // for now, all outputs of a BaseComputeOp have the same shape
  Array<Expr> shape;
  for (const auto& ivar : this->axis) {
    const Range& r = ivar->dom;
    shape.push_back(r->extent);
  }
  return shape;
}

Tensor compute(Array<Expr> shape,
               FCompute fcompute,
               std::string name,
               std::string tag,
               Map<std::string, NodeRef> attrs) {
  auto op_node = make_node<ComputeOpNode>();
  // compute dimension.
  size_t ndim = shape.size();
  std::vector<IterVar> axis;
  std::vector<Var> args;
  for (size_t i = 0; i < ndim; ++i) {
    std::ostringstream os;
    os << "ax" << i;
    axis.emplace_back(IterVarNode::make(
        Range(0, shape[i]), Var(os.str(), shape[i].type()), kDataPar));
    args.push_back(axis.back()->var);
  }

  return ComputeOpNode::make(
      name, tag, attrs, axis, {fcompute(args)}).output(0);
}

Array<Tensor> compute(Array<Expr> shape,
                      FBatchCompute fcompute,
                      std::string name,
                      std::string tag,
                      Map<std::string, NodeRef> attrs) {
  auto op_node = make_node<ComputeOpNode>();
  // compute dimension.
  size_t ndim = shape.size();
  std::vector<IterVar> axis;
  std::vector<Var> args;
  for (size_t i = 0; i < ndim; ++i) {
    std::ostringstream os;
    os << "ax" << i;
    axis.emplace_back(IterVarNode::make(
        Range(0, shape[i]), Var(os.str(), shape[i].type()), kDataPar));
    args.push_back(axis.back()->var);
  }

  Operation op = ComputeOpNode::make(name, tag, attrs, axis, fcompute(args));
  Array<Tensor> outputs;
  for (int idx = 0; idx < op->num_outputs(); ++idx) {
    outputs.push_back(op.output(idx));
  }
  return outputs;
}

Operation ComputeOpNode::make(std::string name,
                              std::string tag,
                              Map<std::string, NodeRef> attrs,
                              Array<IterVar> axis,
                              Array<Expr> body) {
  if (!attrs.defined()) {
    attrs = Map<std::string, NodeRef>();
  }
  auto n = make_node<ComputeOpNode>();
  n->name = std::move(name);
  n->tag = std::move(tag);
  n->attrs = std::move(attrs);
  n->axis = std::move(axis);
  n->body = std::move(body);
  if (n->body[0]->is_type<ir::Reduce>()) {
    const ir::Reduce* reduce = n->body[0].as<ir::Reduce>();
    n->reduce_axis = reduce->axis;
  }
  VerifyComputeOp(n.get());
  return Operation(n);
}

// The schedule related logics
Array<Tensor> ComputeOpNode::InputTensors() const {
  Array<Tensor> ret;
  std::unordered_set<Tensor> visited;
  for (auto& e : body) {
    ir::PostOrderVisit(e, [&ret, &visited](const NodeRef& n) {
        const ir::Call *call = n.as<ir::Call>();
        if (call != nullptr && call->func.defined()) {
          Tensor t = Operation(call->func.node_).output(call->value_index);
          if (!visited.count(t)) {
            ret.push_back(t);
            visited.insert(t);
          }
        }
      });
  }
  return ret;
}

Operation ComputeOpNode::ReplaceInputs(
    const Operation& self,
    const std::unordered_map<Tensor, Tensor>& rmap) const {
  CHECK_EQ(self.operator->(), this);
  VerifyComputeOp(this);
  Array<Expr> arr;
  if (this->body[0]->is_type<ir::Reduce>()) {
    // Specially handle reduce so the replaced op
    // still share all the components
    Expr new_reduce = op::ReplaceTensor(this->body[0], rmap);
    if (!new_reduce.same_as(this->body[0])) {
      const ir::Reduce* r = new_reduce.as<ir::Reduce>();
      for (size_t k = 0; k < this->body.size(); ++k) {
        auto n = make_node<ir::Reduce>(*r);
        n->value_index = static_cast<int>(k);
        n->type = r->source[k].type();
        arr.push_back(Expr(n));
      }
    } else {
      arr = this->body;
    }
  } else {
    arr = UpdateArray(this->body, [&rmap] (const Expr& e) {
        return op::ReplaceTensor(e, rmap);
      });
  }
  if (!arr.same_as(this->body)) {
    return ComputeOpNode::make(
        this->name, this->tag, this->attrs, this->axis, arr);
  } else {
    return self;
  }
}

void ComputeOpNode::PropBoundToInputs(
    const Operation& self,
    arith::Analyzer* analyzer,
    const std::unordered_map<const Variable*, IntSet>& dom_map,
    std::unordered_map<Tensor, TensorDom>* out_dom_map) const {
  CHECK_EQ(self.operator->(), this);
  auto fvisit = [&dom_map, out_dom_map, analyzer](const NodeRef& n) {
    auto *call = n.as<ir::Call>();
    if (call != nullptr && call->func.defined()) {
      Tensor t = Operation(call->func.node_).output(call->value_index);
      if (t->op.defined() && out_dom_map->count(t)) {
        TensorDom& dom = out_dom_map->at(t);
        for (size_t i = 0; i < t.ndim(); ++i) {
          // We assume that the value of the argument cannot be out of bounds (otherwise it is
          // undefined behaviour), so we can intersect the estimated set of the argument with the
          // range expected by the tensor. However, intersection may result in overly complex
          // expressions, so we perform a more relaxed form of intersection.
          IntSet arg_intset = EvalSet(call->args[i], dom_map);
          const arith::IntervalSetNode* arg_interval = arg_intset.as<arith::IntervalSetNode>();
          if (arg_interval) {
            Expr shape_i_min_value = make_zero(t->shape[i].type());
            Expr shape_i_max_value = t->shape[i] - 1;
            Expr min_value = arg_interval->min_value;
            Expr max_value = arg_interval->max_value;
            // Prefer the shape bounds only when we can prove they are tighter.
            if (arith::is_neg_inf(min_value) ||
                analyzer->CanProve(shape_i_min_value >= min_value)) {
              min_value = shape_i_min_value;
            }
            if (arith::is_pos_inf(max_value) ||
                analyzer->CanProve(shape_i_max_value <= max_value)) {
              max_value = shape_i_max_value;
            }
            dom.data[i].push_back(IntSet::interval(min_value, max_value));
          } else {
            dom.data[i].push_back(arg_intset);
          }
        }
      }
    }
  };
  for (auto& e : body) ir::PostOrderVisit(e, fvisit);
}

void BaseComputeOpNode::GatherBound(
    const Operation& self,
    const std::unordered_map<Tensor, TensorDom>& tensor_dom,
    std::unordered_map<IterVar, Range>* out_dom_map) const {
  CHECK_EQ(self.operator->(), this);
  const TensorDom& tdom = tensor_dom.at(self.output(0));
  for (size_t i = 0; i < this->axis.size(); ++i) {
    Range r = arith::Union(tdom.data.at(i)).cover_range(this->axis[i]->dom);
    CHECK(!out_dom_map->count(this->axis[i]));
    (*out_dom_map)[this->axis[i]] = r;
  }
  for (size_t i = 0; i < this->reduce_axis.size(); ++i) {
    CHECK(!out_dom_map->count(this->reduce_axis[i]));
    (*out_dom_map)[this->reduce_axis[i]] = this->reduce_axis[i]->dom;
  }
}

Stmt BaseComputeOpNode::BuildRealize(
    const Stage& stage,
    const std::unordered_map<IterVar, Range>& realize_map,
    const Stmt& body) const {
  CHECK_EQ(stage->op.get(), this);
  Region bounds;
  for (IterVar iv : this->axis) {
    bounds.push_back(realize_map.at(iv));
  }
  Stmt realize = body;
  for (int i = this->num_outputs(); i > 0; --i) {
    Tensor t = stage->op.output(i-1);
    realize = ir::Realize::make(t->op, t->value_index,
      t->dtype, bounds, const_true(), realize);
    // alignment requirement, only useful for compute
    for (size_t i = 0; i < num_schedulable_dims(); ++i) {
      auto it = stage->iter_var_attrs.find(this->axis[i]);
      if (it != stage->iter_var_attrs.end()) {
        IterVarAttr attr = (*it).second;
        if (attr->dim_align_factor != 0) {
          Array<Expr> tuple = {static_cast<int>(i),
                               attr->dim_align_factor,
                               attr->dim_align_offset};
          realize = ir::AttrStmt::make(
              t, ir::attr::buffer_dim_align,
              Call::make(Handle(), ir::intrinsic::tvm_tuple, tuple, Call::Intrinsic),
              realize);
        }
      }
    }
  }
  return realize;
}

size_t ComputeOpNode::num_schedulable_dims() const {
  return axis.size();
}

// Build a reduction body.
void MakeReduction(const ComputeOpNode* op,
                   const Array<Tensor>& tensors,
                   Stmt* init,
                   Stmt* provide) {
  Array<Expr>  args;
  for (IterVar iv : op->axis) {
    args.push_back(iv->var);
  }
  std::vector<Stmt> inits, provides;

  size_t size = op->body.size();
  const Reduce* reduce = op->body[0].as<Reduce>();
  CHECK(reduce);
  const CommReducerNode* combiner = reduce->combiner.as<CommReducerNode>();
  CHECK(combiner);
  Array<Expr> lhs;
  for (size_t i = 0; i < size; ++i) {
    lhs.push_back(tensors[i](args));
  }
  Array<Expr> init_value = combiner->identity_element;
  Array<Expr> update_value = (*combiner)(lhs, reduce->source);
  for (size_t i = 0; i < size; ++i) {
    Tensor t = tensors[i];
    inits.emplace_back(Provide::make(
          t->op, t->value_index, init_value[i], args));
    provides.emplace_back(Provide::make(
          t->op, t->value_index, update_value[i], args));
  }
  *init = Block::make(inits);
  *provide = Block::make(provides);
  if (!is_one(reduce->condition)) {
    *provide = IfThenElse::make(reduce->condition, *provide);
  }
}

// Normal computation.
Stmt MakeProvide(const ComputeOpNode* op,
                 const Tensor& t) {
  Array<Expr> args;
  for (IterVar iv : op->axis) {
    args.push_back(iv->var);
  }
  return Provide::make(t->op, t->value_index, op->body[t->value_index], args);
}

Stmt MakeComputeStmt(const ComputeOpNode* self,
                     const Stage& stage,
                     const std::unordered_map<IterVar, Range>& dom_map,
                     bool debug_keep_trivial_loop) {
  // grab the nest structure
  ComputeLoopNest n = ComputeLoopNest::make(self, stage, dom_map, debug_keep_trivial_loop);
  // Normal loop structure
  n.init_nest.emplace_back(op::MakeIfNest(n.init_predicates));
  n.main_nest.emplace_back(op::MakeIfNest(n.main_predicates));
  if (self->reduce_axis.size() != 0) {
    // make reduction.
    Stmt init, provide;
    Array<Tensor> source;
    for (size_t i = 0; i < self->body.size(); ++i) {
      source.push_back(stage->op.output(i));
    }
    MakeReduction(self, source, &init, &provide);
    init = MergeNest(n.init_nest, init);
    init = op::Substitute(init, n.init_vmap);
    // common nest
    std::vector<std::vector<Stmt> > common(
        n.main_nest.begin(), n.main_nest.begin() + n.num_common_loop + 1);
    std::vector<std::vector<Stmt> > reduce(
        n.main_nest.begin() + n.num_common_loop + 1, n.main_nest.end());
    provide = MergeNest(reduce, provide);
    if (debug_keep_trivial_loop) {
      provide = MergeNest(common, provide);
    } else {
      provide = MergeNest(common, Block::make(init, provide));
    }
    // run substitution in the on the full nest, because  loop condition
    // could depend on outer loops.
    return op::Substitute(provide, n.main_vmap);
  } else {
    std::vector<Stmt> provides;
    for (size_t i = 0; i < self->body.size(); ++i) {
      provides.emplace_back(MakeProvide(self, stage->op.output(i)));
    }
    Stmt provide = Block::make(provides);
    provide = MergeNest(n.main_nest, provide);
    // run substitution in the on the full nest, because  loop condition
    // could depend on outer loops.
    return op::Substitute(provide, n.main_vmap);
  }
}

enum class ComputeType {
  kNormal,
  kCrossThreadReduction,
  kTensorize
};

ComputeType DetectComputeType(const ComputeOpNode* self,
                              const Stage& stage) {
  // Verify correctness of leaf nest.
  int normal_red = 0, thread_red = 0, tensorize = 0;

  for (IterVar iv : stage->leaf_iter_vars) {
    IterVarAttr attr;
    auto it = stage->iter_var_attrs.find(iv);
    if (it != stage->iter_var_attrs.end()) {
      attr = (*it).second;
    }
    if (attr.defined() && attr->iter_type == kTensorized) {
      ++tensorize;
    }
    if (iv->iter_type == kCommReduce) {
      if (attr.defined() && attr->bind_thread.defined()) {
        ++thread_red;
      } else {
        ++normal_red;
      }
    } else {
      CHECK_EQ(thread_red, 0)
          << "Cross thread reduce cannot swap with normal data axis";
    }
  }
  if (tensorize != 0) {
    CHECK(thread_red == 0)
        << "Cannot mix cross thread reduction with Tensorize";
    return ComputeType::kTensorize;
  }
  CHECK(normal_red == 0 || thread_red == 0)
      << "Cannot mix normal reduction with thread reduce";
  if (thread_red != 0) {
    return ComputeType::kCrossThreadReduction;
  } else {
    return ComputeType::kNormal;
  }
}

// implement the provide utility.
Stmt ComputeOpNode::BuildProvide(
    const Stage& stage,
    const std::unordered_map<IterVar, Range>& dom_map,
    bool debug_keep_trivial_loop) const {
  CHECK_EQ(stage->op.operator->(), this);
  ComputeType ctype = DetectComputeType(this, stage);
  if (ctype == ComputeType::kCrossThreadReduction) {
    // specially handle cross thread reduction.
    return MakeCrossThreadReduction(this, stage, dom_map, debug_keep_trivial_loop);
  } else if (ctype == ComputeType::kTensorize) {
    return MakeTensorize(this, stage, dom_map, debug_keep_trivial_loop);
  } else {
    return MakeComputeStmt(this, stage, dom_map, debug_keep_trivial_loop);
  }
}

ComputeLoopNest ComputeLoopNest::make(
    const BaseComputeOpNode* self,
    const Stage& stage,
    const std::unordered_map<IterVar, Range>& dom_map,
    bool debug_keep_trivial_loop) {
  CHECK_EQ(stage->op.operator->(), self);
  ComputeLoopNest ret;
  // make main loop nest
  ret.main_nest = op::MakeLoopNest(
      stage, dom_map, 0, false, std::unordered_set<IterVar>(), &ret.main_vmap,
      debug_keep_trivial_loop);
  ret.main_predicates = schedule::MakeBoundCheck(
      stage, dom_map, ret.main_vmap, false,
      std::unordered_set<IterVar>());
  for (auto& e : ret.main_predicates) {
    e = likely(e);
  }
  if (stage->store_predicate.defined()) {
    ret.main_predicates.push_back(stage->store_predicate);
  }
  if (self->reduce_axis.size() != 0) {
    // try to find the location to insert the initialization.
    // Fuse the initialization and provide loop when possible.
    std::unordered_map<IterVar, int> update_state;
    for (IterVar iv : self->reduce_axis) {
      update_state[iv] = 2;
    }
    for (size_t i = 0; i < self->num_schedulable_dims(); ++i) {
      update_state[self->axis[i]] = 1;
    }
    // find which iter var is related to reduction and which is related to axis.
    schedule::PassDownBitMaskOr(stage, &update_state);
    auto leaf_iter_vars = stage->leaf_iter_vars;
    // first first loop that is related to reduction.
    size_t begin_loop = leaf_iter_vars.size();
    for (size_t i = 0; i < leaf_iter_vars.size(); ++i) {
      auto iv = leaf_iter_vars[i];
      int flag = update_state.at(iv);
      if ((flag & 2) != 0) {
        begin_loop = i; break;
      }
      ret.init_vmap[iv] = ret.main_vmap.at(iv);
    }
    ret.num_common_loop = begin_loop;
    // skip loops that are related to reduction and are unrelated to axis.
    std::unordered_set<IterVar> skip_iter;
    for (auto kv : update_state) {
      int flag = kv.second;
      if (flag == 2) skip_iter.insert(kv.first);
    }
    ret.init_nest = op::MakeLoopNest(
        stage, dom_map, begin_loop, true,
        skip_iter, &(ret.init_vmap), debug_keep_trivial_loop);
    ret.init_predicates = schedule::MakeBoundCheck(
        stage, dom_map, ret.init_vmap, true, skip_iter);
    for (auto& e : ret.init_predicates) {
      e = likely(e);
    }
  } else {
    CHECK_EQ(ret.main_nest.size(), stage->leaf_iter_vars.size() + 1);
    ret.num_common_loop = stage->leaf_iter_vars.size();
  }
  // copy elison here.
  return ret;
}

namespace {
/*!
 * \brief Verify if ComputeOp is valid with respect to Reduce operations.
 *
 *  The following two properties are verified:
 *  (1) All Reduce operations must exist at top level.
 *  (2) For a list of operations, if one is Reduce, then the others
 *      must be Reduce as well; and their inputs should have the
 *      same attribute except value_index.
 */
class ComputeVerifier final : protected ir::IRVisitor {
 public:
  /// Special member functions
  //@{
  explicit ComputeVerifier(const ComputeOpNode* compute)
      : compute_(compute), reduce_(compute->body[0].as<ir::Reduce>()) {}
  virtual ~ComputeVerifier() = default;
  ComputeVerifier(const ComputeVerifier&) = delete;
  ComputeVerifier(ComputeVerifier&&) = delete;
  ComputeVerifier& operator=(const ComputeVerifier&) = delete;
  ComputeVerifier& operator=(ComputeVerifier&&) = delete;
  //@}

  /// Interface to perform compute verification
  void Run() {
    for (const Expr e : compute_->body) {
      // Check for consistency of top level reductions
      const ir::Reduce* reduce = e.as<ir::Reduce>();
      CHECK((reduce && reduce_) || (!reduce && !reduce_))
          << "All ComputeOp should be consistent "
          << "with being Reduce operation or not.";

      if (reduce && reduce_) {
        CHECK(ReduceEqual(reduce, reduce_))
            << "The Reduce inputs of ComputeOp should "
            << "have the same attribute except value_index";
      }

      level_ = 0;
      ir::IRVisitor::Visit(e);
    }
  }

 protected:
  /// Visitor implementation
  //@{
  void Visit(const NodeRef& n) final {
    ++level_;
    ir::IRVisitor::Visit(n);
    --level_;
  }

  void Visit_(const ir::Reduce* op) final {
    // Check for non top level reductions
    CHECK(0 == level_)
        << "Reductions are only allowed at the top level of compute. "
        << "Please create another tensor for further composition.";
  }
  //@}

 private:
  const ComputeOpNode* compute_{nullptr};  ///< ComputeOpNode to verify
  const ir::Reduce* reduce_{nullptr};      ///< Top level Reduce operation
  int level_{0};                           ///< Level of op being processed
};
}  // namespace

/// Verify if ComputeOp is valid with respect to Reduce operations.
static void VerifyComputeOp(const ComputeOpNode* op) {
  ComputeVerifier v(op);
  v.Run();
}

Stmt TransformUpdate(const Stage& stage,
                     const std::unordered_map<IterVar, Range>& dom_map,
                     const ComputeLoopNest& n,
                     Stmt body,
                     Stmt update) {
  Array<Expr> conds;
  std::unordered_set<const Variable*> banned;
  for (size_t i = 0; i < stage->leaf_iter_vars.size(); ++i) {
    IterVar iv = stage->leaf_iter_vars[i];
    auto iit = stage->iter_var_attrs.find(iv);
    if (iit != stage->iter_var_attrs.end()) {
      const IterVarAttr& attr = (*iit).second;
      if (attr->iter_type == kTensorized) {
        break;
      }
    }
    if (iv->iter_type == kCommReduce) {
      auto vit = dom_map.find(iv);
      CHECK(vit != dom_map.end());
      const Range& vrange = vit->second;
      conds.push_back(likely(iv->var > vrange->min));
      banned.insert(iv->var.get());
    }
  }
  for (const Expr& pred : n.main_predicates) {
    if (ir::ExprUseVar(pred, banned)) {
      LOG(FATAL) << "Tensorize update transform failed, the condition "
                 << pred << " has a conflict with the reset condition";
    }
  }

  return IfThenElse::make(arith::ComputeReduce<ir::Or>(conds, const_true(1)),
                          update, body);
}
}  // namespace tvm


text:
<?php

// autoload_psr4.php @generated by Composer

$vendorDir = dirname(dirname(__FILE__));
$baseDir = dirname($vendorDir);

return array(
    'phpDocumentor\\Reflection\\' => array($vendorDir . '/phpdocumentor/reflection-common/src', $vendorDir . '/phpdocumentor/reflection-docblock/src', $vendorDir . '/phpdocumentor/type-resolver/src'),
    'Webmozart\\Assert\\' => array($vendorDir . '/webmozart/assert/src'),
    'Symfony\\Polyfill\\Php81\\' => array($vendorDir . '/symfony/polyfill-php81'),
    'Symfony\\Polyfill\\Php80\\' => array($vendorDir . '/symfony/polyfill-php80'),
    'Symfony\\Polyfill\\Php73\\' => array($vendorDir . '/symfony/polyfill-php73'),
    'Symfony\\Polyfill\\Mbstring\\' => array($vendorDir . '/symfony/polyfill-mbstring'),
    'Symfony\\Polyfill\\Intl\\Normalizer\\' => array($vendorDir . '/symfony/polyfill-intl-normalizer'),
    'Symfony\\Polyfill\\Intl\\Grapheme\\' => array($vendorDir . '/symfony/polyfill-intl-grapheme'),
    'Symfony\\Polyfill\\Ctype\\' => array($vendorDir . '/symfony/polyfill-ctype'),
    'Symfony\\Contracts\\Service\\' => array($vendorDir . '/symfony/service-contracts'),
    'Symfony\\Component\\Yaml\\' => array($vendorDir . '/symfony/yaml'),
    'Symfony\\Component\\String\\' => array($vendorDir . '/symfony/string'),
    'Symfony\\Component\\Stopwatch\\' => array($vendorDir . '/symfony/stopwatch'),
    'Symfony\\Component\\Filesystem\\' => array($vendorDir . '/symfony/filesystem'),
    'Symfony\\Component\\Console\\' => array($vendorDir . '/symfony/console'),
    'Symfony\\Component\\Config\\' => array($vendorDir . '/symfony/config'),
    'Psr\\Log\\' => array($vendorDir . '/psr/log/Psr/Log'),
    'Psr\\Http\\Message\\' => array($vendorDir . '/psr/http-factory/src', $vendorDir . '/psr/http-message/src'),
    'Psr\\Http\\Client\\' => array($vendorDir . '/psr/http-client/src'),
    'Psr\\Container\\' => array($vendorDir . '/psr/container/src'),
    'Prophecy\\' => array($vendorDir . '/phpspec/prophecy/src/Prophecy'),
    'PhpParser\\' => array($vendorDir . '/nikic/php-parser/lib/PhpParser'),
    'PhpCoveralls\\' => array($vendorDir . '/php-coveralls/php-coveralls/src'),
    'GuzzleHttp\\Psr7\\' => array($vendorDir . '/guzzlehttp/psr7/src'),
    'GuzzleHttp\\Promise\\' => array($vendorDir . '/guzzlehttp/promises/src'),
    'GuzzleHttp\\' => array($vendorDir . '/guzzlehttp/guzzle/src'),
    'Doctrine\\Instantiator\\' => array($vendorDir . '/doctrine/instantiator/src/Doctrine/Instantiator'),
    'DeepCopy\\' => array($vendorDir . '/myclabs/deep-copy/src/DeepCopy'),
);

redpajama_set_name: RedPajamaGithub


text:
package com.libqa.web.service.user;

import com.libqa.web.domain.User;
import com.libqa.web.domain.UserKeyword;
import com.libqa.web.repository.UserKeywordRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author : yion
 * @Date : 2015. 11. 10.
 * @Description :
 */
@Slf4j
@Service
public class UserKeywordServiceImpl implements UserKeywordService {

    @Autowired
    private UserKeywordRepository userKeywordRepository;

    @Override
    public List<UserKeyword> findByUserAndIsDeleted(User user) {
        List<UserKeyword> userKeywords = userKeywordRepository.findByUserAndIsDeleted(user, false);
        return userKeywords;
    }
}


text:
package org.apache.geode.tools.pulse.internal.data;

import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Locale;

import org.apache.logging.log4j.Level;

public class PulseConstants {

  public static final String APP_NAME = "PULSE";
  public static final String PULSE_LOG_FILE = APP_NAME + ".log";
  // public static final String PULSE_LOG_FILE_LOCATION =
  // System.getProperty("user.home");
  public static final String PULSE_PROPERTIES_FILE = "pulse.properties";
  public static final String PULSE_SECURITY_PROPERTIES_FILE = "pulsesecurity.properties";
  public static final String PULSE_NOTIFICATION_ALERT_DATE_PATTERN = "yyyy-MM-dd'T'HH:mm'Z'";
  public static final String LOG_MESSAGE_DATE_PATTERN = "yyyy/MM/dd HH:mm:ss.SSS z";

  public static final String LOG_MESSAGES_FILE = "LogMessages";
  public static final String APPLICATION_LANGUAGE = "en";
  public static final String APPLICATION_COUNTRY = "US";

  // Pulse version details properties from properties file
  public static final String PULSE_VERSION_PROPERTIES_FILE = "GemFireVersion.properties";
  public static final String PROPERTY_PULSE_VERSION = "Product-Version";
  public static final String PROPERTY_BUILD_ID = "Build-Id";
  public static final String PROPERTY_BUILD_DATE = "Build-Date";
  public static final String PROPERTY_SOURCE_DATE = "Source-Date";
  public static final String PROPERTY_SOURCE_REVISION = "Source-Revision";
  public static final String PROPERTY_SOURCE_REPOSITORY = "Source-Repository";

  // DEFAULT CONFIGUARTION VALUES FOR PULSE LOGGER
  // Log File
  public static final String PULSE_QUERY_HISTORY_FILE_NAME = APP_NAME + "_QueryHistory.json";
  // Log File location
  public static final String PULSE_QUERY_HISTORY_FILE_LOCATION = System.getProperty("user.home");
  // Date pattern to be used in log messages
  public static final String PULSE_QUERY_HISTORY_DATE_PATTERN = "EEE, MMM dd yyyy, HH:mm:ss z";

  // Use US locale so that number formatting remains consistent in the UI
  public static DecimalFormat TWO_PLACE_DECIMAL_FORMAT =
      (DecimalFormat) NumberFormat.getNumberInstance(Locale.US);
  public static DecimalFormat FOUR_PLACE_DECIMAL_FORMAT =
      (DecimalFormat) NumberFormat.getNumberInstance(Locale.US);
  static {
    TWO_PLACE_DECIMAL_FORMAT.applyPattern("###.##");
    FOUR_PLACE_DECIMAL_FORMAT.applyPattern("0.0000");
  }

  // DEFAULT VALUES
  public static final String GEMFIRE_DEFAULT_HOST = "localhost";
  public static final String GEMFIRE_DEFAULT_PORT = "1099";

  // DEFAULT CONFIGUARTION VALUES FOR PULSE LOGGER
  // Log File
  public static final String PULSE_LOG_FILE_NAME = APP_NAME;
  // Log File location
  public static final String PULSE_LOG_FILE_LOCATION = System.getProperty("user.home");
  // Date pattern to be used in log messages
  public static final String PULSE_LOG_MESSAGE_DATE_PATTERN = "yyyy/MM/dd HH:mm:ss.SSS z";
  // Log file size - 1MB.
  public static final int PULSE_LOG_FILE_SIZE = 1024 * 1024;
  // The log file count - 4 files.
  public static final int PULSE_LOG_FILE_COUNT = 4;
  // Append logs - true.
  public static final boolean PULSE_LOG_APPEND = true;
  // Log level - FINE
  public static final Level PULSE_LOG_LEVEL = Level.DEBUG;

  // SYSTEM PROPERTIES
  public static final String SYSTEM_PROPERTY_PULSE_EMBEDDED = "pulse.embedded";
  public static final String SYSTEM_PROPERTY_PULSE_EMBEDDED_SQLF = "pulse.embedded.sqlf";
  public static final String SYSTEM_PROPERTY_PULSE_USELOCATOR = "pulse.useLocator";
  public static final String SYSTEM_PROPERTY_PULSE_HOST = "pulse.host";
  public static final String SYSTEM_PROPERTY_PULSE_PORT = "pulse.port";

  // APPLICATION PROPERTIES
  public static final String APPLICATION_PROPERTY_PULSE_USELOCATOR = "pulse.useLocator";
  public static final String APPLICATION_PROPERTY_PULSE_HOST = "pulse.host";
  public static final String APPLICATION_PROPERTY_PULSE_PORT = "pulse.port";
  public static final String APPLICATION_PROPERTY_PULSE_JMXUSERNAME = "pulse.jmxUserName";
  public static final String APPLICATION_PROPERTY_PULSE_JMXPASSWORD = "pulse.jmxUserPassword";
  public static final String APPLICATION_PROPERTY_PULSE_LOGFILENAME = "pulse.Log-File-Name";
  public static final String APPLICATION_PROPERTY_PULSE_LOGFILELOCATION = "pulse.Log-File-Location";
  public static final String APPLICATION_PROPERTY_PULSE_LOGFILESIZE = "pulse.Log-File-Size";
  public static final String APPLICATION_PROPERTY_PULSE_LOGFILECOUNT = "pulse.Log-File-Count";
  public static final String APPLICATION_PROPERTY_PULSE_LOGDATEPATTERN = "pulse.Log-Date-Pattern";
  public static final String APPLICATION_PROPERTY_PULSE_LOGLEVEL = "pulse.Log-Level";
  public static final String APPLICATION_PROPERTY_PULSE_LOGAPPEND = "pulse.Log-Append";
  public static final String APPLICATION_PROPERTY_PULSE_PRODUCTSUPPORT = "pulse.product";
  public static final String APPLICATION_PROPERTY_PULSE_SEC_PROFILE_GEMFIRE =
      "pulse.authentication.gemfire";
  public static final String APPLICATION_PROPERTY_PULSE_SEC_PROFILE_DEFAULT =
      "pulse.authentication.default";
  public static final String APPLICATION_PROPERTY_PULSE_SPRING_PROFILE_KEY =
      "spring.profiles.default";

  // STRING FLAGS
  public static final String STRING_FLAG_TRUE = "true";
  public static final String STRING_FLAG_FALSE = "false";
  public static final String DEFAULT_SERVER_GROUP = "Default";
  public static final String DEFAULT_REDUNDANCY_ZONE = "Default";
  public static final String JVM_PAUSES_TYPE_CLUSTER = "cluster";
  public static final String JVM_PAUSES_TYPE_MEMBER = "member";

  // CONSTANTS FOR MBEAN DATA
  public static final String OBJECT_DOMAIN_NAME_GEMFIRE = "GemFire";
  public static final String OBJECT_DOMAIN_NAME_SQLFIRE = "GemFireXD";
  public static final String OBJECT_NAME_MEMBER = OBJECT_DOMAIN_NAME_GEMFIRE + ":type=Member,*";
  public static final String OBJECT_NAME_MEMBER_MANAGER =
      OBJECT_DOMAIN_NAME_GEMFIRE + ":service=Manager,type=Member,*";
  public static final String OBJECT_NAME_SYSTEM_DISTRIBUTED =
      OBJECT_DOMAIN_NAME_GEMFIRE + ":service=System,type=Distributed";
  public static final String OBJECT_NAME_REGION_DISTRIBUTED =
      OBJECT_DOMAIN_NAME_GEMFIRE + ":service=Region,type=Distributed,*";
  public static final String OBJECT_NAME_STATEMENT_DISTRIBUTED =
      OBJECT_DOMAIN_NAME_SQLFIRE + ":service=Statement,type=Aggregate,*";
  public static final String OBJECT_NAME_SF_CLUSTER =
      OBJECT_DOMAIN_NAME_SQLFIRE + ":service=Cluster";
  public static final String OBJECT_NAME_SF_MEMBER_PATTERN =
      OBJECT_DOMAIN_NAME_SQLFIRE + ":group=*,type=Member,member=";
  public static final String OBJECT_NAME_TABLE_AGGREGATE =
      OBJECT_DOMAIN_NAME_SQLFIRE + ":service=Table,type=Aggregate,table=*";
  public static final String OBJECT_NAME_TABLE_AGGREGATE_PATTERN =
      OBJECT_DOMAIN_NAME_SQLFIRE + ":service=Table,type=Aggregate,table=";
  public static final String OBJECT_NAME_REGION_ON_MEMBER_REGION =
      OBJECT_DOMAIN_NAME_GEMFIRE + ":service=Region,name=";
  public static final String OBJECT_NAME_REGION_ON_MEMBER_MEMBER = ",type=Member,member=";
  public static final String OBJECT_NAME_ACCESSCONTROL_MBEAN =
      "GemFire:service=AccessControl,type=Distributed";

  public static final String MBEAN_KEY_PROPERTY_SERVICE = "service";
  public static final String MBEAN_KEY_PROPERTY_SERVICE_VALUE_REGION = "Region";
  public static final String MBEAN_KEY_PROPERTY_SERVICE_VALUE_CACHESERVER = "CacheServer";
  public static final String MBEAN_KEY_PROPERTY_SERVICE_VALUE_GATEWAYRECEIVER = "GatewayReceiver";
  public static final String MBEAN_KEY_PROPERTY_SERVICE_VALUE_GATEWAYSENDER = "GatewaySender";
  public static final String MBEAN_KEY_PROPERTY_SERVICE_VALUE_ASYNCEVENTQUEUE = "AsyncEventQueue";
  public static final String MBEAN_KEY_PROPERTY_SERVICE_VALUE_LOCATOR = "Locator";
  public static final String MBEAN_KEY_PROPERTY_REGION_NAME = "name";

  public static final String MBEAN_KEY_PROPERTY_MEMBER = "member";

  public static final String MBEAN_ATTRIBUTE_MEMBER = "Member";
  public static final String MBEAN_ATTRIBUTE_MEMBERS = "Members";
  public static final String MBEAN_ATTRIBUTE_MANAGER = "Manager";
  public static final String MBEAN_ATTRIBUTE_LOCATOR = "Locator";
  public static final String MBEAN_ATTRIBUTE_SERVER = "Server";
  public static final String MBEAN_ATTRIBUTE_SERVERGROUPS = "Groups";
  public static final String MBEAN_ATTRIBUTE_REDUNDANCYZONES = "RedundancyZone";
  public static final String MBEAN_ATTRIBUTE_DATASTORE = "DataStore";
  public static final String MBEAN_ATTRIBUTE_ID = "Id";

  public static final String MBEAN_ATTRIBUTE_GEMFIREVERSION = "Version";
  public static final String MBEAN_ATTRIBUTE_MEMBERCOUNT = "MemberCount";
  public static final String MBEAN_ATTRIBUTE_NUMCLIENTS = "NumClients";
  public static final String MBEAN_ATTRIBUTE_NETWORKSERVERCLIENTCONNECTIONSTATS =
      "NetworkServerClientConnectionStats";
  public static final String MBEAN_ATTRIBUTE_DISTRIBUTEDSYSTEMID = "DistributedSystemId";
  public static final String MBEAN_ATTRIBUTE_LOCATORCOUNT = "LocatorCount";
  public static final String MBEAN_ATTRIBUTE_TOTALREGIONCOUNT = "TotalRegionCount";
  public static final String MBEAN_ATTRIBUTE_NUMRUNNIGFUNCTION = "NumRunningFunctions";
  public static final String MBEAN_ATTRIBUTE_PROCEDURECALLSCOMPLETED = "ProcedureCallsCompleted";
  public static final String MBEAN_ATTRIBUTE_PROCEDURECALLSINPROGRESS = "ProcedureCallsInProgress";
  public static final String MBEAN_ATTRIBUTE_REGISTEREDCQCOUNT = "RegisteredCQCount";
  public static final String MBEAN_ATTRIBUTE_NUMSUBSCRIPTIONS = "NumSubscriptions";
  public static final String MBEAN_ATTRIBUTE_NUMTXNCOMMITTED = "TransactionCommitted";
  public static final String MBEAN_ATTRIBUTE_NUMTXNROLLBACK = "TransactionRolledBack";
  public static final String MBEAN_ATTRIBUTE_TOTALHEAPSIZE = "TotalHeapSize";
  public static final String MBEAN_ATTRIBUTE_USEDHEAPSIZE = "UsedHeapSize";
  public static final String MBEAN_ATTRIBUTE_OFFHEAPFREESIZE = "OffHeapFreeSize";
  public static final String MBEAN_ATTRIBUTE_OFFHEAPUSEDSIZE = "OffHeapUsedSize";
  public static final String MBEAN_ATTRIBUTE_TOTALREGIONENTRYCOUNT = "TotalRegionEntryCount";
  public static final String MBEAN_ATTRIBUTE_CURRENTENTRYCOUNT = "CurrentQueryCount";
  public static final String MBEAN_ATTRIBUTE_TOTALDISKUSAGE = "TotalDiskUsage";
  public static final String MBEAN_ATTRIBUTE_DISKWRITESRATE = "DiskWritesRate";
  public static final String MBEAN_ATTRIBUTE_AVERAGEWRITES = "AverageWrites";
  public static final String MBEAN_ATTRIBUTE_DISKREADSRATE = "DiskReadsRate";
  public static final String MBEAN_ATTRIBUTE_AVERAGEREADS = "AverageReads";
  public static final String MBEAN_ATTRIBUTE_QUERYREQUESTRATE = "QueryRequestRate";
  public static final String MBEAN_ATTRIBUTE_JVMPAUSES = "JVMPauses";
  public static final String MBEAN_ATTRIBUTE_HOST = "Host";
  public static final String MBEAN_ATTRIBUTE_HOSTNAMEFORCLIENTS = "HostnameForClients";
  public static final String MBEAN_ATTRIBUTE_HOSTNAMEFORCLIENTS_ALT = "HostNameForClients";
  public static final String MBEAN_ATTRIBUTE_BINDADDRESS = "BindAddress";
  public static final String MBEAN_ATTRIBUTE_PORT = "Port";
  public static final String MBEAN_ATTRIBUTE_EVENTRECEIVEDDATE = "EventsReceivedRate";
  public static final String MBEAN_ATTRIBUTE_AVEARGEBATCHPROCESSINGTIME =
      "AverageBatchProcessingTime";
  public static final String MBEAN_ATTRIBUTE_RUNNING = "Running";
  public static final String MBEAN_ATTRIBUTE_BATCHSIZE = "BatchSize";
  public static final String MBEAN_ATTRIBUTE_SENDERID = "SenderId";
  public static final String MBEAN_ATTRIBUTE_EVENTQUEUESIZE = "EventQueueSize";
  public static final String MBEAN_ATTRIBUTE_PRIMARY = "Primary";
  public static final String MBEAN_ATTRIBUTE_PERSISTENCEENABLED = "PersistenceEnabled";
  public static final String MBEAN_ATTRIBUTE_PARALLEL = "Parallel";
  public static final String MBEAN_ATTRIBUTE_REMOTE_DS_ID = "RemoteDSId";
  public static final String MBEAN_ATTRIBUTE_EVENTS_EXCEEDING_ALERT_THRESHOLD =
      "EventsExceedingAlertThreshold";
  public static final String MBEAN_ATTRIBUTE_FULLPATH = "FullPath";
  public static final String MBEAN_ATTRIBUTE_EMPTYNODES = "EmptyNodes";
  public static final String MBEAN_ATTRIBUTE_GETSRATE = "GetsRate";
  public static final String MBEAN_ATTRIBUTE_PUTSRATE = "PutsRate";
  public static final String MBEAN_ATTRIBUTE_LRUEVICTIONRATE = "LruEvictionRate";
  public static final String MBEAN_ATTRIBUTE_REGIONTYPE = "RegionType";
  public static final String MBEAN_ATTRIBUTE_ENTRYSIZE = "EntrySize";
  public static final String MBEAN_ATTRIBUTE_SYSTEMREGIONENTRYCOUNT = "SystemRegionEntryCount";
  public static final String MBEAN_ATTRIBUTE_PERSISTENTENABLED = "PersistentEnabled";
  public static final String MBEAN_ATTRIBUTE_NAME = "Name";
  public static final String MBEAN_ATTRIBUTE_GATEWAYENABLED = "GatewayEnabled";
  public static final String MBEAN_ATTRIBUTE_DISKUSAGE = "DiskUsage";
  public static final String MBEAN_ATTRIBUTE_TOTALFILEDESCRIPTOROPEN = "TotalFileDescriptorOpen";
  public static final String MBEAN_ATTRIBUTE_LOADAVERAGE = "LoadAverage";
  public static final String MBEAN_ATTRIBUTE_CURRENTHEAPSIZE = "CurrentHeapSize"; // deprecated in
                                                                                // Gemfire8.1
  public static final String MBEAN_ATTRIBUTE_USEDMEMORY = "UsedMemory";
  public static final String MBEAN_ATTRIBUTE_MAXIMUMHEAPSIZE = "MaximumHeapSize"; // deprecated in
                                                                                // Gemfire8.1
  public static final String MBEAN_ATTRIBUTE_MAXMEMORY = "MaxMemory";
  public static final String MBEAN_ATTRIBUTE_NUMTHREADS = "NumThreads";
  public static final String MBEAN_ATTRIBUTE_MEMBERUPTIME = "MemberUpTime";
  public static final String MBEAN_ATTRIBUTE_TOTALBYTESONDISK = "TotalBytesOnDisk";
  public static final String MBEAN_ATTRIBUTE_CPUUSAGE = "CpuUsage";
  public static final String MBEAN_ATTRIBUTE_HOSTCPUUSAGE = "HostCpuUsage";
  public static final String MBEAN_ATTRIBUTE_ENTRYCOUNT = "EntryCount";
  public static final String MBEAN_ATTRIBUTE_NUMBEROFROWS = "NumberOfRows";
  public static final String MBEAN_ATTRIBUTE_LOCALMAXMEMORY = "LocalMaxMemory";

  public static final String MBEAN_ATTRIBUTE_NUMTIMESCOMPILED = "NumTimesCompiled";
  public static final String MBEAN_ATTRIBUTE_NUMEXECUTION = "NumExecution";
  public static final String MBEAN_ATTRIBUTE_NUMEXECUTIONSINPROGRESS = "NumExecutionsInProgress";
  public static final String MBEAN_ATTRIBUTE_NUMTIMESGLOBALINDEXLOOKUP =
      "NumTimesGlobalIndexLookup";
  public static final String MBEAN_ATTRIBUTE_NUMROWSMODIFIED = "NumRowsModified";
  public static final String MBEAN_ATTRIBUTE_PARSETIME = "ParseTime";
  public static final String MBEAN_ATTRIBUTE_BINDTIME = "BindTime";
  public static final String MBEAN_ATTRIBUTE_OPTIMIZETIME = "OptimizeTime";
  public static final String MBEAN_ATTRIBUTE_ROUTINGINFOTIME = "RoutingInfoTime";
  public static final String MBEAN_ATTRIBUTE_GENERATETIME = "GenerateTime";
  public static final String MBEAN_ATTRIBUTE_TOTALCOMPILATIONTIME = "TotalCompilationTime";
  public static final String MBEAN_ATTRIBUTE_EXECUTIONTIME = "ExecutionTime";
  public static final String MBEAN_ATTRIBUTE_PROJECTIONTIME = "ProjectionTime";
  public static final String MBEAN_ATTRIBUTE_TOTALEXECUTIONTIME = "TotalExecutionTime";
  public static final String MBEAN_ATTRIBUTE_ROWSMODIFICATIONTIME = "RowsModificationTime";
  public static final String MBEAN_ATTRIBUTE_QNNUMROWSSEEN = "QNNumRowsSeen";
  public static final String MBEAN_ATTRIBUTE_QNMSGSENDTIME = "QNMsgSendTime";
  public static final String MBEAN_ATTRIBUTE_QNMSGSERTIME = "QNMsgSerTime";
  public static final String MBEAN_ATTRIBUTE_QNRESPDESERTIME = "QNRespDeSerTime";
  public static final String MBEAN_ATTRIBUTE_QUERYDEFINITION = "Query";

  public static final String MBEAN_ATTRIBUTE_AEQ_ASYNCEVENTID = "Id";
  public static final String MBEAN_ATTRIBUTE_AEQ_PRIMARY = "Primary";
  public static final String MBEAN_ATTRIBUTE_AEQ_PARALLEL = "Parallel";
  public static final String MBEAN_ATTRIBUTE_AEQ_BATCH_SIZE = "BatchSize";
  public static final String MBEAN_ATTRIBUTE_AEQ_BATCH_TIME_INTERVAL = "BatchTimeInterval";
  public static final String MBEAN_ATTRIBUTE_AEQ_BATCH_CONFLATION_ENABLED =
      "BatchConflationEnabled";
  public static final String MBEAN_ATTRIBUTE_AEQ_ASYNC_EVENT_LISTENER = "AsyncEventListener";
  public static final String MBEAN_ATTRIBUTE_AEQ_EVENT_QUEUE_SIZE = "EventQueueSize";

  // column names
  public static final String MBEAN_COLNAME_NUMTIMESCOMPILED = "NumTimesCompiled";
  public static final String MBEAN_COLNAME_NUMEXECUTION = "NumExecution";
  public static final String MBEAN_COLNAME_NUMEXECUTIONSINPROGRESS = "NumExecutionsInProgress";
  public static final String MBEAN_COLNAME_NUMTIMESGLOBALINDEXLOOKUP = "NumTimesGlobalIndexLookup";
  public static final String MBEAN_COLNAME_NUMROWSMODIFIED = "NumRowsModified";
  public static final String MBEAN_COLNAME_PARSETIME = "ParseTime(ms)";
  public static final String MBEAN_COLNAME_BINDTIME = "BindTime(ms)";
  public static final String MBEAN_COLNAME_OPTIMIZETIME = "OptimizeTime(ms)";
  public static final String MBEAN_COLNAME_ROUTINGINFOTIME = "RoutingInfoTime(ms)";
  public static final String MBEAN_COLNAME_GENERATETIME = "GenerateTime(ms)";
  public static final String MBEAN_COLNAME_TOTALCOMPILATIONTIME = "TotalCompilationTime(ms)";
  public static final String MBEAN_COLNAME_EXECUTIONTIME = "ExecutionTime(ns)";
  public static final String MBEAN_COLNAME_PROJECTIONTIME = "ProjectionTime(ns)";
  public static final String MBEAN_COLNAME_TOTALEXECUTIONTIME = "TotalExecutionTime(ns)";
  public static final String MBEAN_COLNAME_ROWSMODIFICATIONTIME = "RowsModificationTime(ns)";
  public static final String MBEAN_COLNAME_QNNUMROWSSEEN = "QNNumRowsSeen";
  public static final String MBEAN_COLNAME_QNMSGSENDTIME = "QNMsgSendTime(ns)";
  public static final String MBEAN_COLNAME_QNMSGSERTIME = "QNMsgSerTime(ns)";
  public static final String MBEAN_COLNAME_QNRESPDESERTIME = "QNRespDeSerTime(ns)";
  public static final String MBEAN_COLNAME_QUERYDEFINITION = "Query";

  // TODO : add attributes for aggregate statistics
  // public static final String MBEAN_ATTRIBUTE_ENTRYCOUNT = "EntryCount";

  public static final String MBEAN_MANAGER_ATTRIBUTE_PULSEURL = "PulseURL";

  public static final String MBEAN_OPERATION_LISTCACHESERVER = "listCacheServers";
  public static final String MBEAN_OPERATION_LISTSERVERS = "listServers";
  public static final String MBEAN_OPERATION_VIEWREMOTECLUSTERSTATUS = "viewRemoteClusterStatus";
  public static final String MBEAN_OPERATION_SHOWALLCLIENTS = "showAllClientStats";
  public static final String MBEAN_OPERATION_LISTREGIONATTRIBUTES = "listRegionAttributes";
  public static final String MBEAN_OPERATION_QUERYDATABROWSER = "queryData";

  // COMPOSITE DATA KEYS
  public static final String COMPOSITE_DATA_KEY_CLIENTID = "clientId";
  public static final String COMPOSITE_DATA_KEY_NAME = "name";
  public static final String COMPOSITE_DATA_KEY_HOSTNAME = "hostName";
  public static final String COMPOSITE_DATA_KEY_QUEUESIZE = "queueSize";
  public static final String COMPOSITE_DATA_KEY_PROCESSCPUTIME = "processCpuTime";
  public static final String COMPOSITE_DATA_KEY_UPTIME = "upTime";
  public static final String COMPOSITE_DATA_KEY_NUMOFTHREADS = "numOfThreads";
  public static final String COMPOSITE_DATA_KEY_NUMOFGETS = "numOfGets";
  public static final String COMPOSITE_DATA_KEY_NUMOFPUTS = "numOfPuts";
  public static final String COMPOSITE_DATA_KEY_CPUS = "cpus";
  public static final String COMPOSITE_DATA_KEY_CLIENTCQCOUNT = "clientCQCount";
  public static final String COMPOSITE_DATA_KEY_SUBSCRIPTIONENABLED = "subscriptionEnabled";
  public static final String COMPOSITE_DATA_KEY_SCOPE = "scope";
  public static final String COMPOSITE_DATA_KEY_DISKSTORENAME = "diskStoreName";
  public static final String COMPOSITE_DATA_KEY_DISKSYNCHRONOUS = "diskSynchronous";
  public static final String COMPOSITE_DATA_KEY_COMPRESSIONCODEC = "compressionCodec";
  public static final String COMPOSITE_DATA_KEY_ENABLEOFFHEAPMEMORY = "enableOffHeapMemory";
  public static final String COMPOSITE_DATA_KEY_CONNECTIONSACTIVE = "connectionsActive";
  public static final String COMPOSITE_DATA_KEY_CONNECTED = "connected";

  public static final String ALERT_DESC_SEVERE = "Severe Alert! The cluster is on fire !";
  public static final String ALERT_DESC_ERROR =
      "Error Alert! There is a problem with your cluster ! Better fix it !";
  public static final String ALERT_DESC_WARNING =
      "Warning Alert! Look at this cluster after you finish your coffee !";
  public static final String ALERT_DESC_INFO = "Info Alert! For your kind information !";

  public static final String NOTIFICATION_TYPE_SYSTEM_ALERT = "system.alert";
  public static final String NOTIFICATION_TYPE_CACHE_MEMBER_DEPARTED =
      "gemfire.distributedsystem.cache.member.departed";
  public static final String NOTIFICATION_TYPE_REGION_DESTROYED =
      "gemfire.distributedsystem.cache.region.closed";

  public static final String PRODUCT_NAME_GEMFIRE = "gemfire"; // For GemFire
  public static final String PRODUCT_NAME_SQLFIRE = "gemfirexd"; // For SQLFire

  // Following attributes are not present in 9.0
  // "Members"
  // "EmptyNodes"
  // "SystemRegionEntryCount"
  // "MemberCount"
  public static final String[] REGION_MBEAN_ATTRIBUTES = {MBEAN_ATTRIBUTE_MEMBERS,
      MBEAN_ATTRIBUTE_FULLPATH, MBEAN_ATTRIBUTE_DISKREADSRATE, MBEAN_ATTRIBUTE_DISKWRITESRATE,
      MBEAN_ATTRIBUTE_EMPTYNODES, MBEAN_ATTRIBUTE_GETSRATE, MBEAN_ATTRIBUTE_LRUEVICTIONRATE,
      MBEAN_ATTRIBUTE_PUTSRATE, MBEAN_ATTRIBUTE_REGIONTYPE, MBEAN_ATTRIBUTE_ENTRYSIZE,
      MBEAN_ATTRIBUTE_ENTRYCOUNT, MBEAN_ATTRIBUTE_SYSTEMREGIONENTRYCOUNT,
      MBEAN_ATTRIBUTE_MEMBERCOUNT, MBEAN_ATTRIBUTE_PERSISTENTENABLED, MBEAN_ATTRIBUTE_NAME,
      MBEAN_ATTRIBUTE_GATEWAYENABLED, MBEAN_ATTRIBUTE_DISKUSAGE, MBEAN_ATTRIBUTE_LOCALMAXMEMORY};

  public static final String[] CLUSTER_MBEAN_ATTRIBUTES = {MBEAN_ATTRIBUTE_MEMBERCOUNT,
      MBEAN_ATTRIBUTE_NUMCLIENTS, MBEAN_ATTRIBUTE_DISTRIBUTEDSYSTEMID, MBEAN_ATTRIBUTE_LOCATORCOUNT,
      MBEAN_ATTRIBUTE_TOTALREGIONCOUNT, MBEAN_ATTRIBUTE_NUMRUNNIGFUNCTION,
      MBEAN_ATTRIBUTE_REGISTEREDCQCOUNT, MBEAN_ATTRIBUTE_NUMSUBSCRIPTIONS,
      MBEAN_ATTRIBUTE_NUMTXNCOMMITTED, MBEAN_ATTRIBUTE_NUMTXNROLLBACK,
      MBEAN_ATTRIBUTE_TOTALHEAPSIZE, MBEAN_ATTRIBUTE_USEDHEAPSIZE,
      MBEAN_ATTRIBUTE_TOTALREGIONENTRYCOUNT, MBEAN_ATTRIBUTE_CURRENTENTRYCOUNT,
      MBEAN_ATTRIBUTE_TOTALDISKUSAGE, MBEAN_ATTRIBUTE_DISKWRITESRATE, MBEAN_ATTRIBUTE_AVERAGEWRITES,
      MBEAN_ATTRIBUTE_AVERAGEREADS, MBEAN_ATTRIBUTE_QUERYREQUESTRATE, MBEAN_ATTRIBUTE_DISKREADSRATE,
      MBEAN_ATTRIBUTE_JVMPAUSES};

  public static final String[] GATEWAY_MBEAN_ATTRIBUTES =
      {MBEAN_ATTRIBUTE_PORT, MBEAN_ATTRIBUTE_EVENTRECEIVEDDATE,
          MBEAN_ATTRIBUTE_AVEARGEBATCHPROCESSINGTIME, MBEAN_ATTRIBUTE_RUNNING};

  public static final String[] GATEWAYSENDER_MBEAN_ATTRIBUTES =
      {MBEAN_ATTRIBUTE_EVENTRECEIVEDDATE, MBEAN_ATTRIBUTE_BATCHSIZE, MBEAN_ATTRIBUTE_SENDERID,
          MBEAN_ATTRIBUTE_EVENTQUEUESIZE, MBEAN_ATTRIBUTE_RUNNING, MBEAN_ATTRIBUTE_PRIMARY,
          MBEAN_ATTRIBUTE_PERSISTENCEENABLED, MBEAN_ATTRIBUTE_PARALLEL,
          MBEAN_ATTRIBUTE_REMOTE_DS_ID, MBEAN_ATTRIBUTE_EVENTS_EXCEEDING_ALERT_THRESHOLD};

  public static final String[] ASYNC_EVENT_QUEUE_MBEAN_ATTRIBUTES =
      {MBEAN_ATTRIBUTE_AEQ_ASYNCEVENTID, MBEAN_ATTRIBUTE_AEQ_PRIMARY, MBEAN_ATTRIBUTE_AEQ_PARALLEL,
          MBEAN_ATTRIBUTE_AEQ_BATCH_SIZE, MBEAN_ATTRIBUTE_AEQ_BATCH_TIME_INTERVAL,
          MBEAN_ATTRIBUTE_AEQ_BATCH_CONFLATION_ENABLED, MBEAN_ATTRIBUTE_AEQ_ASYNC_EVENT_LISTENER,
          MBEAN_ATTRIBUTE_AEQ_EVENT_QUEUE_SIZE};

  public static final String[] MEMBER_MBEAN_ATTRIBUTES = {MBEAN_ATTRIBUTE_MANAGER,
      MBEAN_ATTRIBUTE_TOTALREGIONCOUNT, MBEAN_ATTRIBUTE_LOCATOR, MBEAN_ATTRIBUTE_TOTALDISKUSAGE,
      MBEAN_ATTRIBUTE_SERVER, MBEAN_ATTRIBUTE_TOTALFILEDESCRIPTOROPEN, MBEAN_ATTRIBUTE_LOADAVERAGE,
      MBEAN_ATTRIBUTE_DISKWRITESRATE, MBEAN_ATTRIBUTE_DISKREADSRATE, MBEAN_ATTRIBUTE_JVMPAUSES,
      MBEAN_ATTRIBUTE_USEDMEMORY, MBEAN_ATTRIBUTE_MAXMEMORY, MBEAN_ATTRIBUTE_NUMTHREADS,
      MBEAN_ATTRIBUTE_MEMBERUPTIME, MBEAN_ATTRIBUTE_HOST, MBEAN_ATTRIBUTE_HOSTNAMEFORCLIENTS,
      MBEAN_ATTRIBUTE_BINDADDRESS, MBEAN_ATTRIBUTE_TOTALBYTESONDISK, MBEAN_ATTRIBUTE_CPUUSAGE,
      MBEAN_ATTRIBUTE_HOSTCPUUSAGE, MBEAN_ATTRIBUTE_MEMBER, MBEAN_ATTRIBUTE_ID,
      MBEAN_ATTRIBUTE_AVERAGEREADS, MBEAN_ATTRIBUTE_AVERAGEWRITES, MBEAN_ATTRIBUTE_OFFHEAPFREESIZE,
      MBEAN_ATTRIBUTE_OFFHEAPUSEDSIZE, MBEAN_ATTRIBUTE_SERVERGROUPS,
      MBEAN_ATTRIBUTE_REDUNDANCYZONES, MBEAN_ATTRIBUTE_GEMFIREVERSION};

  public static final String[] STATEMENT_MBEAN_ATTRIBUTES = {MBEAN_ATTRIBUTE_NAME,
      MBEAN_ATTRIBUTE_NUMTIMESCOMPILED, MBEAN_ATTRIBUTE_NUMEXECUTION,
      MBEAN_ATTRIBUTE_NUMEXECUTIONSINPROGRESS, MBEAN_ATTRIBUTE_NUMTIMESGLOBALINDEXLOOKUP,
      MBEAN_ATTRIBUTE_NUMROWSMODIFIED, MBEAN_ATTRIBUTE_PARSETIME, MBEAN_ATTRIBUTE_BINDTIME,
      MBEAN_ATTRIBUTE_OPTIMIZETIME, MBEAN_ATTRIBUTE_ROUTINGINFOTIME, MBEAN_ATTRIBUTE_GENERATETIME,
      MBEAN_ATTRIBUTE_TOTALCOMPILATIONTIME, MBEAN_ATTRIBUTE_EXECUTIONTIME,
      MBEAN_ATTRIBUTE_PROJECTIONTIME, MBEAN_ATTRIBUTE_TOTALEXECUTIONTIME,
      MBEAN_ATTRIBUTE_ROWSMODIFICATIONTIME, MBEAN_ATTRIBUTE_QNNUMROWSSEEN,
      MBEAN_ATTRIBUTE_QNMSGSENDTIME, MBEAN_ATTRIBUTE_QNMSGSERTIME};

  public static final String[] REGION_ON_MEMBER_MBEAN_ATTRIBUTES =
      {MBEAN_ATTRIBUTE_ENTRYSIZE, MBEAN_ATTRIBUTE_ENTRYCOUNT, MBEAN_ATTRIBUTE_PUTSRATE,
          MBEAN_ATTRIBUTE_GETSRATE, MBEAN_ATTRIBUTE_DISKREADSRATE, MBEAN_ATTRIBUTE_DISKWRITESRATE,
          MBEAN_ATTRIBUTE_LOCALMAXMEMORY};

  public static final String[] SF_CLUSTER_MBEAN_ATTRIBUTES = {
      MBEAN_ATTRIBUTE_PROCEDURECALLSINPROGRESS, MBEAN_ATTRIBUTE_NETWORKSERVERCLIENTCONNECTIONSTATS};

  public static final String[] SF_MEMBER_MBEAN_ATTRIBUTES =
      {MBEAN_ATTRIBUTE_DATASTORE, MBEAN_ATTRIBUTE_NETWORKSERVERCLIENTCONNECTIONSTATS};

  public static final String[] SF_TABLE_MBEAN_ATTRIBUTES =
      {MBEAN_ATTRIBUTE_ENTRYSIZE, MBEAN_ATTRIBUTE_NUMBEROFROWS};

  public static final String PULSE_ROLES[] = {"CLUSTER:READ", "DATA:READ"};

  // SSL Related attributes

  public static final String SSL_KEYSTORE = "javax.net.ssl.keyStore";
  public static final String SSL_KEYSTORE_PASSWORD = "javax.net.ssl.keyStorePassword";
  public static final String SSL_TRUSTSTORE = "javax.net.ssl.trustStore";
  public static final String SSL_TRUSTSTORE_PASSWORD = "javax.net.ssl.trustStorePassword";
  public static final String SSL_ENABLED_CIPHERS = "javax.rmi.ssl.client.enabledCipherSuites";
  public static final String SSL_ENABLED_PROTOCOLS = "javax.rmi.ssl.client.enabledProtocols";

  public static final String SYSTEM_PROPERTY_PULSE_USESSL_LOCATOR = "pulse.useSSL.locator";
  public static final String SYSTEM_PROPERTY_PULSE_USESSL_MANAGER = "pulse.useSSL.manager";

  public static final String REQUEST_PARAM_REGION_FULL_PATH = "regionFullPath";

}


text:
#ifndef XORHELPER_H
#define XORHELPER_H

#include "config.h"

/**
 *    Helper class for xor encrypted buffers.
 *    Handles that the buffer is encrypted first at a certain offset.
 */
class XorHelper {
public:

   /**
    *    Constructor.
    *    @param   xorBuf      The xor buffer.
    *    @param   xorLength   The length of the xor buffer.
    *    @param   xorOffset   The start offset of the xor buffer.
    *                         I.e. a file encrypted with this xor buffer
    *                         will first be xor:ed beginning at this offset.
    */
   XorHelper( const byte* xorBuf,
              uint32 xorLength,
              uint32 xorOffset ) : m_xorBuf( xorBuf ),
                                   m_xorLength( xorLength ),
                                   m_xorOffset( xorOffset ) {}

   /**
    *   Perfrom the xor:ing of the supplied buffer.
    *   @param buf   The buffer to xor.
    *   @param pos   The position of the start of the buffer.
    *   @param len   The length of the buffer.
    */
   void xorBuffer( byte* buf, uint32 pos, uint32 len ) const
   {
      if ( m_xorBuf == NULL || m_xorLength == 0 ) {
         return;
      }
      if ( pos + len < m_xorOffset ) {
         return;
      }
      if ( pos < m_xorOffset ) {
         pos = m_xorOffset;
         buf += m_xorOffset - pos;
         len -= m_xorOffset - pos;
      }

      for ( uint32 i = 0; i < len; ++i ) {
         buf[ i ] ^= m_xorBuf[ (pos + i) % m_xorLength ];
         ++pos;
      }
   }

private:

   /// The xor buffer.
   const byte* m_xorBuf;

   /// The length of the xor buffer.
   uint32 m_xorLength;

   /**
    *    The start offset of the xor buffer.
    *    I.e. a file encrypted with this xor buffer
    *    will first be xor:ed beginning at this offset.
    */
   uint32 m_xorOffset;

};

#endif


text:
@implementation UIColor (PRColorUtils)

- (UIImage *)pr_image
{
    CGRect rect = CGRectMake(0, 0, 1.f, 1.f);
    UIGraphicsBeginImageContext(rect.size);
    CGContextRef context = UIGraphicsGetCurrentContext();
    CGContextSetFillColorWithColor(context, self.CGColor);
    CGContextFillRect(context, rect);
    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return image;
}

+ (UIColor *)colorWithHex:(unsigned int)hex length:(NSUInteger)length
{
    if (length == 3) {
        return [UIColor colorWithRed:(hex >> 8 & 0xF) / 15.f
                               green:(hex >> 4 & 0xF) / 15.f
                                blue:(hex & 0xF) / 15.f
                               alpha:1.f];
    } else if (length == 6) {
        return [UIColor colorWithRed:(hex >> 16 & 0xFF) / 255.f
                               green:(hex >> 8 & 0xFF) / 255.f
                                blue:(hex & 0xFF) / 255.f
                               alpha:1.f];
    } else if (length == 8) {
        return [UIColor colorWithRed:(hex >> 24 & 0xFF) / 255.f
                               green:(hex >> 16 & 0xFF) / 255.f
                                blue:(hex >> 8 & 0xFF) / 255.f
                               alpha:(hex & 0xFF) / 255.f];
    } else {
        return nil;
    }
}

+ (UIColor *)colorWithHexString:(NSString *)hexString
{
    if ([hexString hasPrefix:@"#"]) {
        hexString = [hexString substringFromIndex:1];
    }
    NSScanner *scanner = [NSScanner scannerWithString:hexString];
    unsigned int hex;
    return [scanner scanHexInt:&hex] ? [self colorWithHex:hex length:hexString.length] : nil;
}

@end


text:
class SpreadsheetCell
{
public:
	SpreadsheetCell();
	SpreadsheetCell(double initialValue);
	explicit SpreadsheetCell(const std::string& initialValue);
	SpreadsheetCell(const SpreadsheetCell& src);

	SpreadsheetCell& operator=(const SpreadsheetCell& rhs);

	void set(double inValue);
	void set(const std::string& inString);

	double getValue() const { mNumAccesses++; return mValue; }
	const std::string& getString() const { mNumAccesses++; return mString; }

	static std::string doubleToString(double inValue);
	static double stringToDouble(const std::string& inString);

	friend SpreadsheetCell operator+(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);
	friend SpreadsheetCell operator-(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);
	friend SpreadsheetCell operator*(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);
	friend SpreadsheetCell operator/(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);
	SpreadsheetCell& operator+=(const SpreadsheetCell& rhs);
	SpreadsheetCell& operator-=(const SpreadsheetCell& rhs);
	SpreadsheetCell& operator*=(const SpreadsheetCell& rhs);
	SpreadsheetCell& operator/=(const SpreadsheetCell& rhs);
	friend bool operator==(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);
	friend bool operator<(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);
	friend bool operator>(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);
	friend bool operator!=(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);
	friend bool operator<=(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);
	friend bool operator>=(const SpreadsheetCell& lhs, const SpreadsheetCell& rhs);

private:
	double mValue;
	std::string mString;

	mutable int mNumAccesses = 0;
};


text:
package uk.co.exemel.disco.transport.api;

import uk.co.exemel.disco.core.api.exception.DiscoException;

/**
 * Interface for classes which want to be able to validate (and potentially reject) commands prior to execution of them.
 */
public interface CommandValidator<T extends TransportCommand> {

    /**
     * Called when validation required. Methods should throw an appropriate exception to prevent execution
     */
    void validate(T command) throws DiscoException;
}


text:
package com.hazelcast.internal.management.events;

import com.hazelcast.internal.json.JsonObject;

import java.util.Map;

import static java.util.Arrays.stream;
import static java.util.stream.Collectors.toMap;

public final class EventMetadata {
    private final EventType type;
    private final long timestamp;

    public EventMetadata(EventType type, long timestamp) {
        this.type = type;
        this.timestamp = timestamp;
    }

    // WARNING: Used by Management Center. Do not rename any enum, change its code
    // or remove an existing enum, only add new ones.
    public enum EventType {
        WAN_CONSISTENCY_CHECK_STARTED(1),
        WAN_CONSISTENCY_CHECK_FINISHED(2),
        WAN_SYNC_STARTED(3),
        WAN_SYNC_FINISHED_FULL(4),
        WAN_CONSISTENCY_CHECK_IGNORED(5),
        WAN_SYNC_PROGRESS_UPDATE(6),
        WAN_SYNC_FINISHED_MERKLE(7),
        WAN_CONFIGURATION_ADDED(8),
        ADD_WAN_CONFIGURATION_IGNORED(9),
        WAN_SYNC_IGNORED(10),
        WAN_CONFIGURATION_EXTENDED(11);

        private static final Map<Integer, EventType> CODE_MAPPING = stream(EventType.values())
                .collect(toMap(EventType::getCode, eventType -> eventType));

        private final int code;

        EventType(int code) {
            this.code = code;
        }

        public int getCode() {
            return code;
        }

        @SuppressWarnings("unused")
        // used by Management Center
        public static EventType withCode(int code) {
            EventType type = CODE_MAPPING.get(code);
            if (type == null) {
                throw new IllegalArgumentException("No EventType with code " + code);
            }
            return type;
        }

        @Override
        public String toString() {
            return "EventType{"
                    + "name=" + name()
                    + ", code=" + code
                    + '}';
        }
    }

    public JsonObject toJson() {
        JsonObject json = new JsonObject();
        json.add("type", type.code);
        json.add("timestamp", timestamp);
        return json;
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <packaging>bundle</packaging>
  <parent>
    <groupId>org.jitsi.desktop</groupId>
    <artifactId>impl-parent</artifactId>
    <version>${revision}</version>
  </parent>
  <artifactId>jitsi-protocol-jabber</artifactId>
  <version>${revision}</version>
  <description>Jabber Protocol Provider Implementation</description>
  <dependencies>
    <dependency>
      <groupId>org.osgi</groupId>
      <artifactId>osgi.core</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-text</artifactId>
    </dependency>
    <dependency>
      <groupId>org.jitsi</groupId>
      <artifactId>libjitsi</artifactId>
    </dependency>
    <dependency>
      <groupId>org.jitsi</groupId>
      <artifactId>jitsi-xmpp-extensions</artifactId>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>jitsi-util</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>jitsi-osgi-util</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-argdelegation</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-certificate</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-credentialsstorage</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-customavatar</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-dnsservice</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-globaldisplaydetails</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-ui-service</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-hid</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-netaddr</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-protocol</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-protocol-media</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-resourcemanager</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>jitsi-wrap</artifactId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-core</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.servicemix.bundles</groupId>
      <artifactId>org.apache.servicemix.bundles.xpp3</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-java8</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-im</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-bosh</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.jbosh</groupId>
      <artifactId>jbosh</artifactId>
    </dependency>
    <dependency>
      <groupId>org.minidns</groupId>
      <artifactId>minidns-core</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-tcp</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-debug</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-extensions</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-experimental</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-legacy</artifactId>
    </dependency>
    <dependency>
      <groupId>org.igniterealtime.smack</groupId>
      <artifactId>smack-xmlparser-stax</artifactId>
    </dependency>
    <dependency>
      <groupId>org.jitsi</groupId>
      <artifactId>jnsapi</artifactId>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>service-protocol</artifactId>
      <version>${project.version}</version>
      <type>test-jar</type>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <configuration>
          <instructions>
            <Bundle-Activator>net.java.sip.communicator.impl.protocol.jabber.JabberActivator</Bundle-Activator>
          </instructions>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>