lbug 0.16.0

An in-process property graph database management system built for query speed and scalability
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
 * Use of this file is governed by the BSD 3-clause license that
 * can be found in the LICENSE.txt file in the project root.
 */

#include "atn/ArrayPredictionContext.h"

#include <cstring>

#include "atn/SingletonPredictionContext.h"
#include "atn/HashUtils.h"
#include "misc/MurmurHash.h"
#include "support/Casts.h"

using namespace antlr4::atn;
using namespace antlr4::misc;
using namespace antlrcpp;

namespace {

  bool predictionContextEqual(const Ref<const PredictionContext> &lhs, const Ref<const PredictionContext> &rhs) {
    // parent PredictionContext pointers can be null during full context mode and
    // the ctxs are in an ArrayPredictionContext.  If both are null, return true
    // if just one is null, return false. If both are non-null, do comparison.
    if ( lhs == nullptr ) return rhs == nullptr;
    if ( rhs == nullptr ) return false; // lhs!=null and rhs==null
    return *lhs == *rhs;                // both nonnull
  }

}

ArrayPredictionContext::ArrayPredictionContext(const SingletonPredictionContext &predictionContext)
    : ArrayPredictionContext({ predictionContext.parent }, { predictionContext.returnState }) {}

ArrayPredictionContext::ArrayPredictionContext(std::vector<Ref<const PredictionContext>> parents,
                                               std::vector<size_t> returnStates)
    : PredictionContext(PredictionContextType::ARRAY), parents(std::move(parents)), returnStates(std::move(returnStates)) {
  assert(this->parents.size() > 0);
  assert(this->returnStates.size() > 0);
  assert(this->parents.size() == this->returnStates.size());
}

bool ArrayPredictionContext::isEmpty() const {
  // Since EMPTY_RETURN_STATE can only appear in the last position, we don't need to verify that size == 1.
  return returnStates[0] == EMPTY_RETURN_STATE;
}

size_t ArrayPredictionContext::size() const {
  return returnStates.size();
}

const Ref<const PredictionContext>& ArrayPredictionContext::getParent(size_t index) const {
  return parents[index];
}

size_t ArrayPredictionContext::getReturnState(size_t index) const {
  return returnStates[index];
}

size_t ArrayPredictionContext::hashCodeImpl() const {
  size_t hash = MurmurHash::initialize();
  hash = MurmurHash::update(hash, static_cast<size_t>(getContextType()));
  for (const auto &parent : parents) {
    hash = MurmurHash::update(hash, parent);
  }
  for (const auto &returnState : returnStates) {
    hash = MurmurHash::update(hash, returnState);
  }
  return MurmurHash::finish(hash, 1 + parents.size() + returnStates.size());
}

bool ArrayPredictionContext::equals(const PredictionContext &other) const {
  if (this == std::addressof(other)) {
    return true;
  }
  if (getContextType() != other.getContextType()) {
    return false;
  }
  const auto &array = downCast<const ArrayPredictionContext&>(other);
  const bool sameSize = returnStates.size() == array.returnStates.size() &&
                        parents.size() == array.parents.size();
  if ( !sameSize ) {
      return false;
  }

  const bool sameHash = cachedHashCodeEqual(cachedHashCode(), array.cachedHashCode());
  if ( !sameHash ) {
      return false;
  }

  const size_t stateSizeBytes = sizeof(decltype(returnStates)::value_type);
  const bool returnStateArraysEqual =
          std::memcmp(returnStates.data(), array.returnStates.data(),
                      returnStates.size() * stateSizeBytes) == 0;
  if ( !returnStateArraysEqual ) {
      return false;
  }

  // stack of contexts is the same
  const bool parentCtxEqual =
          std::equal(parents.begin(), parents.end(), array.parents.begin(), predictionContextEqual);
  return parentCtxEqual;
}

std::string ArrayPredictionContext::toString() const {
  if (isEmpty()) {
    return "[]";
  }

  std::stringstream ss;
  ss << "[";
  for (size_t i = 0; i < returnStates.size(); i++) {
    if (i > 0) {
      ss << ", ";
    }
    if (returnStates[i] == EMPTY_RETURN_STATE) {
      ss << "$";
      continue;
    }
    ss << returnStates[i];
    if (parents[i] != nullptr) {
      ss << " " << parents[i]->toString();
    } else {
      ss << "nul";
    }
  }
  ss << "]";
  return ss.str();
}