/**
* Create new hash with custom hash and equal functions.
*
* @param[in] memory_manager Memory manager to use.
* @param[in] slots Initial size of hash.
* @param[in] hash Function to use to hash keys.
* @param[in] equal Function to use to compare keys.
* @return Empty Hash.
**/
static
Hash create(
MemoryManager memory_manager,
size_t slots,
key_hash_t hash,
key_equal_t equal
)
{
std::pair<ib_hash_function_t, void*> hash_trampoline;
std::pair<ib_hash_equal_t, void*> equal_trampoline;
ib_hash_t* h;
hash_trampoline = make_c_trampoline<
uint32_t(const char*, size_t, uint32_t)
>(hash);
equal_trampoline = make_c_trampoline<
int(const char*, size_t, const char*, size_t)
>(equal);
memory_manager.register_cleanup(
boost::bind(delete_c_trampoline, hash_trampoline.second)
);
memory_manager.register_cleanup(
boost::bind(delete_c_trampoline, equal_trampoline.second)
);
throw_if_error(
ib_hash_create_ex(
&h, memory_manager.ib(), slots,
hash_trampoline.first, hash_trampoline.second,
equal_trampoline.first, equal_trampoline.second
)
);
return Hash(h);
}
/**
* Create new hash. Case insensitive.
*
* Creates a new case sensitive hash.
*
* @param[in] memory_manager Memory manager to use.
* @param[in] slots Initial size of hash.
* @return Empty Hash.
**/
static Hash create_nocase(MemoryManager memory_manager, size_t slots = 16)
{
ib_hash_t* h;
throw_if_error(
ib_hash_create_ex(
&h, memory_manager.ib(), slots,
&ib_hashfunc_djb2_nocase, NULL,
&ib_hashequal_nocase, NULL
)
);
return Hash(h);
}
Value eval_map(
MemoryManager mm,
const Functional::value_vec_t& secondary_args,
boost::any& map_state,
Value subvalue
) const
{
/* If the subvalue we've been given is NULL, likewise return a NULL
* subvalue. We can't change anything. */
if (! subvalue) {
return Value();
}
if (subvalue.type() != Value::STRING) {
return Value();
}
ConstByteString text = subvalue.as_string();
boost::shared_ptr<vector<char> > result(new vector<char>());
// Ensure that result.data() is non-null, even if we never insert
// anything.
result->reserve(1);
// value_to_data() ensures that a copy is associated with the memory
// pool and will be deleted when the memory pool goes away.
value_to_data(result, mm.ib());
boost::regex_replace(
back_inserter(*result),
text.const_data(), text.const_data() + text.length(),
m_expression,
m_replacement
);
return Value::create_string(
mm,
subvalue.name(), subvalue.name_length(),
ByteString::create_alias(
mm,
result->data(), result->size()
)
);
}
ActionInstance ActionInstance::create(
MemoryManager memory_manager,
Context context,
ConstAction action,
const char* parameters
)
{
ib_action_inst_t* actioninst;
throw_if_error(
ib_action_inst_create(
&actioninst,
memory_manager.ib(),
context.ib(),
action.ib(),
parameters
)
);
return ActionInstance(actioninst);
}
OperatorInstance OperatorInstance::create(
MemoryManager memory_manager,
Context context,
ConstOperator op,
ib_flags_t required_capabilities,
const char* parameters
)
{
ib_operator_inst_t* opinst;
throw_if_error(
ib_operator_inst_create(
&opinst,
memory_manager.ib(),
context.ib(),
op.ib(),
required_capabilities,
parameters
)
);
return OperatorInstance(opinst);
}
/**
* Create new list.
*
* Creates a new empty list using @a memory_manager for memory.
*
* @param[in] memory_manager Memory manager to use.
* @return Empty List.
**/
static List create(MemoryManager memory_manager)
{
ib_list_t* ib_list;
throw_if_error(ib_list_create(&ib_list, memory_manager.ib()));
return List(ib_list);
}
