Value::Value(int protocol_version,
const DataType::ConstPtr& data_type,
char* data, int32_t size)
: protocol_version_(protocol_version)
, data_type_(data_type) {
if (size > 0 && data_type->is_collection()) {
data_ = decode_size(protocol_version, data, count_);
if (protocol_version_ >= 3) {
size_ = size - sizeof(int32_t);
} else {
size_ = size - sizeof(uint16_t);
}
} else {
if (data_type->is_tuple()) {
SharedRefPtr<const CompositeType> composite_type(data_type);
count_ = composite_type->types().size();
} else if (data_type->is_user_type()) {
UserType::ConstPtr user_type(data_type);
count_ = user_type->fields().size();
} else {
count_ = 0;
}
data_ = data;
size_ = size;
}
}
UserTypeFieldIterator(const Value* user_type_value)
: Iterator(CASS_ITERATOR_TYPE_USER_TYPE_FIELD)
, user_type_value_(user_type_value)
, position_(user_type_value->data()) {
UserType::ConstPtr user_type(user_type_value->data_type());
next_ = user_type->fields().begin();
end_ = user_type->fields().end();
}
void
self::clear() {
_user = user_type(NULL);
_room = room_type();
_joining_room = room_type::id_type();
_room_version = false;
_room_version_all = false;
_room_version_12_only = false;
}
DataType::ConstPtr DataTypeCqlNameParser::parse(const std::string& type,
const NativeDataTypes& native_types,
KeyspaceMetadata* keyspace,
bool is_frozen) {
Parser parser(type, 0);
std::string type_name;
Parser::TypeParamsVec params;
parser.parse_type_name(&type_name);
std::transform(type_name.begin(), type_name.end(), type_name.begin(), tolower);
DataType::ConstPtr native_type(native_types.by_cql_name(type_name));
if (native_type) {
return native_type;
}
if (type_name == "list") {
parser.parse_type_parameters(¶ms);
if (params.size() != 1) {
LOG_ERROR("Expecting single parameter for list %s", type.c_str());
return DataType::NIL;
}
DataType::ConstPtr element_type = parse(params[0], native_types, keyspace);
return CollectionType::list(element_type, is_frozen);
}
if (type_name == "set") {
parser.parse_type_parameters(¶ms);
if (params.size() != 1) {
LOG_ERROR("Expecting single parameter for set %s", type.c_str());
return DataType::NIL;
}
DataType::ConstPtr element_type = parse(params[0], native_types, keyspace);
return CollectionType::set(element_type, is_frozen);
}
if (type_name == "map") {
parser.parse_type_parameters(¶ms);
if (params.size() != 2) {
LOG_ERROR("Expecting two parameters for set %s", type.c_str());
return DataType::NIL;
}
DataType::ConstPtr key_type = parse(params[0], native_types, keyspace);
DataType::ConstPtr value_type = parse(params[1], native_types, keyspace);
return CollectionType::map(key_type, value_type, is_frozen);
}
if (type_name == "tuple") {
parser.parse_type_parameters(¶ms);
if (params.empty()) {
LOG_ERROR("Expecting at least a one parameter for tuple %s", type.c_str());
return DataType::NIL;
}
DataType::Vec types;
for (Parser::TypeParamsVec::iterator i = params.begin(),
end = params.end();
i != end; ++i) {
types.push_back(parse(*i, native_types, keyspace));
}
return DataType::ConstPtr(new TupleType(types, is_frozen));
}
if (type_name == "frozen") {
parser.parse_type_parameters(¶ms);
if (params.size() != 1) {
LOG_ERROR("Expecting single parameter for frozen keyword %s", type.c_str());
return DataType::NIL;
}
return parse(params[0], native_types, keyspace, true);
}
if (type_name == "empty") {
return DataType::ConstPtr(new CustomType(type_name));
}
if (type_name.empty()) {
return DataType::NIL;
}
UserType::ConstPtr user_type(keyspace->get_or_create_user_type(type_name, is_frozen));
if (user_type->is_frozen() != is_frozen) {
return UserType::Ptr(new UserType(user_type->keyspace(),
user_type->type_name(),
user_type->fields(),
is_frozen));
}
return user_type;
}
