C++ Datum::GetType方法代码示例

Scope& Scope::AppendScope(const std::string& key)
{
	Datum* datum = Find(key);
	//TODO: Push Back when removing from Vector
	//Found key, check if type is table
	if (datum)
	{
		if (datum->IsExternal() || (datum->GetType() != Datum::DatumType::Table))
		{
			throw std::exception("This Datum is not of the right type");
		}
		Scope* newScope = new Scope();
		newScope->mParent = this;
		datum->Set(newScope, datum->Size());
		return *datum->GetScope(datum->Size() - 1);
	}
	else
	{
		//key not found
		Datum& d = Append(key, Datum::DatumType::Table);
		Scope* newScope = new Scope();
		newScope->mParent = this;
		d.Set(newScope, 0);
		return *d.GetScope(0);
	}
}

void Scope::Adopt(Scope& childToAdopt, const std::string& key, const std::uint32_t index)
{
	if (childToAdopt.GetParent())
		childToAdopt.Orphan();

	Datum * foundDatum = Find(key);
	if (foundDatum)
	{
		if ((foundDatum->GetType() != Datum::DatumType::Table) || foundDatum->IsExternal())
			throw std::exception("You are trying to adopt into a invalid scope");

		if ((foundDatum->GetType() == Datum::DatumType::Table))
		{
			if (index >= foundDatum->Size())
			{
				foundDatum->Set(&childToAdopt, index);
				foundDatum->GetScope(index)->mParent = this;
			}
			else
			{
				Scope* temp = foundDatum->GetScope(index);
				foundDatum->Set(&childToAdopt, index);
				foundDatum->GetScope(index)->mParent = this;
				for (std::uint32_t i = index + 1; i < foundDatum->Size(); ++i)
				{
					Scope* temp2 = foundDatum->GetScope(i);
					foundDatum->Set(temp, i);
					temp = temp2;
				}
				foundDatum->Set(temp, foundDatum->Size());
			}
		}
	}
	else
	{
		Datum& d = Append(key, Datum::DatumType::Table);
		d.Set(&childToAdopt);
		d.GetScope()->mParent = this;
	}
}

void Scope::Adopt(Scope& child, const std::string& key, std::uint32_t index)
{
    if (key == std::string())
        throw std::exception("Key cannot be an empty string.");

    child.Orphan();
    child.mParent = this;

    // try to find entry first in this scope
    Datum* d = Find(key);
    if (d != nullptr)
    {
        if (d->GetType() != Datum::Table)
            throw std::exception("Found entry is not a table!");
        if (d->IsExternal())
            throw std::exception("Table is external. Cannot modify data owned by something else.");

        std::uint32_t originalDatumSize = d->Size();

        // if a scope is empty or not pointing to anything at the given index, we can just have it point to something else
        if (originalDatumSize <= index || d->GetTable(index) == nullptr || d->GetTable(index)->mOrder.Size() == 0)
            d->Set(&child, index);

        // otherwise, we add in the child scope and rearrange the datum array if necessary
        else
        {
            if (index < originalDatumSize)
            {
                d->SetSize(originalDatumSize + 1);
                for (std::uint32_t i = originalDatumSize; i > index; --i)
                {
                    d->Set(d->GetTable(i - 1), i);
                }
            }
            else if (index > originalDatumSize)
            {
                index = originalDatumSize;
            }
            d->Set(&child, index);
        }
    }
    else
    {
        Datum scopeDatum;
        scopeDatum = &child;

        std::pair<std::string, Datum> pair(key, scopeDatum);
        HashMap<std::string, Datum>::Iterator iterator = mTable.Insert(pair);
        mOrder.PushBack(&(*iterator));
    }
}

Scope& Scope::AppendScope(const std::string& key)
{
    if (key == std::string())
        throw std::exception("Key cannot be an empty string.");

    Scope* newScope = new Scope();
    newScope->mParent = this;

    // try to find entry first in this scope
    Datum* d = Find(key);
    if (d != nullptr)
    {
        if (d->GetType() != Datum::Table && d->GetType() != Datum::Unknown)
        {
            delete newScope;
            throw std::exception("Found entry is not a table!");
        }
        if (d->IsExternal())
        {
            delete newScope;
            throw std::exception("Table entry is external. Cannot modify data owned by something else.");
        }

        // a new scope gets added into this table datum
        std::uint32_t datumSize = d->Size();
        d->Set(newScope, datumSize);
        return *d->GetTable(datumSize);
    }

    // if no entry is found, create new datum with this scope
    Datum scopeDatum;
    scopeDatum = newScope;
    std::pair<std::string, Datum> pair(key, scopeDatum);
    HashMap<std::string, Datum>::Iterator iterator = mTable.Insert(pair);
    mOrder.PushBack(&(*iterator));
    return *(iterator->second.GetTable());
}

	/**
	The update function of ActionAdopt calls the setSector method of
	the entity that contains this action on the provided target sector.
	This should produce the behavior of orphaning the entity and moving it
	into a new sector

	@param curState the current worldstate to reference during update
	*/
	void ActionAdopt::Update(const WorldState& curState)
	{
		//Double check to ensure that our target sector isn't the one
		//that our containing entity already exists in
		std::string targetName = Find("Target")->Get<std::string>();
		Sector* curSector = curState.GetSector();
		if (targetName == curSector->Name())
		{
			return;
		}

		//Grab the entity that contains us
		Entity* curEntity = curState.GetEntity();
		
		//Grab the world
		World* curWorld = curState.GetWorld();

		//Set up the sector
		Datum* targetDatum = curWorld->Sectors()->Find(targetName);
		if (targetDatum == nullptr || targetDatum->GetType() != Datum::TABLE)
		{
			throw std::exception("Sector could not be found");
		}
		else		
		{
			Sector* targetSector = targetDatum->Get<Scope*>()->As<Sector>();
			if (targetSector == nullptr)
			{
				throw std::exception("Malformed sector");
			}
			else
			{
				curEntity->SetSector(targetSector);
				return;
			}
		}
	}