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; }