fedparser_store.cc

来自「certi-SHM-3.0.tar 不错的开源的分布式方针软件 大家多多支持 他」· CC 代码 · 共 570 行 · 第 1/2 页

    TypeStack[Depth] = PARAM ;
}

// ----------------------------------------------------------------------------
//! Process security level atoms.
void FedParser::processSecLevelAtom(Atom *)
    throw (SecurityError,
           RTIinternalError)
{
    TypeStack[Depth] = SECLEVEL ;
}

// ----------------------------------------------------------------------------
//! Guess whose security level the string describes, and set it correctly.
void FedParser::processSecLevelString(String *x)
    throw (SecurityError,
           RTIinternalError)
{
    SecurityLevelID LevelID ;

    // 1- Translate string into SecurityLevelID
    LevelID = RootObj->GetSecurityLevelID(x->name);

    // 2- Is it for an object class or an Interaction Class
    switch(TypeStack[Depth - 1]) {

    case OBJ:
    case CLASSOBJ:
        D.Out(pdTrace, "Setting SecLevel of ObjClass %d to %d.",
              objStack.back()->getHandle(), LevelID);
        objStack.back()->setLevelId(LevelID);
        break ;

    case INT:
    case CLASSINT:
        D.Out(pdTrace, "Setting SecLevel of IntClass %d to %d.",
              intStack.back()->handle, LevelID);
        intStack.back()->setLevelId(LevelID);
        break ;

    default:
        D.Out(pdError, "Should set security level for unknowm type %d.",
              TypeStack[Depth - 1]);
        throw RTIinternalError("Unknown Type for Security Level in FED file.");
    }

}

// ----------------------------------------------------------------------------
//! Process FED_RELIABLE etc. atoms, related to Transport or Order type.
void FedParser::processTransportOrderAtom(Atom *x)
    throw (RTIinternalError)
{
    if (TypeStack[Depth] == ATTRIB) {

        if (strcmp(x->name, FED_STR_RELIABLE) == 0)
            attStack.back()->Transport = RELIABLE ;

        else if (strcmp(x->name, FED_STR_BESTEFFORT) == 0)
            attStack.back()->Transport = BEST_EFFORT ;

        else if (strcmp(x->name, FED_STR_RECEIVE) == 0)
            attStack.back()->Order = RECEIVE ;

        else if (strcmp(x->name, FED_STR_TIMESTAMP) == 0)
            attStack.back()->Order = TIMESTAMP ;

        else {
            D.Out(pdError,
                  "Unknown atom string %s in StoreAtom's switch.", x->name);
            throw RTIinternalError("Unknown Atom string in FED file.");
        }
    } // TypeStack[Depth] == ATTRIB

    else if (TypeStack[Depth] == CLASSINT) {

        if (strcmp(x->name, FED_STR_RELIABLE) == 0)
            intStack.back()->transport = RELIABLE ;

        else if (strcmp(x->name, FED_STR_BESTEFFORT) == 0)
            intStack.back()->transport = BEST_EFFORT ;

        else if (strcmp(x->name, FED_STR_RECEIVE) == 0)
            intStack.back()->order = RECEIVE ;

        else if (strcmp(x->name, FED_STR_TIMESTAMP) == 0)
            intStack.back()->order = TIMESTAMP ;

        else {
            D.Out(pdError,
                  "Unknown atom string %s in StoreAtom's switch.", x->name);
            throw RTIinternalError("Unknown Atom string in FED file.");
        }
    } // TypeStack[Depth] == CLASSINT

    else {
        D.Out(pdError,
              "Unknown atom string %s in StoreAtom's switch.", x->name);
        throw RTIinternalError("Unknown Atom string in FED file.");
    }
}

// ----------------------------------------------------------------------------
//! Entry point for creating object instances (called by readFile module).
/*! Transfer the Object tree pointed by Root into a RootObj tree. It calls
  storeObject(Root) to start the recursive storage process.
  -- THIS METHOD IS THE STORE PART ENTRY POINT --
*/
void
FedParser::store(Object *Root)
    throw (SecurityError, RTIinternalError)
{
    storeObject(Root, "");
    cout << endl ;
}

// ----------------------------------------------------------------------------
//! Recognize atom name and store type or process atom.
void
FedParser::storeAtom(Atom *x)
    throw (SecurityError, RTIinternalError)
{

    D.Out(pdDebug, "Storing Atom %s.", x->name);
    cout << ' ' << x->name ;

    if (strcmp(x->name, FED_STR_FED) == 0)
        TypeStack[Depth] = FED ;

    else if (strcmp(x->name, FED_STR_OBJECTS) == 0)
        TypeStack[Depth] = OBJ ;

    else if (strcmp(x->name, FED_STR_INTERACTIONS) == 0)
        TypeStack[Depth] = INT ;

    else if (strcmp(x->name, FED_STR_CLASS) == 0)
        processClassAtom(x);

    else if (strcmp(x->name, FED_STR_ATTRIBUTE) == 0)
        processAttributeAtom(x);

    else if (strcmp(x->name, FED_STR_PARAMETER) == 0)
        processParameterAtom(x);

    else if (strcmp(x->name, FED_STR_SECLEVEL) == 0)
        processSecLevelAtom(x);

    else if (strcmp(x->name, FED_STR_FEDERATE) == 0)
        TypeStack[Depth] = FEDERATE_NAME ;

    else
        processTransportOrderAtom(x);
}

// ----------------------------------------------------------------------------
/*! The main recursive part is here.
  Header is used to print trace information.
*/
void FedParser::storeList(List *x, const char *Header)
    throw (SecurityError,
           RTIinternalError)
{
    Object *next ;

    storeObject(x->first, Header);

    next = x->next ;
    // Next can be either a Nil object(then the list end is reached)
    // a another list(if there are remaining list elements).

    if (next->type == NIL_TYPE) {
        Depth-- ;
        cout << "]" ;
    }
    // There are remaining elements in the list.
    else if (next->type == LIST_TYPE)
        storeList((struct List *)next, Header);

    else {
        D.Out(pdError, "Illegal type for next in List Object.");
        throw RTIinternalError("Illegal type for next in List Object.");
    }

    FedParser::freeObject(next);
}

// ----------------------------------------------------------------------------
//! storeObject calls the right store module depending on object type.
/*! Call one of the Store* method depending on 'x' type.
  Header is used to print trace information.
*/
void
FedParser::storeObject(Object *x, const char *Header)
    throw (SecurityError, RTIinternalError)
{
    switch(x->type) {
    case LIST_TYPE: {
        cout << endl << Header << '[' ;
        Depth++ ;

        // Increment Header
        char *NewHeader ;
        NewHeader = (char *) malloc(strlen(Header) + 4);
        if (NewHeader == NULL)
            storeList((struct List *) x, Header);
        else {
            strcpy(NewHeader, Header);
            strcat(NewHeader, " ");
            storeList((struct List *) x, NewHeader);
            free(NewHeader);
        }
    }
        break ;

    case ATOM_TYPE:
        storeAtom((struct Atom *) x);
        break ;
    case STRING_TYPE:
        storeString((struct String *) x);
        break ;
    case NIL_TYPE:
        cout << Header << "[]" << endl ;
        break ;
    }

    FedParser::freeObject(x);
}

// ----------------------------------------------------------------------------
void FedParser::storeString(String *x)
    throw (SecurityError,
           RTIinternalError)
{

    D.Out(pdDebug, "Storing String %s.", x->name);

    cout << " \"" << x->name << '\"' ;

    try {
        switch(TypeStack[Depth]) {

        case OBJ:
        case CLASSOBJ:
            objStack.back()->setName(x->name);
            break ;

        case INT:
        case CLASSINT:
            intStack.back()->setName(x->name);
            break ;

        case ATTRIB:
            attStack.back()->setName(x->name);
            break ;

        case PARAM:
            parStack.back()->setName(x->name);
            break ;

        case SECLEVEL:
            processSecLevelString(x);
            break ;

        case FEDERATE_NAME:
        case FEDERATE_LEVEL:
            processFederateString(x);
            break ;

        default:
            D.Out(pdError, "Unknown type in StoreString's switch.");
            throw RTIinternalError("CREAD: Unknown type in StoreString's switch.");
        }
    }
    catch (ValueLengthExceeded) {
        cout << endl << endl << "Name Token too long : " << x->name << '.'
             << endl << "You must shorten your string or increase the "
             << "MAX_USER_TAG_LENGTH constant." << endl ;
        throw RTIinternalError("Name too long.");
    }
}

}} // namespace certi/fedparser

// $Id: FedParser_Store.cc,v 3.10 2003/03/12 10:04:02 breholee Exp $