#include "Type.hpp"

void Type::repr(instance_ptr self, ReprAccumulator& out) {

assertForwardsResolved();

this->check([&](auto& subtype) {

subtype.repr(self, out);

});

}

char Type::cmp(instance_ptr left, instance_ptr right) {

assertForwardsResolved();

return this->check([&](auto& subtype) {

return subtype.cmp(left, right);

});

}

int32_t Type::hash32(instance_ptr left) {

assertForwardsResolved();

return this->check([&](auto& subtype) {

return subtype.hash32(left);

});

}

void Type::swap(instance_ptr left, instance_ptr right) {

assertForwardsResolved();

if (left == right) {

return;

}

size_t remaining = m_size;

while (remaining >= 8) {

int64_t temp = *(int64_t*)left;

*(int64_t*)left = *(int64_t*)right;

*(int64_t*)right = temp;

remaining -= 8;

left += 8;

right += 8;

}

while (remaining > 0) {

int8_t temp = *(int8_t*)left;

*(int8_t*)left = *(int8_t*)right;

*(int8_t*)right = temp;

remaining -= 1;

left += 1;

right += 1;

}

}

// static

char Type::byteCompare(uint8_t* l, uint8_t* r, size_t count) {

while (count >= 8 && *(uint64_t*)l == *(uint64_t*)r) {

l += 8;

r += 8;

count -= 8;

}

for (long k = 0; k < count; k++) {

if (l[k] < r[k]) {

return -1;

}

if (l[k] > r[k]) {

return 1;

}

}

return 0;

}

void Type::constructor(instance_ptr self) {

assertForwardsResolved();

this->check([&](auto& subtype) { subtype.constructor(self); } );

}

void Type::destroy(instance_ptr self) {

assertForwardsResolved();

this->check([&](auto& subtype) { subtype.destroy(self); } );

}

void Type::forwardTypesMayHaveChanged() {

m_references_unresolved_forwards = false;

visitReferencedTypes([&](Type* t) {

if (t->references_unresolved_forwards()) {

m_references_unresolved_forwards = true;

}

});

this->check([&](auto& subtype) {

subtype._forwardTypesMayHaveChanged();

});

if (mTypeRep) {

updateTypeRepForType(this, mTypeRep);

}

}

void Type::copy_constructor(instance_ptr self, instance_ptr other) {

assertForwardsResolved();

this->check([&](auto& subtype) { subtype.copy_constructor(self, other); } );

}

void Type::assign(instance_ptr self, instance_ptr other) {

assertForwardsResolved();

this->check([&](auto& subtype) { subtype.assign(self, other); } );

}

bool Type::isBinaryCompatibleWith(Type* other) {

if (other == this) {

return true;

}

while (other->getTypeCategory() == TypeCategory::catPythonSubclass) {

other = other->getBaseType();

}

auto it = mIsBinaryCompatible.find(other);

if (it != mIsBinaryCompatible.end()) {

return it->second != BinaryCompatibilityCategory::Incompatible;

}

//mark that we are recursing through this datastructure. we don't want to

//loop indefinitely.

mIsBinaryCompatible[other] = BinaryCompatibilityCategory::Checking;

bool isCompatible = this->check([&](auto& subtype) {

return subtype.isBinaryCompatibleWithConcrete(other);

});

mIsBinaryCompatible[other] = isCompatible ?

BinaryCompatibilityCategory::Compatible :

BinaryCompatibilityCategory::Incompatible

;

return isCompatible;

}

bool OneOf::isBinaryCompatibleWithConcrete(Type* other) {

if (other->getTypeCategory() != TypeCategory::catOneOf) {

return false;

}

OneOf* otherO = (OneOf*)other;

if (m_types.size() != otherO->m_types.size()) {

return false;

}

for (long k = 0; k < m_types.size(); k++) {

if (!m_types[k]->isBinaryCompatibleWith(otherO->m_types[k])) {

return false;

}

}

return true;

}

void OneOf::_forwardTypesMayHaveChanged() {

m_size = computeBytecount();

m_name = computeName();

m_is_default_constructible = false;

for (auto typePtr: m_types) {

if (typePtr->is_default_constructible()) {

m_is_default_constructible = true;

break;

}

}

}

std::string OneOf::computeName() const {

std::string res = "OneOf(";

bool first = true;

for (auto t: m_types) {

if (first) {

first = false;

} else {

res += ", ";

}

res += t->name();

}

res += ")";

return res;

}

void OneOf::repr(instance_ptr self, ReprAccumulator& stream) {

m_types[*((uint8_t*)self)]->repr(self+1, stream);

}

int32_t OneOf::hash32(instance_ptr left) {

Hash32Accumulator acc((int)getTypeCategory());

acc.add(*(uint8_t*)left);

acc.add(m_types[*((uint8_t*)left)]->hash32(left+1));

return acc.get();

}

char OneOf::cmp(instance_ptr left, instance_ptr right) {

if (((uint8_t*)left)[0] < ((uint8_t*)right)[0]) {

return -1;

}

if (((uint8_t*)left)[0] > ((uint8_t*)right)[0]) {

return 1;

}

return m_types[*((uint8_t*)left)]->cmp(left+1,right+1);

}

size_t OneOf::computeBytecount() const {

size_t res = 0;

for (auto t: m_types)

res = std::max(res, t->bytecount());

return res + 1;

}

void OneOf::constructor(instance_ptr self) {

if (!m_is_default_constructible) {

throw std::runtime_error(m_name + " is not default-constructible");

}

for (size_t k = 0; k < m_types.size(); k++) {

if (m_types[k]->is_default_constructible()) {

*(uint8_t*)self = k;

m_types[k]->constructor(self+1);

return;

}

}

}

void OneOf::destroy(instance_ptr self) {

uint8_t which = *(uint8_t*)(self);

m_types[which]->destroy(self+1);

}

void OneOf::copy_constructor(instance_ptr self, instance_ptr other) {

uint8_t which = *(uint8_t*)self = *(uint8_t*)other;

m_types[which]->copy_constructor(self+1, other+1);

}

void OneOf::assign(instance_ptr self, instance_ptr other) {

uint8_t which = *(uint8_t*)self;

if (which == *(uint8_t*)other) {

m_types[which]->assign(self+1,other+1);

} else {

m_types[which]->destroy(self+1);

uint8_t otherWhich = *(uint8_t*)other;

*(uint8_t*)self = otherWhich;

m_types[otherWhich]->copy_constructor(self+1,other+1);

}

}

// static

OneOf* OneOf::Make(const std::vector<Type*>& types) {

std::vector<Type*> flat_typelist;

std::set<Type*> seen;

//make sure we only get each type once and don't have any other 'OneOf' in there...

std::function<void (const std::vector<Type*>)> visit = [&](const std::vector<Type*>& subvec) {

for (auto t: subvec) {

if (t->getTypeCategory() == catOneOf) {

visit( ((OneOf*)t)->getTypes() );

} else if (seen.find(t) == seen.end()) {

flat_typelist.push_back(t);

seen.insert(t);

}

}

};

visit(types);

static std::mutex guard;

std::lock_guard<std::mutex> lock(guard);

typedef const std::vector<Type*> keytype;

static std::map<keytype, OneOf*> m;

auto it = m.find(flat_typelist);

if (it == m.end()) {

it = m.insert(std::make_pair(flat_typelist, new OneOf(flat_typelist))).first;

}

return it->second;

}

bool CompositeType::isBinaryCompatibleWithConcrete(Type* other) {

if (other->getTypeCategory() != m_typeCategory) {

return false;

}

CompositeType* otherO = (CompositeType*)other;

if (m_types.size() != otherO->m_types.size()) {

return false;

}

for (long k = 0; k < m_types.size(); k++) {

if (!m_types[k]->isBinaryCompatibleWith(otherO->m_types[k])) {

return false;

}

}

return true;

}

void CompositeType::_forwardTypesMayHaveChanged() {

m_is_default_constructible = true;

m_size = 0;

m_byte_offsets.clear();

for (auto t: m_types) {

m_byte_offsets.push_back(m_size);

m_size += t->bytecount();

}

for (auto t: m_types) {

if (!t->is_default_constructible()) {

m_is_default_constructible = false;

}

}

}

char CompositeType::cmp(instance_ptr left, instance_ptr right) {

for (long k = 0; k < m_types.size(); k++) {

char res = m_types[k]->cmp(left + m_byte_offsets[k], right + m_byte_offsets[k]);

if (res != 0) {

return res;

}

}

return 0;

}

void CompositeType::repr(instance_ptr self, ReprAccumulator& stream) {

stream << "(";

for (long k = 0; k < getTypes().size();k++) {

if (k > 0) {

stream << ", ";

}

if (k < m_names.size()) {

stream << m_names[k] << "=";

}

getTypes()[k]->repr(eltPtr(self,k),stream);

}

if (getTypes().size() == 1) {

stream << ",";

}

stream << ")";

}

int32_t CompositeType::hash32(instance_ptr left) {

Hash32Accumulator acc((int)getTypeCategory());

for (long k = 0; k < getTypes().size();k++) {

acc.add(getTypes()[k]->hash32(eltPtr(left,k)));

}

acc.add(getTypes().size());

return acc.get();

}

void CompositeType::constructor(instance_ptr self) {

if (!m_is_default_constructible) {

throw std::runtime_error(m_name + " is not default-constructible");

}

for (size_t k = 0; k < m_types.size(); k++) {

m_types[k]->constructor(self+m_byte_offsets[k]);

}

}

void CompositeType::destroy(instance_ptr self) {

for (long k = (long)m_types.size() - 1; k >= 0; k--) {

m_types[k]->destroy(self+m_byte_offsets[k]);

}

}

void CompositeType::copy_constructor(instance_ptr self, instance_ptr other) {

for (long k = (long)m_types.size() - 1; k >= 0; k--) {

m_types[k]->copy_constructor(self + m_byte_offsets[k], other+m_byte_offsets[k]);

}

}

void CompositeType::assign(instance_ptr self, instance_ptr other) {

for (long k = (long)m_types.size() - 1; k >= 0; k--) {

m_types[k]->assign(self + m_byte_offsets[k], other+m_byte_offsets[k]);

}

}

void NamedTuple::_forwardTypesMayHaveChanged() {

((CompositeType*)this)->_forwardTypesMayHaveChanged();

std::string oldName = m_name;

m_name = "NamedTuple(";

for (long k = 0; k < m_types.size();k++) {

if (k) {

m_name += ", ";

}

m_name += m_names[k] + "=" + m_types[k]->name();

}

m_name += ")";

}

void Tuple::_forwardTypesMayHaveChanged() {

((CompositeType*)this)->_forwardTypesMayHaveChanged();

m_name = "Tuple(";

for (long k = 0; k < m_types.size();k++) {

if (k) {

m_name += ", ";

}

m_name += m_types[k]->name();

}

m_name += ")";

}

bool TupleOrListOf::isBinaryCompatibleWithConcrete(Type* other) {

if (other->getTypeCategory() != m_typeCategory) {

return false;

}

TupleOf* otherO = (TupleOf*)other;

return m_element_type->isBinaryCompatibleWith(otherO->m_element_type);

}

void TupleOrListOf::repr(instance_ptr self, ReprAccumulator& stream) {

PushReprState isNew(stream, self);

if (!isNew) {

if (m_is_tuple) {

stream << m_name << "(" << (void*)self << ")";

} else {

stream << m_name << "[" << (void*)self << "]";

}

return;

}

stream << (m_is_tuple ? "(" : "[");

int32_t ct = count(self);

for (long k = 0; k < ct;k++) {

if (k > 0) {

stream << ", ";

}

m_element_type->repr(eltPtr(self,k),stream);

}

stream << (m_is_tuple ? ")" : "]");

}

int32_t TupleOrListOf::hash32(instance_ptr left) {

if (!(*(layout**)left)) {

return 0x123;

}

if ((*(layout**)left)->hash_cache == -1) {

Hash32Accumulator acc((int)getTypeCategory());

int32_t ct = count(left);

acc.add(ct);

for (long k = 0; k < ct;k++) {

acc.add(m_element_type->hash32(eltPtr(left, k)));

}

(*(layout**)left)->hash_cache = acc.get();

if ((*(layout**)left)->hash_cache == -1) {

(*(layout**)left)->hash_cache = -2;

}

}

return (*(layout**)left)->hash_cache;

}

char TupleOrListOf::cmp(instance_ptr left, instance_ptr right) {

if (!(*(layout**)left) && (*(layout**)right)) {

return -1;

}

if (!(*(layout**)right) && (*(layout**)left)) {

return 1;

}

if (!(*(layout**)right) && !(*(layout**)left)) {

return 0;

}

layout& left_layout = **(layout**)left;

layout& right_layout = **(layout**)right;

if (&left_layout == &right_layout) {

return 0;

}

size_t bytesPer = m_element_type->bytecount();

for (long k = 0; k < left_layout.count && k < right_layout.count; k++) {

char res = m_element_type->cmp(left_layout.data + bytesPer * k,

right_layout.data + bytesPer * k);

if (res != 0) {

return res;

}

}

if (left_layout.count < right_layout.count) {

return -1;

}

if (left_layout.count > right_layout.count) {

return 1;

}

return 0;

}

// static

TupleOf* TupleOf::Make(Type* elt) {

static std::mutex guard;

std::lock_guard<std::mutex> lock(guard);

static std::map<Type*, TupleOf*> m;

auto it = m.find(elt);

if (it == m.end()) {

it = m.insert(std::make_pair(elt, new TupleOf(elt))).first;

}

return it->second;

}

// static

ListOf* ListOf::Make(Type* elt) {

static std::mutex guard;

std::lock_guard<std::mutex> lock(guard);

static std::map<Type*, ListOf*> m;

auto it = m.find(elt);

if (it == m.end()) {

it = m.insert(std::make_pair(elt, new ListOf(elt))).first;

}

return it->second;

}

int64_t TupleOrListOf::count(instance_ptr self) const {

if (!(*(layout**)self)) {

return 0;

}

return (*(layout**)self)->count;

}

int64_t TupleOrListOf::refcount(instance_ptr self) const {

if (!(*(layout**)self)) {

return 0;

}

return (*(layout**)self)->refcount;

}

void TupleOrListOf::constructor(instance_ptr self) {

constructor(self, 0, [](instance_ptr i, int64_t k) {});

}

void TupleOrListOf::destroy(instance_ptr selfPtr) {

layout_ptr& self = *(layout_ptr*)selfPtr;

if (!self) {

return;

}

self->refcount--;

if (self->refcount == 0) {

m_element_type->destroy(self->count, [&](int64_t k) {return eltPtr(self,k);});

free(self->data);

free(self);

}

}

void TupleOrListOf::copy_constructor(instance_ptr self, instance_ptr other) {

(*(layout**)self) = (*(layout**)other);

if (*(layout**)self) {

(*(layout**)self)->refcount++;

}

}

void TupleOrListOf::assign(instance_ptr self, instance_ptr other) {

layout* old = (*(layout**)self);

(*(layout**)self) = (*(layout**)other);

if (*(layout**)self) {

(*(layout**)self)->refcount++;

}

destroy((instance_ptr)&old);

}

void ListOf::append(instance_ptr self, instance_ptr other) {

layout_ptr& self_layout = *(layout_ptr*)self;

if (!self_layout) {

self_layout = (layout_ptr)malloc(sizeof(layout) + getEltType()->bytecount() * 1);

self_layout->count = 1;

self_layout->refcount = 1;

self_layout->reserved = 1;

self_layout->hash_cache = -1;

getEltType()->copy_constructor(eltPtr(self, 0), other);

} else {

if (self_layout->count == self_layout->reserved) {

int64_t new_reserved = self_layout->reserved * 1.25 + 1;

self_layout->data = (uint8_t*)realloc(self_layout->data, getEltType()->bytecount() * new_reserved);

self_layout->reserved = new_reserved;

}

getEltType()->copy_constructor(eltPtr(self, self_layout->count), other);

self_layout->count++;

}

}

size_t ListOf::reserved(instance_ptr self) {

layout_ptr& self_layout = *(layout_ptr*)self;

return self_layout->reserved;

}

void ListOf::reserve(instance_ptr self, size_t target) {

layout_ptr& self_layout = *(layout_ptr*)self;

if (target < self_layout->count) {

target = self_layout->count;

}

self_layout->data = (uint8_t*)realloc(self_layout->data, getEltType()->bytecount() * target);

self_layout->reserved = target;

}

void ListOf::remove(instance_ptr self, size_t index) {

layout_ptr& self_layout = *(layout_ptr*)self;

getEltType()->destroy(eltPtr(self, index));

memmove(eltPtr(self, index), eltPtr(self, index+1), (self_layout->count - index - 1) * getEltType()->bytecount());

self_layout->count--;

}

void ListOf::resize(instance_ptr self, size_t count) {

layout_ptr& self_layout = *(layout_ptr*)self;

if (count > self_layout->reserved) {

reserve(self, count);

}

if (count < self_layout->count) {

getEltType()->destroy(self_layout->count - count, [&](int64_t k) {return eltPtr(self,k + count);});

self_layout->count = count;

}

else if (count > self_layout->count) {

getEltType()->constructor(count - self_layout->count, [&](int64_t k) {return eltPtr(self,k + self_layout->count);});

self_layout->count = count;

}

}

void ListOf::resize(instance_ptr self, size_t count, instance_ptr value) {

layout_ptr& self_layout = *(layout_ptr*)self;

if (count > self_layout->reserved) {

reserve(self, count);

}

if (count < self_layout->count) {

getEltType()->destroy(self_layout->count - count, [&](int64_t k) {return eltPtr(self,k + count);});

self_layout->count = count;

}

else if (count > self_layout->count) {

getEltType()->copy_constructor(

count - self_layout->count,

[&](int64_t k) {return eltPtr(self,k + self_layout->count);},

[&](int64_t k) {return value;}

);

self_layout->count = count;

}

}

void ConstDict::_forwardTypesMayHaveChanged() {

m_name = "ConstDict(" + m_key->name() + "->" + m_value->name() + ")";

m_size = sizeof(void*);

m_is_default_constructible = true;

m_bytes_per_key = m_key->bytecount();

m_bytes_per_key_value_pair = m_key->bytecount() + m_value->bytecount();

m_bytes_per_key_subtree_pair = m_key->bytecount() + this->bytecount();

m_key_value_pair_type = Tuple::Make({m_key, m_value});

}

bool ConstDict::isBinaryCompatibleWithConcrete(Type* other) {

if (other->getTypeCategory() != m_typeCategory) {

return false;

}

ConstDict* otherO = (ConstDict*)other;

return m_key->isBinaryCompatibleWith(otherO->m_key) &&

m_value->isBinaryCompatibleWith(otherO->m_value);

}

// static

ConstDict* ConstDict::Make(Type* key, Type* value) {

static std::mutex guard;

std::lock_guard<std::mutex> lock(guard);

static std::map<std::pair<Type*, Type*>, ConstDict*> m;

auto lookup_key = std::make_pair(key,value);

auto it = m.find(lookup_key);

if (it == m.end()) {

it = m.insert(std::make_pair(lookup_key, new ConstDict(key, value))).first;

}

return it->second;

}

void ConstDict::repr(instance_ptr self, ReprAccumulator& stream) {

PushReprState isNew(stream, self);

if (!isNew) {

stream << m_name << "(" << (void*)self << ")";

return;

}

stream << "{";

int32_t ct = count(self);

for (long k = 0; k < ct;k++) {

if (k > 0) {

stream << ", ";

}

m_key->repr(kvPairPtrKey(self,k),stream);

stream << ": ";

m_value->repr(kvPairPtrValue(self,k),stream);

}

stream << "}";

}

int32_t ConstDict::hash32(instance_ptr left) {

if (size(left) == 0) {

return 0x123456;

}

if ((*(layout**)left)->hash_cache == -1) {

Hash32Accumulator acc((int)getTypeCategory());

int32_t count = size(left);

acc.add(count);

for (long k = 0; k < count;k++) {

acc.add(m_key->hash32(kvPairPtrKey(left,k)));

acc.add(m_value->hash32(kvPairPtrValue(left,k)));

}

(*(layout**)left)->hash_cache = acc.get();

if ((*(layout**)left)->hash_cache == -1) {

(*(layout**)left)->hash_cache = -2;

}

}

return (*(layout**)left)->hash_cache;

}

//to make this fast(er), we do dict size comparison first, then keys, then values

char ConstDict::cmp(instance_ptr left, instance_ptr right) {

if (size(left) < size(right)) {

return -1;

}

if (size(left) > size(right)) {

return 1;

}

if (*(layout**)left == *(layout**)right) {

return 0;

}

int ct = count(left);

for (long k = 0; k < ct; k++) {

char res = m_key->cmp(kvPairPtrKey(left,k), kvPairPtrKey(right,k));

if (res) {

return res;

}

}

for (long k = 0; k < ct; k++) {

char res = m_value->cmp(

kvPairPtrValue(left,k),

kvPairPtrValue(right,k)

);

if (res) {

return res;

}

}

return 0;

}

void ConstDict::addDicts(instance_ptr lhs, instance_ptr rhs, instance_ptr output) const {

std::vector<instance_ptr> keep;

int64_t lhsCount = count(lhs);

int64_t rhsCount = count(rhs);

for (long k = 0; k < lhsCount; k++) {

instance_ptr lhsVal = kvPairPtrKey(lhs, k);

if (!lookupValueByKey(rhs, lhsVal)) {

keep.push_back(lhsVal);

}

}

constructor(output, rhsCount + keep.size(), false);

for (long k = 0; k < rhsCount; k++) {

m_key->copy_constructor(kvPairPtrKey(output,k), kvPairPtrKey(rhs, k));

m_value->copy_constructor(kvPairPtrValue(output,k), kvPairPtrValue(rhs, k));

}

for (long k = 0; k < keep.size(); k++) {

m_key->copy_constructor(kvPairPtrKey(output,k + rhsCount), keep[k]);

m_value->copy_constructor(kvPairPtrValue(output,k + rhsCount), keep[k] + m_bytes_per_key);

}

incKvPairCount(output, keep.size() + rhsCount);

sortKvPairs(output);

}

void ConstDict::subtractTupleOfKeysFromDict(instance_ptr lhs, instance_ptr rhs, instance_ptr output) const {

TupleOf* tupleType = tupleOfKeysType();

int64_t lhsCount = count(lhs);

int64_t rhsCount = tupleType->count(rhs);

std::set<int> remove;

for (long k = 0; k < rhsCount; k++) {

int64_t index = lookupIndexByKey(lhs, tupleType->eltPtr(rhs, k));

if (index != -1) {

remove.insert(index);

}

}

constructor(output, lhsCount - remove.size(), false);

long written = 0;

for (long k = 0; k < lhsCount; k++) {

if (remove.find(k) == remove.end()) {

m_key->copy_constructor(kvPairPtrKey(output,written), kvPairPtrKey(lhs, k));

m_value->copy_constructor(kvPairPtrValue(output,written), kvPairPtrValue(lhs, k));

written++;

}

}

incKvPairCount(output, written);

}

instance_ptr ConstDict::kvPairPtrKey(instance_ptr self, int64_t i) const {

if (!(*(layout**)self)) {

return self;

}

layout& record = **(layout**)self;

return record.data + m_bytes_per_key_value_pair * i;

}

instance_ptr ConstDict::kvPairPtrValue(instance_ptr self, int64_t i) const {

if (!(*(layout**)self)) {

return self;

}

layout& record = **(layout**)self;

return record.data + m_bytes_per_key_value_pair * i + m_bytes_per_key;

}

void ConstDict::incKvPairCount(instance_ptr self, int by) const {

if (by == 0) {

return;

}

layout& record = **(layout**)self;

record.count += by;

}

void ConstDict::sortKvPairs(instance_ptr self) const {

if (!*(layout**)self) {

return;

}

layout& record = **(layout**)self;

assert(!record.subpointers);

if (record.count <= 1) {

return;

}

else if (record.count == 2) {

if (m_key->cmp(kvPairPtrKey(self, 0), kvPairPtrKey(self,1)) > 0) {

m_key->swap(kvPairPtrKey(self,0), kvPairPtrKey(self,1));

m_value->swap(kvPairPtrValue(self,0), kvPairPtrValue(self,1));

}

return;

} else {

std::vector<int> indices;

for (long k=0;k<record.count;k++) {

indices.push_back(k);

}

std::sort(indices.begin(), indices.end(), [&](int l, int r) {

char res = m_key->cmp(kvPairPtrKey(self,l),kvPairPtrKey(self,r));

return res < 0;

});

//create a temporary buffer

std::vector<uint8_t> d;

d.resize(m_bytes_per_key_value_pair * record.count);

//final_lookup contains the location of each value in the original sort

for (long k = 0; k < indices.size(); k++) {

m_key->swap(kvPairPtrKey(self, indices[k]), &d[m_bytes_per_key_value_pair*k]);

m_value->swap(kvPairPtrValue(self, indices[k]), &d[m_bytes_per_key_value_pair*k+m_bytes_per_key]);

}

//now move them back

for (long k = 0; k < indices.size(); k++) {

m_key->swap(kvPairPtrKey(self, k), &d[m_bytes_per_key_value_pair*k]);

m_value->swap(kvPairPtrValue(self, k), &d[m_bytes_per_key_value_pair*k+m_bytes_per_key]);

}

}

}

instance_ptr ConstDict::keyTreePtr(instance_ptr self, int64_t i) const {

if (!(*(layout**)self)) {

return self;

}

layout& record = **(layout**)self;

return record.data + m_bytes_per_key_subtree_pair * i;

}

bool ConstDict::instanceIsSubtrees(instance_ptr self) const {

if (!(*(layout**)self)) {

return self;

}

layout& record = **(layout**)self;

return record.subpointers != 0;

}

int64_t ConstDict::refcount(instance_ptr self) const {

if (!(*(layout**)self)) {

return 0;

}

layout& record = **(layout**)self;

return record.refcount;