std::string AliasIdSet::toString() const {
assertx(checkInvariants());
if (isBigInteger()) {
return folly::to<std::string>(m_bits);
}
if (empty()) return "None";
if (isAny()) return "Any";
std::string result;
// Try to print the slots by grouping them, expect output like
// '0~4,9,10,50~...'
auto first = true; // whether to avoid priting the separator
int32_t begin = -1; // starting bit of the consecutive range.
// Append slots [begin, end) to result string.
auto const appendRange = [&] (uint32_t end) {
assertx(end > begin);
result += folly::to<std::string>(begin);
if (end == begin + 1) return;
if (end == begin + 2) {
result += folly::to<std::string>(",", begin + 1);
} else {
result += folly::to<std::string>("~", end - 1);
}
};
for (uint32_t i = 0; i <= BitsetMax; ++i) {
if (test(i)) {
if (begin < 0) begin = static_cast<int32_t>(i);
else continue;
} else {
if (begin < 0) continue;
if (!first) result += ",";
appendRange(i);
begin = -1;
first = false;
}
}
if (hasUpperRange()) {
if (!first) result += ",";
if (begin < 0) begin = BitsetMax + 1;
result += folly::to<std::string>(begin, "~...");
} else if (begin >= 0) {
// Append [begin, BitsetMax].
appendRange(BitsetMax + 1);
}
return result;
}
// 起動.
IZ_BOOL Udp::start(const IPv4Endpoint& hostEp)
{
if (isValidSocket(m_socket)) {
return IZ_TRUE;
}
IZ_BOOL result = IZ_FALSE;
// ソケットの生成
m_socket = socket(
AF_INET, // アドレスファミリ
SOCK_DGRAM, // ソケットタイプ
IPPROTO_UDP); // プロトコル
VRETURN(isValidSocket(m_socket));
// 通信ポート・アドレスの設定
sockaddr_in inAddr;
{
FILL_ZERO(&inAddr, sizeof(inAddr));
inAddr.sin_family = AF_INET;
inAddr.sin_port = htons(hostEp.getPort());
auto address = hostEp.getAddress();
if (address.isAny()) {
setIp(inAddr, htonl(INADDR_ANY));
}
else {
IZ_CHAR ip[64];
address.toString(ip, COUNTOF(ip));
setIp(inAddr, inet_addr(ip));
}
}
// ソケットにアドレスを結びつける
result = (bind(m_socket, (const sockaddr*)&inAddr, sizeof(inAddr)) >= 0);
if (result) {
m_isBindAddr = IZ_TRUE;
m_host = hostEp;
}
else {
IZ_ASSERT(IZ_FALSE);
stop();
}
return result;
}
IZ_BOOL Udp::connectTo(const IPv4Endpoint& remoteEp)
{
VRETURN(isValidSocket(m_socket));
IZ_BOOL result = IZ_FALSE;
// 通信ポート・アドレスの設定
sockaddr_in destAddr;
{
memset(&destAddr, 0, sizeof(destAddr));
destAddr.sin_family = AF_INET;
destAddr.sin_port = htons(remoteEp.getPort());
auto address = remoteEp.getAddress();
result = !address.isAny();
VGOTO(result, __EXIT__);
char ip[64];
address.toString(ip, COUNTOF(ip));
setIp(destAddr, inet_addr(ip));
}
// 接続
result = (connect(m_socket, (const sockaddr*)&destAddr, sizeof(destAddr)) >= 0);
if (result) {
if (!m_isBindAddr) {
// ホスト名取得
sockaddr_in inAddr;
int32_t inAddrSize = sizeof(inAddr);
result = (getsockname(m_socket, (sockaddr*)&inAddr, &inAddrSize) >= 0);
VGOTO(result, __EXIT__);
m_isBindAddr = IZ_TRUE;
m_host.set(inAddr);
}
}
__EXIT__:
if (!result) {
IZ_ASSERT(IZ_FALSE);
stop();
}
return result;
}
void StructuredScript::Storage::Memory::assign(IAny::Ptr object, IStorage *storage, IExceptionManager *exception, INode *expr){
auto value = value_.lock();
if (attributes_ != nullptr){//Validate access
if (value != nullptr && !Query::Object::isUndefined(value) && (attributes_->hasAttribute(""))){
Query::ExceptionManager::set(exception, PrimitiveFactory::createString(Query::ExceptionManager::combine(
"Cannot modify object!", expr)));
return;
}
}
auto states = MemoryState(type_->states());
if ((states.isConstant() || states.isFinal()) && value != nullptr && !Query::Object::isUndefined(value)){//Cannot assign to a const | final memory
Query::ExceptionManager::set(exception, PrimitiveFactory::createString(Query::ExceptionManager::combine(
"Cannot modify memory!", expr)));
return;
}
object = object->base();
if (object == nullptr || Query::Object::isUndefined(object) || Query::Object::isExpansion(object) || Query::Object::isExpanded(object)){
Query::ExceptionManager::set(exception, PrimitiveFactory::createString(Query::ExceptionManager::combine(
"Cannot assign an invalid object!", expr)));
return;
}
auto type = object->type();
if (type == nullptr){//Expected type
Query::ExceptionManager::set(exception, PrimitiveFactory::createString(Query::ExceptionManager::combine(
"Expected type of object during assignment!", expr)));
return;
}
bool mustCast;
if (type_ != nullptr){//Validate assignment
auto compatibleType = type_->getCompatibleType(type);
if (compatibleType == nullptr){//Incompatible types -- use type as is
if (states.isReference() && !states.isRValReference()){//Compatible type required
Query::ExceptionManager::set(exception, PrimitiveFactory::createString(Query::ExceptionManager::combine(
"Incompatible types!", expr)));
return;
}
mustCast = true;
compatibleType = type_;
}
else
mustCast = false;
if (states.isReference()){//Get reference
auto memory = object->memory();
if (states.isRValReference()){//Value | Reference
if (mustCast){
object = object->cast(compatibleType->base(), storage, exception, expr);
if (Query::ExceptionManager::has(exception))
return;
}
else if (memory != nullptr){
auto objectType = memory->type();
auto objectStates = MemoryState((objectType == nullptr) ? MemoryState::STATE_NONE : objectType->states());
if (!objectStates.isRValReference()){//Only get reference if object is not an rvalue reference
object = PrimitiveFactory::createReference(memory->ptr());
dynamic_cast<IDeclaredType *>(type_.get())->states((states -= MemoryState::STATE_RVALUE).states());
}
}
}
else if (memory == nullptr){//Reference requires an lvalue
Query::ExceptionManager::set(exception, PrimitiveFactory::createString(Query::ExceptionManager::combine(
"Cannot get reference of an rvalue!", expr)));
return;
}
else//Reference
object = PrimitiveFactory::createReference(memory->ptr());
}
else if (!compatibleType->isAny()){//Cast object to compatible type
object = object->cast(compatibleType->base(), storage, exception, expr);
if (Query::ExceptionManager::has(exception))
return;
if (object == nullptr){//Failed to do conversion
Query::ExceptionManager::set(exception, PrimitiveFactory::createString(Query::ExceptionManager::combine(
"Incompatible types!", expr)));
return;
}
}
if (object->memory() != nullptr)//Create object copy
object = object->clone(storage, exception, expr);
if (Query::ExceptionManager::has(exception))
return;
}
assign(object);
}
