<p>text</p\n><title>" ); + //xml.Print(); + //XmlTest( "Tag split by newline", xml.Error(), false ); + } + + #ifdef TIXML_USE_STL + { + // [ 1475201 ] TinyXML parses entities in comments + TiXmlDocument xml; + istringstream parse1( "" + "" ); + parse1 >> xml; + + TiXmlNode* e0 = xml.FirstChild(); + TiXmlNode* e1 = e0->NextSibling(); + TiXmlComment* c0 = e0->ToComment(); + TiXmlComment* c1 = e1->ToComment(); + + XmlTest( "Comments ignore entities.", " declarations for <head> & <body> ", c0->Value(), true ); + XmlTest( "Comments ignore entities.", " far & away ", c1->Value(), true ); + } + #endif + + { + // [ 1475201 ] TinyXML parses entities in comments + TiXmlDocument xml; + xml.Parse("" + "" ); + + TiXmlNode* e0 = xml.FirstChild(); + TiXmlNode* e1 = e0->NextSibling(); + TiXmlComment* c0 = e0->ToComment(); + TiXmlComment* c1 = e1->ToComment(); + + XmlTest( "Comments ignore entities.", " declarations for <head> & <body> ", c0->Value(), true ); + XmlTest( "Comments ignore entities.", " far & away ", c1->Value(), true ); + } + + { + TiXmlDocument xml; + xml.Parse( "<Parent>" + "<child1 att=''/>" + "" + "<child2 att=''/>" + "</Parent>" ); + int count = 0; + + TiXmlNode* ele = 0; + while ( (ele = xml.FirstChildElement( "Parent" )->IterateChildren( ele ) ) != 0 ) { + ++count; + } + XmlTest( "Comments iterate correctly.", 3, count ); + } + + { + // trying to repro ]1874301]. If it doesn't go into an infinite loop, all is well. + unsigned char buf[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?><feed><![CDATA[Test XMLblablablalblbl"; + buf[60] = 239; + buf[61] = 0; + + TiXmlDocument doc; + doc.Parse( (const char*)buf); + } + + + { + // bug 1827248 Error while parsing a little bit malformed file + // Actually not malformed - should work. + TiXmlDocument xml; + xml.Parse( "<attributelist> </attributelist >" ); + XmlTest( "Handle end tag whitespace", false, xml.Error() ); + } + + { + // This one must not result in an infinite loop + TiXmlDocument xml; + xml.Parse( "<infinite>loop" ); + XmlTest( "Infinite loop test.", true, true ); + } + + { + // 1709904 - can not repro the crash + { + TiXmlDocument xml; + xml.Parse( "<tag>/</tag>" ); + XmlTest( "Odd XML parsing.", xml.FirstChild()->Value(), "tag" ); + } + /* Could not repro. { + TiXmlDocument xml; + xml.LoadFile( "EQUI_Inventory.xml" ); + //XmlTest( "Odd XML parsing.", xml.FirstChildElement()->Value(), "XML" ); + TiXmlPrinter printer; + xml.Accept( &printer ); + fprintf( stdout, "%s", printer.CStr() ); + }*/ + } + + /* 1417717 experiment + { + TiXmlDocument xml; + xml.Parse("<text>Dan & Tracie</text>"); + xml.Print(stdout); + } + { + TiXmlDocument xml; + xml.Parse("<text>Dan &foo; Tracie</text>"); + xml.Print(stdout); + } + */ + + #if defined( WIN32 ) && defined( TUNE ) + _CrtMemCheckpoint( &endMemState ); + //_CrtMemDumpStatistics( &endMemState ); + + _CrtMemState diffMemState; + _CrtMemDifference( &diffMemState, &startMemState, &endMemState ); + _CrtMemDumpStatistics( &diffMemState ); + #endif + + printf ("\nPass %d, Fail %d\n", gPass, gFail); + return gFail; +} Index: /branches/fep_rpc_client/tinyxml/tinyxmlparser.cpp =================================================================== --- /branches/fep_rpc_client/tinyxml/tinyxmlparser.cpp (revision 79) +++ /branches/fep_rpc_client/tinyxml/tinyxmlparser.cpp (revision 79) @@ -0,0 +1,1638 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code by Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + +#include <ctype.h> +#include <stddef.h> + +#include "tinyxml.h" + +//#define DEBUG_PARSER +#if defined( DEBUG_PARSER ) +# if defined( DEBUG ) && defined( _MSC_VER ) +# include <windows.h> +# define TIXML_LOG OutputDebugString +# else +# define TIXML_LOG printf +# endif +#endif + +// Note tha "PutString" hardcodes the same list. This +// is less flexible than it appears. Changing the entries +// or order will break putstring. +TiXmlBase::Entity TiXmlBase::entity[ TiXmlBase::NUM_ENTITY ] = +{ + { "&", 5, '&' }, + { "<", 4, '<' }, + { ">", 4, '>' }, + { """, 6, '\"' }, + { "'", 6, '\'' } +}; + +// Bunch of unicode info at: +// http://www.unicode.org/faq/utf_bom.html +// Including the basic of this table, which determines the #bytes in the +// sequence from the lead byte. 1 placed for invalid sequences -- +// although the result will be junk, pass it through as much as possible. +// Beware of the non-characters in UTF-8: +// ef bb bf (Microsoft "lead bytes") +// ef bf be +// ef bf bf + +const unsigned char TIXML_UTF_LEAD_0 = 0xefU; +const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; +const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; + +const int TiXmlBase::utf8ByteTable[256] = +{ + // 0 1 2 3 4 5 6 7 8 9 a b c d e f + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x00 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x10 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x30 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x50 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x70 End of ASCII range + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x80 0x80 to 0xc1 invalid + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x90 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xa0 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xb0 + 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xc0 0xc2 to 0xdf 2 byte + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xd0 + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xe0 0xe0 to 0xef 3 byte + 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid +}; + + +void TiXmlBase::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length ) +{ + const unsigned long BYTE_MASK = 0xBF; + const unsigned long BYTE_MARK = 0x80; + const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; + + if (input < 0x80) + *length = 1; + else if ( input < 0x800 ) + *length = 2; + else if ( input < 0x10000 ) + *length = 3; + else if ( input < 0x200000 ) + *length = 4; + else + { *length = 0; return; } // This code won't covert this correctly anyway. + + output += *length; + + // Scary scary fall throughs. + switch (*length) + { + case 4: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 3: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 2: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 1: + --output; + *output = (char)(input | FIRST_BYTE_MARK[*length]); + } +} + + +/*static*/ int TiXmlBase::IsAlpha( unsigned char anyByte, TiXmlEncoding /*encoding*/ ) +{ + // This will only work for low-ascii, everything else is assumed to be a valid + // letter. I'm not sure this is the best approach, but it is quite tricky trying + // to figure out alhabetical vs. not across encoding. So take a very + // conservative approach. + +// if ( encoding == TIXML_ENCODING_UTF8 ) +// { + if ( anyByte < 127 ) + return isalpha( anyByte ); + else + return 1; // What else to do? The unicode set is huge...get the english ones right. +// } +// else +// { +// return isalpha( anyByte ); +// } +} + + +/*static*/ int TiXmlBase::IsAlphaNum( unsigned char anyByte, TiXmlEncoding /*encoding*/ ) +{ + // This will only work for low-ascii, everything else is assumed to be a valid + // letter. I'm not sure this is the best approach, but it is quite tricky trying + // to figure out alhabetical vs. not across encoding. So take a very + // conservative approach. + +// if ( encoding == TIXML_ENCODING_UTF8 ) +// { + if ( anyByte < 127 ) + return isalnum( anyByte ); + else + return 1; // What else to do? The unicode set is huge...get the english ones right. +// } +// else +// { +// return isalnum( anyByte ); +// } +} + + +class TiXmlParsingData +{ + friend class TiXmlDocument; + public: + void Stamp( const char* now, TiXmlEncoding encoding ); + + const TiXmlCursor& Cursor() const { return cursor; } + + private: + // Only used by the document! + TiXmlParsingData( const char* start, int _tabsize, int row, int col ) + { + assert( start ); + stamp = start; + tabsize = _tabsize; + cursor.row = row; + cursor.col = col; + } + + TiXmlCursor cursor; + const char* stamp; + int tabsize; +}; + + +void TiXmlParsingData::Stamp( const char* now, TiXmlEncoding encoding ) +{ + assert( now ); + + // Do nothing if the tabsize is 0. + if ( tabsize < 1 ) + { + return; + } + + // Get the current row, column. + int row = cursor.row; + int col = cursor.col; + const char* p = stamp; + assert( p ); + + while ( p < now ) + { + // Treat p as unsigned, so we have a happy compiler. + const unsigned char* pU = (const unsigned char*)p; + + // Code contributed by Fletcher Dunn: (modified by lee) + switch (*pU) { + case 0: + // We *should* never get here, but in case we do, don't + // advance past the terminating null character, ever + return; + + case '\r': + // bump down to the next line + ++row; + col = 0; + // Eat the character + ++p; + + // Check for \r\n sequence, and treat this as a single character + if (*p == '\n') { + ++p; + } + break; + + case '\n': + // bump down to the next line + ++row; + col = 0; + + // Eat the character + ++p; + + // Check for \n\r sequence, and treat this as a single + // character. (Yes, this bizarre thing does occur still + // on some arcane platforms...) + if (*p == '\r') { + ++p; + } + break; + + case '\t': + // Eat the character + ++p; + + // Skip to next tab stop + col = (col / tabsize + 1) * tabsize; + break; + + case TIXML_UTF_LEAD_0: + if ( encoding == TIXML_ENCODING_UTF8 ) + { + if ( *(p+1) && *(p+2) ) + { + // In these cases, don't advance the column. These are + // 0-width spaces. + if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 ) + p += 3; + else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU ) + p += 3; + else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU ) + p += 3; + else + { p +=3; ++col; } // A normal character. + } + } + else + { + ++p; + ++col; + } + break; + + default: + if ( encoding == TIXML_ENCODING_UTF8 ) + { + // Eat the 1 to 4 byte utf8 character. + int step = TiXmlBase::utf8ByteTable[*((const unsigned char*)p)]; + if ( step == 0 ) + step = 1; // Error case from bad encoding, but handle gracefully. + p += step; + + // Just advance one column, of course. + ++col; + } + else + { + ++p; + ++col; + } + break; + } + } + cursor.row = row; + cursor.col = col; + assert( cursor.row >= -1 ); + assert( cursor.col >= -1 ); + stamp = p; + assert( stamp ); +} + + +const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding ) +{ + if ( !p || !*p ) + { + return 0; + } + if ( encoding == TIXML_ENCODING_UTF8 ) + { + while ( *p ) + { + const unsigned char* pU = (const unsigned char*)p; + + // Skip the stupid Microsoft UTF-8 Byte order marks + if ( *(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==TIXML_UTF_LEAD_1 + && *(pU+2)==TIXML_UTF_LEAD_2 ) + { + p += 3; + continue; + } + else if(*(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==0xbfU + && *(pU+2)==0xbeU ) + { + p += 3; + continue; + } + else if(*(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==0xbfU + && *(pU+2)==0xbfU ) + { + p += 3; + continue; + } + + if ( IsWhiteSpace( *p ) ) // Still using old rules for white space. + ++p; + else + break; + } + } + else + { + while ( *p && IsWhiteSpace( *p ) ) + ++p; + } + + return p; +} + +#ifdef TIXML_USE_STL +/*static*/ bool TiXmlBase::StreamWhiteSpace( std::istream * in, TIXML_STRING * tag ) +{ + for( ;; ) + { + if ( !in->good() ) return false; + + int c = in->peek(); + // At this scope, we can't get to a document. So fail silently. + if ( !IsWhiteSpace( c ) || c <= 0 ) + return true; + + *tag += (char) in->get(); + } +} + +/*static*/ bool TiXmlBase::StreamTo( std::istream * in, int character, TIXML_STRING * tag ) +{ + //assert( character > 0 && character < 128 ); // else it won't work in utf-8 + while ( in->good() ) + { + int c = in->peek(); + if ( c == character ) + return true; + if ( c <= 0 ) // Silent failure: can't get document at this scope + return false; + + in->get(); + *tag += (char) c; + } + return false; +} +#endif + +// One of TinyXML's more performance demanding functions. Try to keep the memory overhead down. The +// "assign" optimization removes over 10% of the execution time. +// +const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding ) +{ + // Oddly, not supported on some comilers, + //name->clear(); + // So use this: + *name = ""; + assert( p ); + + // Names start with letters or underscores. + // Of course, in unicode, tinyxml has no idea what a letter *is*. The + // algorithm is generous. + // + // After that, they can be letters, underscores, numbers, + // hyphens, or colons. (Colons are valid ony for namespaces, + // but tinyxml can't tell namespaces from names.) + if ( p && *p + && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) ) + { + const char* start = p; + while( p && *p + && ( IsAlphaNum( (unsigned char ) *p, encoding ) + || *p == '_' + || *p == '-' + || *p == '.' + || *p == ':' ) ) + { + //(*name) += *p; // expensive + ++p; + } + if ( p-start > 0 ) { + name->assign( start, p-start ); + } + return p; + } + return 0; +} + +const char* TiXmlBase::GetEntity( const char* p, char* value, int* length, TiXmlEncoding encoding ) +{ + // Presume an entity, and pull it out. + TIXML_STRING ent; + int i; + *length = 0; + + if ( *(p+1) && *(p+1) == '#' && *(p+2) ) + { + unsigned long ucs = 0; + ptrdiff_t delta = 0; + unsigned mult = 1; + + if ( *(p+2) == 'x' ) + { + // Hexadecimal. + if ( !*(p+3) ) return 0; + + const char* q = p+3; + q = strchr( q, ';' ); + + if ( !q || !*q ) return 0; + + delta = q-p; + --q; + + while ( *q != 'x' ) + { + if ( *q >= '0' && *q <= '9' ) + ucs += mult * (*q - '0'); + else if ( *q >= 'a' && *q <= 'f' ) + ucs += mult * (*q - 'a' + 10); + else if ( *q >= 'A' && *q <= 'F' ) + ucs += mult * (*q - 'A' + 10 ); + else + return 0; + mult *= 16; + --q; + } + } + else + { + // Decimal. + if ( !*(p+2) ) return 0; + + const char* q = p+2; + q = strchr( q, ';' ); + + if ( !q || !*q ) return 0; + + delta = q-p; + --q; + + while ( *q != '#' ) + { + if ( *q >= '0' && *q <= '9' ) + ucs += mult * (*q - '0'); + else + return 0; + mult *= 10; + --q; + } + } + if ( encoding == TIXML_ENCODING_UTF8 ) + { + // convert the UCS to UTF-8 + ConvertUTF32ToUTF8( ucs, value, length ); + } + else + { + *value = (char)ucs; + *length = 1; + } + return p + delta + 1; + } + + // Now try to match it. + for( i=0; i<NUM_ENTITY; ++i ) + { + if ( strncmp( entity[i].str, p, entity[i].strLength ) == 0 ) + { + assert( strlen( entity[i].str ) == entity[i].strLength ); + *value = entity[i].chr; + *length = 1; + return ( p + entity[i].strLength ); + } + } + + // So it wasn't an entity, its unrecognized, or something like that. + *value = *p; // Don't put back the last one, since we return it! + //*length = 1; // Leave unrecognized entities - this doesn't really work. + // Just writes strange XML. + return p+1; +} + + +bool TiXmlBase::StringEqual( const char* p, + const char* tag, + bool ignoreCase, + TiXmlEncoding encoding ) +{ + assert( p ); + assert( tag ); + if ( !p || !*p ) + { + assert( 0 ); + return false; + } + + const char* q = p; + + if ( ignoreCase ) + { + while ( *q && *tag && ToLower( *q, encoding ) == ToLower( *tag, encoding ) ) + { + ++q; + ++tag; + } + + if ( *tag == 0 ) + return true; + } + else + { + while ( *q && *tag && *q == *tag ) + { + ++q; + ++tag; + } + + if ( *tag == 0 ) // Have we found the end of the tag, and everything equal? + return true; + } + return false; +} + +const char* TiXmlBase::ReadText( const char* p, + TIXML_STRING * text, + bool trimWhiteSpace, + const char* endTag, + bool caseInsensitive, + TiXmlEncoding encoding ) +{ + *text = ""; + if ( !trimWhiteSpace // certain tags always keep whitespace + || !condenseWhiteSpace ) // if true, whitespace is always kept + { + // Keep all the white space. + while ( p && *p + && !StringEqual( p, endTag, caseInsensitive, encoding ) + ) + { + int len; + char cArr[4] = { 0, 0, 0, 0 }; + p = GetChar( p, cArr, &len, encoding ); + text->append( cArr, len ); + } + } + else + { + bool whitespace = false; + + // Remove leading white space: + p = SkipWhiteSpace( p, encoding ); + while ( p && *p + && !StringEqual( p, endTag, caseInsensitive, encoding ) ) + { + if ( *p == '\r' || *p == '\n' ) + { + whitespace = true; + ++p; + } + else if ( IsWhiteSpace( *p ) ) + { + whitespace = true; + ++p; + } + else + { + // If we've found whitespace, add it before the + // new character. Any whitespace just becomes a space. + if ( whitespace ) + { + (*text) += ' '; + whitespace = false; + } + int len; + char cArr[4] = { 0, 0, 0, 0 }; + p = GetChar( p, cArr, &len, encoding ); + if ( len == 1 ) + (*text) += cArr[0]; // more efficient + else + text->append( cArr, len ); + } + } + } + if ( p && *p ) + p += strlen( endTag ); + return ( p && *p ) ? p : 0; +} + +#ifdef TIXML_USE_STL + +void TiXmlDocument::StreamIn( std::istream * in, TIXML_STRING * tag ) +{ + // The basic issue with a document is that we don't know what we're + // streaming. Read something presumed to be a tag (and hope), then + // identify it, and call the appropriate stream method on the tag. + // + // This "pre-streaming" will never read the closing ">" so the + // sub-tag can orient itself. + + if ( !StreamTo( in, '<', tag ) ) + { + SetError( TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + + while ( in->good() ) + { + int tagIndex = (int) tag->length(); + while ( in->good() && in->peek() != '>' ) + { + int c = in->get(); + if ( c <= 0 ) + { + SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); + break; + } + (*tag) += (char) c; + } + + if ( in->good() ) + { + // We now have something we presume to be a node of + // some sort. Identify it, and call the node to + // continue streaming. + TiXmlNode* node = Identify( tag->c_str() + tagIndex, TIXML_DEFAULT_ENCODING ); + + if ( node ) + { + node->StreamIn( in, tag ); + bool isElement = node->ToElement() != 0; + delete node; + node = 0; + + // If this is the root element, we're done. Parsing will be + // done by the >> operator. + if ( isElement ) + { + return; + } + } + else + { + SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + } + } + // We should have returned sooner. + SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN ); +} + +#endif + +const char* TiXmlDocument::Parse( const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding ) +{ + ClearError(); + + // Parse away, at the document level. Since a document + // contains nothing but other tags, most of what happens + // here is skipping white space. + if ( !p || !*p ) + { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + // Note that, for a document, this needs to come + // before the while space skip, so that parsing + // starts from the pointer we are given. + location.Clear(); + if ( prevData ) + { + location.row = prevData->cursor.row; + location.col = prevData->cursor.col; + } + else + { + location.row = 0; + location.col = 0; + } + TiXmlParsingData data( p, TabSize(), location.row, location.col ); + location = data.Cursor(); + + if ( encoding == TIXML_ENCODING_UNKNOWN ) + { + // Check for the Microsoft UTF-8 lead bytes. + const unsigned char* pU = (const unsigned char*)p; + if ( *(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0 + && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1 + && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 ) + { + encoding = TIXML_ENCODING_UTF8; + useMicrosoftBOM = true; + } + } + + p = SkipWhiteSpace( p, encoding ); + if ( !p ) + { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + while ( p && *p ) + { + TiXmlNode* node = Identify( p, encoding ); + if ( node ) + { + p = node->Parse( p, &data, encoding ); + LinkEndChild( node ); + } + else + { + break; + } + + // Did we get encoding info? + if ( encoding == TIXML_ENCODING_UNKNOWN + && node->ToDeclaration() ) + { + TiXmlDeclaration* dec = node->ToDeclaration(); + const char* enc = dec->Encoding(); + assert( enc ); + + if ( *enc == 0 ) + encoding = TIXML_ENCODING_UTF8; + else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) ) + encoding = TIXML_ENCODING_UTF8; + else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) ) + encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice + else + encoding = TIXML_ENCODING_LEGACY; + } + + p = SkipWhiteSpace( p, encoding ); + } + + // Was this empty? + if ( !firstChild ) { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding ); + return 0; + } + + // All is well. + return p; +} + +void TiXmlDocument::SetError( int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding ) +{ + // The first error in a chain is more accurate - don't set again! + if ( error ) + return; + + assert( err > 0 && err < TIXML_ERROR_STRING_COUNT ); + error = true; + errorId = err; + errorDesc = errorString[ errorId ]; + + errorLocation.Clear(); + if ( pError && data ) + { + data->Stamp( pError, encoding ); + errorLocation = data->Cursor(); + } +} + + +TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding ) +{ + TiXmlNode* returnNode = 0; + + p = SkipWhiteSpace( p, encoding ); + if( !p || !*p || *p != '<' ) + { + return 0; + } + + p = SkipWhiteSpace( p, encoding ); + + if ( !p || !*p ) + { + return 0; + } + + // What is this thing? + // - Elements start with a letter or underscore, but xml is reserved. + // - Comments: "; + + if ( !StringEqual( p, startTag, false, encoding ) ) + { + if ( document ) + document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding ); + return 0; + } + p += strlen( startTag ); + + // [ 1475201 ] TinyXML parses entities in comments + // Oops - ReadText doesn't work, because we don't want to parse the entities. + // p = ReadText( p, &value, false, endTag, false, encoding ); + // + // from the XML spec: + /* + [Definition: Comments may appear anywhere in a document outside other markup; in addition, + they may appear within the document type declaration at places allowed by the grammar. + They are not part of the document's character data; an XML processor MAY, but need not, + make it possible for an application to retrieve the text of comments. For compatibility, + the string "--" (double-hyphen) MUST NOT occur within comments.] Parameter entity + references MUST NOT be recognized within comments. + + An example of a comment: + +  + */ + + value = ""; + // Keep all the white space. + while ( p && *p && !StringEqual( p, endTag, false, encoding ) ) + { + value.append( p, 1 ); + ++p; + } + if ( p && *p ) + p += strlen( endTag ); + + return p; +} + + +const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) +{ + p = SkipWhiteSpace( p, encoding ); + if ( !p || !*p ) return 0; + + if ( data ) + { + data->Stamp( p, encoding ); + location = data->Cursor(); + } + // Read the name, the '=' and the value. + const char* pErr = p; + p = ReadName( p, &name, encoding ); + if ( !p || !*p ) + { + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding ); + return 0; + } + p = SkipWhiteSpace( p, encoding ); + if ( !p || !*p || *p != '=' ) + { + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); + return 0; + } + + ++p; // skip '=' + p = SkipWhiteSpace( p, encoding ); + if ( !p || !*p ) + { + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); + return 0; + } + + const char* end; + const char SINGLE_QUOTE = '\''; + const char DOUBLE_QUOTE = '\"'; + + if ( *p == SINGLE_QUOTE ) + { + ++p; + end = "\'"; // single quote in string + p = ReadText( p, &value, false, end, false, encoding ); + } + else if ( *p == DOUBLE_QUOTE ) + { + ++p; + end = "\""; // double quote in string + p = ReadText( p, &value, false, end, false, encoding ); + } + else + { + // All attribute values should be in single or double quotes. + // But this is such a common error that the parser will try + // its best, even without them. + value = ""; + while ( p && *p // existence + && !IsWhiteSpace( *p ) // whitespace + && *p != '/' && *p != '>' ) // tag end + { + if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) { + // [ 1451649 ] Attribute values with trailing quotes not handled correctly + // We did not have an opening quote but seem to have a + // closing one. Give up and throw an error. + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); + return 0; + } + value += *p; + ++p; + } + } + return p; +} + +#ifdef TIXML_USE_STL +void TiXmlText::StreamIn( std::istream * in, TIXML_STRING * tag ) +{ + while ( in->good() ) + { + int c = in->peek(); + if ( !cdata && (c == '<' ) ) + { + return; + } + if ( c <= 0 ) + { + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + + (*tag) += (char) c; + in->get(); // "commits" the peek made above + + if ( cdata && c == '>' && tag->size() >= 3 ) { + size_t len = tag->size(); + if ( (*tag)[len-2] == ']' && (*tag)[len-3] == ']' ) { + // terminator of cdata. + return; + } + } + } +} +#endif + +const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) +{ + value = ""; + TiXmlDocument* document = GetDocument(); + + if ( data ) + { + data->Stamp( p, encoding ); + location = data->Cursor(); + } + + const char* const startTag = "<![CDATA["; + const char* const endTag = "]]>"; + + if ( cdata || StringEqual( p, startTag, false, encoding ) ) + { + cdata = true; + + if ( !StringEqual( p, startTag, false, encoding ) ) + { + if ( document ) + document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding ); + return 0; + } + p += strlen( startTag ); + + // Keep all the white space, ignore the encoding, etc. + while ( p && *p + && !StringEqual( p, endTag, false, encoding ) + ) + { + value += *p; + ++p; + } + + TIXML_STRING dummy; + p = ReadText( p, &dummy, false, endTag, false, encoding ); + return p; + } + else + { + bool ignoreWhite = true; + + const char* end = "<"; + p = ReadText( p, &value, ignoreWhite, end, false, encoding ); + if ( p && *p ) + return p-1; // don't truncate the '<' + return 0; + } +} + +#ifdef TIXML_USE_STL +void TiXmlDeclaration::StreamIn( std::istream * in, TIXML_STRING * tag ) +{ + while ( in->good() ) + { + int c = in->get(); + if ( c <= 0 ) + { + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + (*tag) += (char) c; + + if ( c == '>' ) + { + // All is well. + return; + } + } +} +#endif + +const char* TiXmlDeclaration::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding _encoding ) +{ + p = SkipWhiteSpace( p, _encoding ); + // Find the beginning, find the end, and look for + // the stuff in-between. + TiXmlDocument* document = GetDocument(); + if ( !p || !*p || !StringEqual( p, "<?xml", true, _encoding ) ) + { + if ( document ) document->SetError( TIXML_ERROR_PARSING_DECLARATION, 0, 0, _encoding ); + return 0; + } + if ( data ) + { + data->Stamp( p, _encoding ); + location = data->Cursor(); + } + p += 5; + + version = ""; + encoding = ""; + standalone = ""; + + while ( p && *p ) + { + if ( *p == '>' ) + { + ++p; + return p; + } + + p = SkipWhiteSpace( p, _encoding ); + if ( StringEqual( p, "version", true, _encoding ) ) + { + TiXmlAttribute attrib; + p = attrib.Parse( p, data, _encoding ); + version = attrib.Value(); + } + else if ( StringEqual( p, "encoding", true, _encoding ) ) + { + TiXmlAttribute attrib; + p = attrib.Parse( p, data, _encoding ); + encoding = attrib.Value(); + } + else if ( StringEqual( p, "standalone", true, _encoding ) ) + { + TiXmlAttribute attrib; + p = attrib.Parse( p, data, _encoding ); + standalone = attrib.Value(); + } + else + { + // Read over whatever it is. + while( p && *p && *p != '>' && !IsWhiteSpace( *p ) ) + ++p; + } + } + return 0; +} + +bool TiXmlText::Blank() const +{ + for ( unsigned i=0; i<value.length(); i++ ) + if ( !IsWhiteSpace( value[i] ) ) + return false; + return true; +} + Index: /branches/fep_rpc_client/tinyxml/tinyxml.cpp =================================================================== --- /branches/fep_rpc_client/tinyxml/tinyxml.cpp (revision 79) +++ /branches/fep_rpc_client/tinyxml/tinyxml.cpp (revision 79) @@ -0,0 +1,1886 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code by Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + +#include <ctype.h> + +#ifdef TIXML_USE_STL +#include <sstream> +#include <iostream> +#endif + +#include "tinyxml.h" + +FILE* TiXmlFOpen( const char* filename, const char* mode ); + +bool TiXmlBase::condenseWhiteSpace = true; + +// Microsoft compiler security +FILE* TiXmlFOpen( const char* filename, const char* mode ) +{ + #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) + FILE* fp = 0; + errno_t err = fopen_s( &fp, filename, mode ); + if ( !err && fp ) + return fp; + return 0; + #else + return fopen( filename, mode ); + #endif +} + +void TiXmlBase::EncodeString( const TIXML_STRING& str, TIXML_STRING* outString ) +{ + int i=0; + + while( i<(int)str.length() ) + { + unsigned char c = (unsigned char) str[i]; + + if ( c == '&' + && i < ( (int)str.length() - 2 ) + && str[i+1] == '#' + && str[i+2] == 'x' ) + { + // Hexadecimal character reference. + // Pass through unchanged. + // © -- copyright symbol, for example. + // + // The -1 is a bug fix from Rob Laveaux. It keeps + // an overflow from happening if there is no ';'. + // There are actually 2 ways to exit this loop - + // while fails (error case) and break (semicolon found). + // However, there is no mechanism (currently) for + // this function to return an error. + while ( i<(int)str.length()-1 ) + { + outString->append( str.c_str() + i, 1 ); + ++i; + if ( str[i] == ';' ) + break; + } + } + else if ( c == '&' ) + { + outString->append( entity[0].str, entity[0].strLength ); + ++i; + } + else if ( c == '<' ) + { + outString->append( entity[1].str, entity[1].strLength ); + ++i; + } + else if ( c == '>' ) + { + outString->append( entity[2].str, entity[2].strLength ); + ++i; + } + else if ( c == '\"' ) + { + outString->append( entity[3].str, entity[3].strLength ); + ++i; + } + else if ( c == '\'' ) + { + outString->append( entity[4].str, entity[4].strLength ); + ++i; + } + else if ( c < 32 ) + { + // Easy pass at non-alpha/numeric/symbol + // Below 32 is symbolic. + char buf[ 32 ]; + + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF( buf, sizeof(buf), "&#x%02X;", (unsigned) ( c & 0xff ) ); + #else + sprintf( buf, "&#x%02X;", (unsigned) ( c & 0xff ) ); + #endif + + //*ME: warning C4267: convert 'size_t' to 'int' + //*ME: Int-Cast to make compiler happy ... + outString->append( buf, (int)strlen( buf ) ); + ++i; + } + else + { + //char realc = (char) c; + //outString->append( &realc, 1 ); + *outString += (char) c; // somewhat more efficient function call. + ++i; + } + } +} + + +TiXmlNode::TiXmlNode( NodeType _type ) : TiXmlBase() +{ + parent = 0; + type = _type; + firstChild = 0; + lastChild = 0; + prev = 0; + next = 0; +} + + +TiXmlNode::~TiXmlNode() +{ + TiXmlNode* node = firstChild; + TiXmlNode* temp = 0; + + while ( node ) + { + temp = node; + node = node->next; + delete temp; + } +} + + +void TiXmlNode::CopyTo( TiXmlNode* target ) const +{ + target->SetValue (value.c_str() ); + target->userData = userData; + target->location = location; +} + + +void TiXmlNode::Clear() +{ + TiXmlNode* node = firstChild; + TiXmlNode* temp = 0; + + while ( node ) + { + temp = node; + node = node->next; + delete temp; + } + + firstChild = 0; + lastChild = 0; +} + + +TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node ) +{ + assert( node->parent == 0 || node->parent == this ); + assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() ); + + if ( node->Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + delete node; + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + node->parent = this; + + node->prev = lastChild; + node->next = 0; + + if ( lastChild ) + lastChild->next = node; + else + firstChild = node; // it was an empty list. + + lastChild = node; + return node; +} + + +TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis ) +{ + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + TiXmlNode* node = addThis.Clone(); + if ( !node ) + return 0; + + return LinkEndChild( node ); +} + + +TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis ) +{ + if ( !beforeThis || beforeThis->parent != this ) { + return 0; + } + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + TiXmlNode* node = addThis.Clone(); + if ( !node ) + return 0; + node->parent = this; + + node->next = beforeThis; + node->prev = beforeThis->prev; + if ( beforeThis->prev ) + { + beforeThis->prev->next = node; + } + else + { + assert( firstChild == beforeThis ); + firstChild = node; + } + beforeThis->prev = node; + return node; +} + + +TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis ) +{ + if ( !afterThis || afterThis->parent != this ) { + return 0; + } + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + TiXmlNode* node = addThis.Clone(); + if ( !node ) + return 0; + node->parent = this; + + node->prev = afterThis; + node->next = afterThis->next; + if ( afterThis->next ) + { + afterThis->next->prev = node; + } + else + { + assert( lastChild == afterThis ); + lastChild = node; + } + afterThis->next = node; + return node; +} + + +TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis ) +{ + if ( !replaceThis ) + return 0; + + if ( replaceThis->parent != this ) + return 0; + + if ( withThis.ToDocument() ) { + // A document can never be a child. Thanks to Noam. + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + TiXmlNode* node = withThis.Clone(); + if ( !node ) + return 0; + + node->next = replaceThis->next; + node->prev = replaceThis->prev; + + if ( replaceThis->next ) + replaceThis->next->prev = node; + else + lastChild = node; + + if ( replaceThis->prev ) + replaceThis->prev->next = node; + else + firstChild = node; + + delete replaceThis; + node->parent = this; + return node; +} + + +bool TiXmlNode::RemoveChild( TiXmlNode* removeThis ) +{ + if ( !removeThis ) { + return false; + } + + if ( removeThis->parent != this ) + { + assert( 0 ); + return false; + } + + if ( removeThis->next ) + removeThis->next->prev = removeThis->prev; + else + lastChild = removeThis->prev; + + if ( removeThis->prev ) + removeThis->prev->next = removeThis->next; + else + firstChild = removeThis->next; + + delete removeThis; + return true; +} + +const TiXmlNode* TiXmlNode::FirstChild( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = firstChild; node; node = node->next ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::LastChild( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = lastChild; node; node = node->prev ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const +{ + if ( !previous ) + { + return FirstChild(); + } + else + { + assert( previous->parent == this ); + return previous->NextSibling(); + } +} + + +const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const +{ + if ( !previous ) + { + return FirstChild( val ); + } + else + { + assert( previous->parent == this ); + return previous->NextSibling( val ); + } +} + + +const TiXmlNode* TiXmlNode::NextSibling( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = next; node; node = node->next ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::PreviousSibling( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = prev; node; node = node->prev ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +void TiXmlElement::RemoveAttribute( const char * name ) +{ + #ifdef TIXML_USE_STL + TIXML_STRING str( name ); + TiXmlAttribute* node = attributeSet.Find( str ); + #else + TiXmlAttribute* node = attributeSet.Find( name ); + #endif + if ( node ) + { + attributeSet.Remove( node ); + delete node; + } +} + +const TiXmlElement* TiXmlNode::FirstChildElement() const +{ + const TiXmlNode* node; + + for ( node = FirstChild(); + node; + node = node->NextSibling() ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const +{ + const TiXmlNode* node; + + for ( node = FirstChild( _value ); + node; + node = node->NextSibling( _value ) ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlElement* TiXmlNode::NextSiblingElement() const +{ + const TiXmlNode* node; + + for ( node = NextSibling(); + node; + node = node->NextSibling() ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const +{ + const TiXmlNode* node; + + for ( node = NextSibling( _value ); + node; + node = node->NextSibling( _value ) ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlDocument* TiXmlNode::GetDocument() const +{ + const TiXmlNode* node; + + for( node = this; node; node = node->parent ) + { + if ( node->ToDocument() ) + return node->ToDocument(); + } + return 0; +} + + +TiXmlElement::TiXmlElement (const char * _value) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) +{ + firstChild = lastChild = 0; + value = _value; +} + + +#ifdef TIXML_USE_STL +TiXmlElement::TiXmlElement( const std::string& _value ) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) +{ + firstChild = lastChild = 0; + value = _value; +} +#endif + + +TiXmlElement::TiXmlElement( const TiXmlElement& copy) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) +{ + firstChild = lastChild = 0; + copy.CopyTo( this ); +} + + +TiXmlElement& TiXmlElement::operator=( const TiXmlElement& base ) +{ + ClearThis(); + base.CopyTo( this ); + return *this; +} + + +TiXmlElement::~TiXmlElement() +{ + ClearThis(); +} + + +void TiXmlElement::ClearThis() +{ + Clear(); + while( attributeSet.First() ) + { + TiXmlAttribute* node = attributeSet.First(); + attributeSet.Remove( node ); + delete node; + } +} + + +const char* TiXmlElement::Attribute( const char* name ) const +{ + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( node ) + return node->Value(); + return 0; +} + + +#ifdef TIXML_USE_STL +const std::string* TiXmlElement::Attribute( const std::string& name ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( attrib ) + return &attrib->ValueStr(); + return 0; +} +#endif + + +const char* TiXmlElement::Attribute( const char* name, int* i ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const char* result = 0; + + if ( attrib ) { + result = attrib->Value(); + if ( i ) { + attrib->QueryIntValue( i ); + } + } + return result; +} + + +#ifdef TIXML_USE_STL +const std::string* TiXmlElement::Attribute( const std::string& name, int* i ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const std::string* result = 0; + + if ( attrib ) { + result = &attrib->ValueStr(); + if ( i ) { + attrib->QueryIntValue( i ); + } + } + return result; +} +#endif + + +const char* TiXmlElement::Attribute( const char* name, double* d ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const char* result = 0; + + if ( attrib ) { + result = attrib->Value(); + if ( d ) { + attrib->QueryDoubleValue( d ); + } + } + return result; +} + + +#ifdef TIXML_USE_STL +const std::string* TiXmlElement::Attribute( const std::string& name, double* d ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const std::string* result = 0; + + if ( attrib ) { + result = &attrib->ValueStr(); + if ( d ) { + attrib->QueryDoubleValue( d ); + } + } + return result; +} +#endif + + +int TiXmlElement::QueryIntAttribute( const char* name, int* ival ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryIntValue( ival ); +} + + +int TiXmlElement::QueryUnsignedAttribute( const char* name, unsigned* value ) const +{ + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( !node ) + return TIXML_NO_ATTRIBUTE; + + int ival = 0; + int result = node->QueryIntValue( &ival ); + *value = (unsigned)ival; + return result; +} + + +int TiXmlElement::QueryBoolAttribute( const char* name, bool* bval ) const +{ + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( !node ) + return TIXML_NO_ATTRIBUTE; + + int result = TIXML_WRONG_TYPE; + if ( StringEqual( node->Value(), "true", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "yes", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "1", true, TIXML_ENCODING_UNKNOWN ) ) + { + *bval = true; + result = TIXML_SUCCESS; + } + else if ( StringEqual( node->Value(), "false", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "no", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "0", true, TIXML_ENCODING_UNKNOWN ) ) + { + *bval = false; + result = TIXML_SUCCESS; + } + return result; +} + + + +#ifdef TIXML_USE_STL +int TiXmlElement::QueryIntAttribute( const std::string& name, int* ival ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryIntValue( ival ); +} +#endif + + +int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryDoubleValue( dval ); +} + + +#ifdef TIXML_USE_STL +int TiXmlElement::QueryDoubleAttribute( const std::string& name, double* dval ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryDoubleValue( dval ); +} +#endif + + +void TiXmlElement::SetAttribute( const char * name, int val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetIntValue( val ); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetAttribute( const std::string& name, int val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetIntValue( val ); + } +} +#endif + + +void TiXmlElement::SetDoubleAttribute( const char * name, double val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetDoubleValue( val ); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetDoubleAttribute( const std::string& name, double val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetDoubleValue( val ); + } +} +#endif + + +void TiXmlElement::SetAttribute( const char * cname, const char * cvalue ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( cname ); + if ( attrib ) { + attrib->SetValue( cvalue ); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetAttribute( const std::string& _name, const std::string& _value ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( _name ); + if ( attrib ) { + attrib->SetValue( _value ); + } +} +#endif + + +void TiXmlElement::Print( FILE* cfile, int depth ) const +{ + int i; + assert( cfile ); + for ( i=0; i<depth; i++ ) { + fprintf( cfile, " " ); + } + + fprintf( cfile, "<%s", value.c_str() ); + + const TiXmlAttribute* attrib; + for ( attrib = attributeSet.First(); attrib; attrib = attrib->Next() ) + { + fprintf( cfile, " " ); + attrib->Print( cfile, depth ); + } + + // There are 3 different formatting approaches: + // 1) An element without children is printed as a <foo /> node + // 2) An element with only a text child is printed as <foo> text </foo> + // 3) An element with children is printed on multiple lines. + TiXmlNode* node; + if ( !firstChild ) + { + fprintf( cfile, " />" ); + } + else if ( firstChild == lastChild && firstChild->ToText() ) + { + fprintf( cfile, ">" ); + firstChild->Print( cfile, depth + 1 ); + fprintf( cfile, "</%s>", value.c_str() ); + } + else + { + fprintf( cfile, ">" ); + + for ( node = firstChild; node; node=node->NextSibling() ) + { + if ( !node->ToText() ) + { + fprintf( cfile, "\n" ); + } + node->Print( cfile, depth+1 ); + } + fprintf( cfile, "\n" ); + for( i=0; i<depth; ++i ) { + fprintf( cfile, " " ); + } + fprintf( cfile, "</%s>", value.c_str() ); + } +} + + +void TiXmlElement::CopyTo( TiXmlElement* target ) const +{ + // superclass: + TiXmlNode::CopyTo( target ); + + // Element class: + // Clone the attributes, then clone the children. + const TiXmlAttribute* attribute = 0; + for( attribute = attributeSet.First(); + attribute; + attribute = attribute->Next() ) + { + target->SetAttribute( attribute->Name(), attribute->Value() ); + } + + TiXmlNode* node = 0; + for ( node = firstChild; node; node = node->NextSibling() ) + { + target->LinkEndChild( node->Clone() ); + } +} + +bool TiXmlElement::Accept( TiXmlVisitor* visitor ) const +{ + if ( visitor->VisitEnter( *this, attributeSet.First() ) ) + { + for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() ) + { + if ( !node->Accept( visitor ) ) + break; + } + } + return visitor->VisitExit( *this ); +} + + +TiXmlNode* TiXmlElement::Clone() const +{ + TiXmlElement* clone = new TiXmlElement( Value() ); + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +const char* TiXmlElement::GetText() const +{ + const TiXmlNode* child = this->FirstChild(); + if ( child ) { + const TiXmlText* childText = child->ToText(); + if ( childText ) { + return childText->Value(); + } + } + return 0; +} + + +TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + tabsize = 4; + useMicrosoftBOM = false; + ClearError(); +} + +TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + tabsize = 4; + useMicrosoftBOM = false; + value = documentName; + ClearError(); +} + + +#ifdef TIXML_USE_STL +TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + tabsize = 4; + useMicrosoftBOM = false; + value = documentName; + ClearError(); +} +#endif + + +TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + copy.CopyTo( this ); +} + + +TiXmlDocument& TiXmlDocument::operator=( const TiXmlDocument& copy ) +{ + Clear(); + copy.CopyTo( this ); + return *this; +} + + +bool TiXmlDocument::LoadFile( TiXmlEncoding encoding ) +{ + return LoadFile( Value(), encoding ); +} + + +bool TiXmlDocument::SaveFile() const +{ + return SaveFile( Value() ); +} + +bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding ) +{ + TIXML_STRING filename( _filename ); + value = filename; + + // reading in binary mode so that tinyxml can normalize the EOL + FILE* file = TiXmlFOpen( value.c_str (), "rb" ); + + if ( file ) + { + bool result = LoadFile( file, encoding ); + fclose( file ); + return result; + } + else + { + SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } +} + +bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding ) +{ + if ( !file ) + { + SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } + + // Delete the existing data: + Clear(); + location.Clear(); + + // Get the file size, so we can pre-allocate the string. HUGE speed impact. + long length = 0; + fseek( file, 0, SEEK_END ); + length = ftell( file ); + fseek( file, 0, SEEK_SET ); + + // Strange case, but good to handle up front. + if ( length <= 0 ) + { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } + + // Subtle bug here. TinyXml did use fgets. But from the XML spec: + // 2.11 End-of-Line Handling + // <snip> + // <quote> + // ...the XML processor MUST behave as if it normalized all line breaks in external + // parsed entities (including the document entity) on input, before parsing, by translating + // both the two-character sequence #xD #xA and any #xD that is not followed by #xA to + // a single #xA character. + // </quote> + // + // It is not clear fgets does that, and certainly isn't clear it works cross platform. + // Generally, you expect fgets to translate from the convention of the OS to the c/unix + // convention, and not work generally. + + /* + while( fgets( buf, sizeof(buf), file ) ) + { + data += buf; + } + */ + + char* buf = new char[ length+1 ]; + buf[0] = 0; + + if ( fread( buf, length, 1, file ) != 1 ) { + delete [] buf; + SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } + + // Process the buffer in place to normalize new lines. (See comment above.) + // Copies from the 'p' to 'q' pointer, where p can advance faster if + // a newline-carriage return is hit. + // + // Wikipedia: + // Systems based on ASCII or a compatible character set use either LF (Line feed, '\n', 0x0A, 10 in decimal) or + // CR (Carriage return, '\r', 0x0D, 13 in decimal) individually, or CR followed by LF (CR+LF, 0x0D 0x0A)... + // * LF: Multics, Unix and Unix-like systems (GNU/Linux, AIX, Xenix, Mac OS X, FreeBSD, etc.), BeOS, Amiga, RISC OS, and others + // * CR+LF: DEC RT-11 and most other early non-Unix, non-IBM OSes, CP/M, MP/M, DOS, OS/2, Microsoft Windows, Symbian OS + // * CR: Commodore 8-bit machines, Apple II family, Mac OS up to version 9 and OS-9 + + const char* p = buf; // the read head + char* q = buf; // the write head + const char CR = 0x0d; + const char LF = 0x0a; + + buf[length] = 0; + while( *p ) { + assert( p < (buf+length) ); + assert( q <= (buf+length) ); + assert( q <= p ); + + if ( *p == CR ) { + *q++ = LF; + p++; + if ( *p == LF ) { // check for CR+LF (and skip LF) + p++; + } + } + else { + *q++ = *p++; + } + } + assert( q <= (buf+length) ); + *q = 0; + + Parse( buf, 0, encoding ); + + delete [] buf; + return !Error(); +} + + +bool TiXmlDocument::SaveFile( const char * filename ) const +{ + // The old c stuff lives on... + FILE* fp = TiXmlFOpen( filename, "w" ); + if ( fp ) + { + bool result = SaveFile( fp ); + fclose( fp ); + return result; + } + return false; +} + + +bool TiXmlDocument::SaveFile( FILE* fp ) const +{ + if ( useMicrosoftBOM ) + { + const unsigned char TIXML_UTF_LEAD_0 = 0xefU; + const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; + const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; + + fputc( TIXML_UTF_LEAD_0, fp ); + fputc( TIXML_UTF_LEAD_1, fp ); + fputc( TIXML_UTF_LEAD_2, fp ); + } + Print( fp, 0 ); + return (ferror(fp) == 0); +} + + +void TiXmlDocument::CopyTo( TiXmlDocument* target ) const +{ + TiXmlNode::CopyTo( target ); + + target->error = error; + target->errorId = errorId; + target->errorDesc = errorDesc; + target->tabsize = tabsize; + target->errorLocation = errorLocation; + target->useMicrosoftBOM = useMicrosoftBOM; + + TiXmlNode* node = 0; + for ( node = firstChild; node; node = node->NextSibling() ) + { + target->LinkEndChild( node->Clone() ); + } +} + + +TiXmlNode* TiXmlDocument::Clone() const +{ + TiXmlDocument* clone = new TiXmlDocument(); + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +void TiXmlDocument::Print( FILE* cfile, int depth ) const +{ + assert( cfile ); + for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() ) + { + node->Print( cfile, depth ); + fprintf( cfile, "\n" ); + } +} + + +bool TiXmlDocument::Accept( TiXmlVisitor* visitor ) const +{ + if ( visitor->VisitEnter( *this ) ) + { + for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() ) + { + if ( !node->Accept( visitor ) ) + break; + } + } + return visitor->VisitExit( *this ); +} + + +const TiXmlAttribute* TiXmlAttribute::Next() const +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( next->value.empty() && next->name.empty() ) + return 0; + return next; +} + +/* +TiXmlAttribute* TiXmlAttribute::Next() +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( next->value.empty() && next->name.empty() ) + return 0; + return next; +} +*/ + +const TiXmlAttribute* TiXmlAttribute::Previous() const +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( prev->value.empty() && prev->name.empty() ) + return 0; + return prev; +} + +/* +TiXmlAttribute* TiXmlAttribute::Previous() +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( prev->value.empty() && prev->name.empty() ) + return 0; + return prev; +} +*/ + +void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const +{ + TIXML_STRING n, v; + + EncodeString( name, &n ); + EncodeString( value, &v ); + + if (value.find ('\"') == TIXML_STRING::npos) { + if ( cfile ) { + fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() ); + } + if ( str ) { + (*str) += n; (*str) += "=\""; (*str) += v; (*str) += "\""; + } + } + else { + if ( cfile ) { + fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() ); + } + if ( str ) { + (*str) += n; (*str) += "='"; (*str) += v; (*str) += "'"; + } + } +} + + +int TiXmlAttribute::QueryIntValue( int* ival ) const +{ + if ( TIXML_SSCANF( value.c_str(), "%d", ival ) == 1 ) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; +} + +int TiXmlAttribute::QueryDoubleValue( double* dval ) const +{ + if ( TIXML_SSCANF( value.c_str(), "%lf", dval ) == 1 ) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; +} + +void TiXmlAttribute::SetIntValue( int _value ) +{ + char buf [64]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF(buf, sizeof(buf), "%d", _value); + #else + sprintf (buf, "%d", _value); + #endif + SetValue (buf); +} + +void TiXmlAttribute::SetDoubleValue( double _value ) +{ + char buf [256]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF( buf, sizeof(buf), "%g", _value); + #else + sprintf (buf, "%g", _value); + #endif + SetValue (buf); +} + +int TiXmlAttribute::IntValue() const +{ + return atoi (value.c_str ()); +} + +double TiXmlAttribute::DoubleValue() const +{ + return atof (value.c_str ()); +} + + +TiXmlComment::TiXmlComment( const TiXmlComment& copy ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) +{ + copy.CopyTo( this ); +} + + +TiXmlComment& TiXmlComment::operator=( const TiXmlComment& base ) +{ + Clear(); + base.CopyTo( this ); + return *this; +} + + +void TiXmlComment::Print( FILE* cfile, int depth ) const +{ + assert( cfile ); + for ( int i=0; i<depth; i++ ) + { + fprintf( cfile, " " ); + } + fprintf( cfile, "", value.c_str() ); +} + + +void TiXmlComment::CopyTo( TiXmlComment* target ) const +{ + TiXmlNode::CopyTo( target ); +} + + +bool TiXmlComment::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlComment::Clone() const +{ + TiXmlComment* clone = new TiXmlComment(); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +void TiXmlText::Print( FILE* cfile, int depth ) const +{ + assert( cfile ); + if ( cdata ) + { + int i; + fprintf( cfile, "\n" ); + for ( i=0; i<depth; i++ ) { + fprintf( cfile, " " ); + } + fprintf( cfile, "<![CDATA[%s]]>\n", value.c_str() ); // unformatted output + } + else + { + TIXML_STRING buffer; + EncodeString( value, &buffer ); + fprintf( cfile, "%s", buffer.c_str() ); + } +} + + +void TiXmlText::CopyTo( TiXmlText* target ) const +{ + TiXmlNode::CopyTo( target ); + target->cdata = cdata; +} + + +bool TiXmlText::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlText::Clone() const +{ + TiXmlText* clone = 0; + clone = new TiXmlText( "" ); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +TiXmlDeclaration::TiXmlDeclaration( const char * _version, + const char * _encoding, + const char * _standalone ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) +{ + version = _version; + encoding = _encoding; + standalone = _standalone; +} + + +#ifdef TIXML_USE_STL +TiXmlDeclaration::TiXmlDeclaration( const std::string& _version, + const std::string& _encoding, + const std::string& _standalone ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) +{ + version = _version; + encoding = _encoding; + standalone = _standalone; +} +#endif + + +TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) +{ + copy.CopyTo( this ); +} + + +TiXmlDeclaration& TiXmlDeclaration::operator=( const TiXmlDeclaration& copy ) +{ + Clear(); + copy.CopyTo( this ); + return *this; +} + + +void TiXmlDeclaration::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const +{ + if ( cfile ) fprintf( cfile, "<?xml " ); + if ( str ) (*str) += "<?xml "; + + if ( !version.empty() ) { + if ( cfile ) fprintf (cfile, "version=\"%s\" ", version.c_str ()); + if ( str ) { (*str) += "version=\""; (*str) += version; (*str) += "\" "; } + } + if ( !encoding.empty() ) { + if ( cfile ) fprintf (cfile, "encoding=\"%s\" ", encoding.c_str ()); + if ( str ) { (*str) += "encoding=\""; (*str) += encoding; (*str) += "\" "; } + } + if ( !standalone.empty() ) { + if ( cfile ) fprintf (cfile, "standalone=\"%s\" ", standalone.c_str ()); + if ( str ) { (*str) += "standalone=\""; (*str) += standalone; (*str) += "\" "; } + } + if ( cfile ) fprintf( cfile, "?>" ); + if ( str ) (*str) += "?>"; +} + + +void TiXmlDeclaration::CopyTo( TiXmlDeclaration* target ) const +{ + TiXmlNode::CopyTo( target ); + + target->version = version; + target->encoding = encoding; + target->standalone = standalone; +} + + +bool TiXmlDeclaration::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlDeclaration::Clone() const +{ + TiXmlDeclaration* clone = new TiXmlDeclaration(); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +void TiXmlUnknown::Print( FILE* cfile, int depth ) const +{ + for ( int i=0; i<depth; i++ ) + fprintf( cfile, " " ); + fprintf( cfile, "<%s>", value.c_str() ); +} + + +void TiXmlUnknown::CopyTo( TiXmlUnknown* target ) const +{ + TiXmlNode::CopyTo( target ); +} + + +bool TiXmlUnknown::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlUnknown::Clone() const +{ + TiXmlUnknown* clone = new TiXmlUnknown(); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +TiXmlAttributeSet::TiXmlAttributeSet() +{ + sentinel.next = &sentinel; + sentinel.prev = &sentinel; +} + + +TiXmlAttributeSet::~TiXmlAttributeSet() +{ + assert( sentinel.next == &sentinel ); + assert( sentinel.prev == &sentinel ); +} + + +void TiXmlAttributeSet::Add( TiXmlAttribute* addMe ) +{ + #ifdef TIXML_USE_STL + assert( !Find( TIXML_STRING( addMe->Name() ) ) ); // Shouldn't be multiply adding to the set. + #else + assert( !Find( addMe->Name() ) ); // Shouldn't be multiply adding to the set. + #endif + + addMe->next = &sentinel; + addMe->prev = sentinel.prev; + + sentinel.prev->next = addMe; + sentinel.prev = addMe; +} + +void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe ) +{ + TiXmlAttribute* node; + + for( node = sentinel.next; node != &sentinel; node = node->next ) + { + if ( node == removeMe ) + { + node->prev->next = node->next; + node->next->prev = node->prev; + node->next = 0; + node->prev = 0; + return; + } + } + assert( 0 ); // we tried to remove a non-linked attribute. +} + + +#ifdef TIXML_USE_STL +TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const +{ + for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) + { + if ( node->name == name ) + return node; + } + return 0; +} + +TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const std::string& _name ) +{ + TiXmlAttribute* attrib = Find( _name ); + if ( !attrib ) { + attrib = new TiXmlAttribute(); + Add( attrib ); + attrib->SetName( _name ); + } + return attrib; +} +#endif + + +TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const +{ + for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) + { + if ( strcmp( node->name.c_str(), name ) == 0 ) + return node; + } + return 0; +} + + +TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const char* _name ) +{ + TiXmlAttribute* attrib = Find( _name ); + if ( !attrib ) { + attrib = new TiXmlAttribute(); + Add( attrib ); + attrib->SetName( _name ); + } + return attrib; +} + + +#ifdef TIXML_USE_STL +std::istream& operator>> (std::istream & in, TiXmlNode & base) +{ + TIXML_STRING tag; + tag.reserve( 8 * 1000 ); + base.StreamIn( &in, &tag ); + + base.Parse( tag.c_str(), 0, TIXML_DEFAULT_ENCODING ); + return in; +} +#endif + + +#ifdef TIXML_USE_STL +std::ostream& operator<< (std::ostream & out, const TiXmlNode & base) +{ + TiXmlPrinter printer; + printer.SetStreamPrinting(); + base.Accept( &printer ); + out << printer.Str(); + + return out; +} + + +std::string& operator<< (std::string& out, const TiXmlNode& base ) +{ + TiXmlPrinter printer; + printer.SetStreamPrinting(); + base.Accept( &printer ); + out.append( printer.Str() ); + + return out; +} +#endif + + +TiXmlHandle TiXmlHandle::FirstChild() const +{ + if ( node ) + { + TiXmlNode* child = node->FirstChild(); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::FirstChild( const char * value ) const +{ + if ( node ) + { + TiXmlNode* child = node->FirstChild( value ); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::FirstChildElement() const +{ + if ( node ) + { + TiXmlElement* child = node->FirstChildElement(); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::FirstChildElement( const char * value ) const +{ + if ( node ) + { + TiXmlElement* child = node->FirstChildElement( value ); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::Child( int count ) const +{ + if ( node ) + { + int i; + TiXmlNode* child = node->FirstChild(); + for ( i=0; + child && i<count; + child = child->NextSibling(), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::Child( const char* value, int count ) const +{ + if ( node ) + { + int i; + TiXmlNode* child = node->FirstChild( value ); + for ( i=0; + child && i<count; + child = child->NextSibling( value ), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::ChildElement( int count ) const +{ + if ( node ) + { + int i; + TiXmlElement* child = node->FirstChildElement(); + for ( i=0; + child && i<count; + child = child->NextSiblingElement(), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::ChildElement( const char* value, int count ) const +{ + if ( node ) + { + int i; + TiXmlElement* child = node->FirstChildElement( value ); + for ( i=0; + child && i<count; + child = child->NextSiblingElement( value ), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +bool TiXmlPrinter::VisitEnter( const TiXmlDocument& ) +{ + return true; +} + +bool TiXmlPrinter::VisitExit( const TiXmlDocument& ) +{ + return true; +} + +bool TiXmlPrinter::VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute ) +{ + DoIndent(); + buffer += "<"; + buffer += element.Value(); + + for( const TiXmlAttribute* attrib = firstAttribute; attrib; attrib = attrib->Next() ) + { + buffer += " "; + attrib->Print( 0, 0, &buffer ); + } + + if ( !element.FirstChild() ) + { + buffer += " />"; + DoLineBreak(); + } + else + { + buffer += ">"; + if ( element.FirstChild()->ToText() + && element.LastChild() == element.FirstChild() + && element.FirstChild()->ToText()->CDATA() == false ) + { + simpleTextPrint = true; + // no DoLineBreak()! + } + else + { + DoLineBreak(); + } + } + ++depth; + return true; +} + + +bool TiXmlPrinter::VisitExit( const TiXmlElement& element ) +{ + --depth; + if ( !element.FirstChild() ) + { + // nothing. + } + else + { + if ( simpleTextPrint ) + { + simpleTextPrint = false; + } + else + { + DoIndent(); + } + buffer += "</"; + buffer += element.Value(); + buffer += ">"; + DoLineBreak(); + } + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlText& text ) +{ + if ( text.CDATA() ) + { + DoIndent(); + buffer += "<![CDATA["; + buffer += text.Value(); + buffer += "]]>"; + DoLineBreak(); + } + else if ( simpleTextPrint ) + { + TIXML_STRING str; + TiXmlBase::EncodeString( text.ValueTStr(), &str ); + buffer += str; + } + else + { + DoIndent(); + TIXML_STRING str; + TiXmlBase::EncodeString( text.ValueTStr(), &str ); + buffer += str; + DoLineBreak(); + } + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlDeclaration& declaration ) +{ + DoIndent(); + declaration.Print( 0, 0, &buffer ); + DoLineBreak(); + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlComment& comment ) +{ + DoIndent(); + buffer += ""; + DoLineBreak(); + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlUnknown& unknown ) +{ + DoIndent(); + buffer += "<"; + buffer += unknown.Value(); + buffer += ">"; + DoLineBreak(); + return true; +} + Index: /branches/fep_rpc_client/network.h =================================================================== --- /branches/fep_rpc_client/network.h (revision 77) +++ /branches/fep_rpc_client/network.h (revision 79) @@ -11,4 +11,5 @@ const int Fixed_Byte_To_Checksum = 25; // the first byte is not considered in the calculation of "BYTE 2" const int CONTROL_DATA_LEN = 27; + char * const dp5[8] = { "ML_1", "ML_2", "ML_3", "ML_4", "ML_5", "ML_6", "HOV_Lane", "FYW_Conn"}; @@ -20,35 +21,30 @@ "SD_6", "Pass_Vol_Count", "X"}; -/*** NETWORK STRUCTS ***/ -typedef struct loopagg LOOPAGG; -struct loopagg -{ - int index; - char lane; // how namy lanes at the detector station - long time; - int interval; - int g_vol; - float g_occ; - double g_spd; - int *vol; - float *occ; - double *spd; -}; - // FEP line: has several lds typedef struct fep_line FEP_LINE; struct fep_line { - int lineNum; - vector<long> lds; - vector<long> ldsIndex; // location in ldsMap - short ldsNum; // actual number of lds on the line + int lineNum; + vector<long> lds; + vector<long> ldsIndex; // location in ldsMap - short count; // actual count from caltrans - int schedule; - int lineInfo; + short count; // actual count from caltrans + int schedule; + int lineInfo; long systemKey; long globalSeq; long schedleSeq; +}; + +// Loop detector +typedef struct loop LOOP; +struct loop +{ + long loopID; + char *loop_loc; + + int vol; + float occ; + double spd; }; @@ -61,8 +57,6 @@ short line_num; short drop; - - int num; // number of loops - long *loopID; - char **loop_loc; + + vector<LOOP*> loops; // LDS data @@ -74,3 +68,11 @@ }; +typedef struct volOcc VOLOCC; +struct volOcc +{ + char high; + char low; +}; + + #endif Index: /branches/fep_rpc_client/DataPacker.cpp =================================================================== --- /branches/fep_rpc_client/DataPacker.cpp (revision 79) +++ /branches/fep_rpc_client/DataPacker.cpp (revision 79) @@ -0,0 +1,266 @@ +#include "DataPacker.h"; + +unsigned char * DataPacker::msg; + +unsigned char * DataPacker::packData(LDS_LOOP *station) { + int pos = 26; + DataPacker packer; + msg = packer.staticDataPack(station); + pos = packer.dynamicDataPack(station, 5, pos); + pos = packer.dynamicDataPack(station, 6, pos); + pos = packer.dynamicDataPack(station, 7, pos); + pos = packer.dynamicDataPack(station, 8, pos); + // Update data for BYTE 9, 16, 21, 22, 23, 24 + + // what is the current metering rate? + // check each LDS, if there is demand detector, the downstream node the + // ldsMap[i].dataPack[22-1] = ldsMap[i].dataPack[9-1] = ; + + // will need to check if queue override is enabled (Currently, no queue + // ldsMap[i].dataPack[16-1] = ; + + // byte 23: MAINLINE total volume + msg[23 - 1] = station->MlTotVol; + + // byte 24: opposite total volume + msg[24 - 1] = station->OppTotVol; + + // last BYTE: checksum + msg[station->length - 1] = + packer.chksum(msg, station->length - 1 - 1); + + /* + for (int j = 0; j < station->length; j++) { + printf("%02X", msg[j]); + } + printf("\n"); + */ +} + +int DataPacker::dynamicDataPack(LDS_LOOP *station, int packNo, int pos) { + int i, j, vol, occ, haveData; + //used for data byte 23 and 24 + station->MlTotVol = 0; + station->OppTotVol = 0; + + for (j = 1; j <= 8; j++) { + + if (DataAvail(msg[packNo - 1], j)) { + // loop at bit j has data + for (int lane = 0; lane < station->loops.size(); lane++) { + // what's the corresponding loop of bit j + char * currLoopLoc = station->loops.at(lane)->loop_loc; + if (packNo == 5) + haveData = strcmp(currLoopLoc, dp5[j - 1]); + else if (packNo == 6) + haveData = strcmp(currLoopLoc, dp6[j - 1]); + else if (packNo == 7) + haveData = strcmp(currLoopLoc, dp7[j - 1]); + else if (packNo == 8) + haveData = strcmp(currLoopLoc, dp8[j - 1]); + else + return -1; + + if (haveData == 0) { + LOOP *currLoop = station->loops.at(lane); + vol = currLoop->vol; + occ = (int) (currLoop->occ * 900 + 0.5); + + VOLOCC packedVOLOCC = packVOLOCC(vol, occ); + pos++; + msg[pos - 1] = packedVOLOCC.high; + pos++; + msg[pos - 1] = packedVOLOCC.low; + + if (packNo == 5) { + station->MlTotVol += vol; + } else if (packNo == 6) { + station->OppTotVol += vol; + } + } + } + } + } + return pos; +} + +unsigned char * DataPacker::staticDataPack(LDS_LOOP *station) { + int j; + // Allocate memory for dataPack + unsigned char *dataPack = (unsigned char *) calloc(sizeof(unsigned char), station->length); + + // dataPack 5-8: lane config + char d5 = 0, d6 = 0, d7 = 0, d8 = 0; + for (j = 0; j < station->loops.size(); j++) { + for (int k = 0; k < 8; k++) { + char * currLoopLoc = station->loops.at(j)->loop_loc; + if (strcmp(currLoopLoc, dp5[k]) == 0) + d5 += pow(2, k); + if (strcmp(currLoopLoc, dp6[k]) == 0) + d6 += pow(2, k); + if (strcmp(currLoopLoc, dp7[k]) == 0) + d7 += pow(2, k); + if (strcmp(currLoopLoc, dp8[k]) == 0) + d8 += pow(2, k); + } + } + dataPack[5 - 1] = d5; + dataPack[6 - 1] = d6; + dataPack[7 - 1] = d7; + dataPack[8 - 1] = d8; + + // dataPack 1: Drop number, i.e. station address + dataPack[1 - 1] = station->drop; + // dataPack2 (2 bytes per loop) + dataPack[2 - 1] = station->loops.size() * 2 + Fixed_Byte_To_Checksum; + + // dataPacket 3 (lowbyte: # of mainline loops, highbyte: # of opposite loops) + int low = 0, high = 0; + for (j = 1; j <= 6; j++) { + low += DataAvail(dataPack[5 - 1], j); + high += DataAvail(dataPack[6 - 1], j); + } + high = high << 4; + dataPack[3 - 1] = high | low; + + // dataPack4 (Miscl. flags: samples are: 80, A0, E0, 00) + dataPack[4 - 1] = 0xA0; + + // dataPack 9: initialized as 00 (meaning no metering); need to be updated every 30 sec + dataPack[9 - 1] = 0; + + // datadataPack 10-13: lane malfunction? Assuming all functional + dataPack[10 - 1] = 0; + dataPack[11 - 1] = 0; + dataPack[12 - 1] = 0; + dataPack[13 - 1] = 0; + + // dataPack 14-22: ramp metering data + // BYTE 16 and 22 need to be updated every 30 sec + bool found = false; + for (j = 0; j < station->loops.size(); j++) { + if (strcmp(station->loops.at(j)->loop_loc, "DEMAND") == 0) { + found = true; + break; + } + } + if (found) { + // BYTE 14: mostly 07, some are 05, 03, 00 + dataPack[14 - 1] = 0x07; + // mostly 06(TOD table 1); some are 0B (No metering) or 05(traffic responsive) + dataPack[15 - 1] = 0x06; + // most 00, some are 01 (queue override) or 80(Meter ON sign) + dataPack[16 - 1] = 0x00; + // Field Manual Rate + dataPack[17 - 1] = 0xFF; + // TOC Manual Rate + dataPack[18 - 1] = 0xFF; + // PSO Manual Rate + dataPack[19 - 1] = 0xFF; + // CORM Rate + dataPack[20 - 1] = 0xFF; + // Local Responsive Rate. DON'T UNDERSTAND YET + dataPack[21 - 1] = 0x00; + // TOD Rate: need to query RAMP plugin! + dataPack[22 - 1] = 0x00; + }// LDS: NO Metering + else { + dataPack[14 - 1] = 0x00; + dataPack[15 - 1] = 0x0B; + dataPack[16 - 1] = 0x00; + dataPack[17 - 1] = 0xFF; + dataPack[18 - 1] = 0xFF; + dataPack[19 - 1] = 0xFF; + dataPack[20 - 1] = 0xFF; + dataPack[21 - 1] = 0x00; + dataPack[22 - 1] = 0x00; + } + + // dataPack 23-24: sum of mainline/Opp traffic data; need to be updated every 30 sec + station->MlTotVol = 0; + station->OppTotVol = 0; + dataPack[23 - 1] = station->MlTotVol; + dataPack[24 - 1] = station->OppTotVol; + + // dataPack 25-26: BYTE 25 is fixed, i.e. 03; BYTE 26 is either 0xA2 or 0x84 + dataPack[25 - 1] = 0x03; + dataPack[26 - 1] = 0x84; + + return dataPack; +} + +bool DataPacker::DataAvail(char flag, int num) { + int mag, fel; + + // find mask value + if (num == 1) + mag = 0x01; + else if (num == 2) + mag = 0x02; + else if (num == 3) + mag = 0x04; + else if (num == 4) + mag = 0x08; + else if (num == 5) + mag = 0x10; + else if (num == 6) + mag = 0x20; + else if (num == 7) + mag = 0x40; + else if (num == 8) + mag = 0x80; + + fel = flag & mag; + fel = fel >> (num - 1); + + if (fel == 1) + return true; + else + return false; +} + +// checksum based on data from byte 1 (after 0DOA) to the second last byte (the +char DataPacker::chksum(unsigned char *dataptr, int len) { + int i; + unsigned char checksum = 0; + + for (i = 0; i < len; i++) + checksum += dataptr[i]; + + return checksum; +} + +// convert vol and occ data to a two-byte data packet +VOLOCC DataPacker::packVOLOCC(int vol, int occ) +{ + int bit, i; + int high, low; + int high_high = 0, high_low = 0; + VOLOCC com; + + // occ data: 10 bits + low = 0; + for (i=9; i>=0; i--) + { + if (i >= 8) + { + bit = ((occ >> i) & 1); + high_low += pow(2, (i - 8)) * bit; + } + // lower byte + else + { + bit = ((occ >> i) & 1); + low += pow(2, i) * bit; + } + } + + // vol: 6 bits (1. vol, shift to the left for two times; 2. combine data) + high_high = vol << 2; + high = high_high | high_low; + + com.high = high; + com.low = low; + + return com; +} Index: /branches/fep_rpc_client/DataPacker.h =================================================================== --- /branches/fep_rpc_client/DataPacker.h (revision 79) +++ /branches/fep_rpc_client/DataPacker.h (revision 79) @@ -0,0 +1,47 @@ +/* + * File: DataPacker.h + * + * DataPacker has a single static public method packData(..) that returns the + * packed data message that is sent to the ATMS Server in the fep_reply struct + * via RPC. + * + * @author John A. Torres + * @version 9/8/2017 + */ + +#ifndef DATAPACKER_H +#define DATAPACKER_H + +// Include dependencies +#include "network.h"; +#include <iostream> +#include <string.h> + +class DataPacker { + +public: + /** + * Returns packed data message to be sent to ATMS Server in fep_reply via RPC + * + * @param station The station for which the message is to be made + * @return The packed data message + */ + static unsigned char * packData(LDS_LOOP *station); + +private: + static unsigned char *msg; + // Packs the static data in message sent to ATMS + unsigned char * staticDataPack(LDS_LOOP *station); + // Packs dynamic data in message sent to ATMS + int dynamicDataPack(LDS_LOOP *station, int packNo, int pos); + // Sets last byte of message + char chksum(unsigned char *dataptr, int len); + // Tells whether or not data is available for specified lane + bool DataAvail(char flag, int num); + // Helper function: packs vol and occ into two byte data packet + VOLOCC packVOLOCC(int vol, int occ); + +}; + +#endif /* DATAPACKER_H */ + Index: /branches/fep_rpc_client/nbproject/Makefile-Release.mk =================================================================== --- /branches/fep_rpc_client/nbproject/Makefile-Release.mk (revision 77) +++ /branches/fep_rpc_client/nbproject/Makefile-Release.mk (revision 79) @@ -36,4 +36,5 @@ # Object Files OBJECTFILES= \ + ${OBJECTDIR}/DataPacker.o \ ${OBJECTDIR}/FEPClient.o \ ${OBJECTDIR}/NetworkReader.o \ @@ -65,4 +66,9 @@ ${MKDIR} -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM} ${LINK.cc} -o ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client ${OBJECTFILES} ${LDLIBSOPTIONS} + +${OBJECTDIR}/DataPacker.o: DataPacker.cpp + ${MKDIR} -p ${OBJECTDIR} + ${RM} "$@.d" + $(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/DataPacker.o DataPacker.cpp ${OBJECTDIR}/FEPClient.o: FEPClient.cpp Index: /branches/fep_rpc_client/nbproject/Makefile-Debug.mk =================================================================== --- /branches/fep_rpc_client/nbproject/Makefile-Debug.mk (revision 77) +++ /branches/fep_rpc_client/nbproject/Makefile-Debug.mk (revision 79) @@ -36,4 +36,5 @@ # Object Files OBJECTFILES= \ + ${OBJECTDIR}/DataPacker.o \ ${OBJECTDIR}/FEPClient.o \ ${OBJECTDIR}/NetworkReader.o \ @@ -56,5 +57,5 @@ # Link Libraries and Options -LDLIBSOPTIONS=tinyxml/libtinyxml.a +LDLIBSOPTIONS=tinyxml/tinyxml.a # Build Targets @@ -62,9 +63,14 @@ "${MAKE}" -f nbproject/Makefile-${CND_CONF}.mk ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client -${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client: tinyxml/libtinyxml.a +${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client: tinyxml/tinyxml.a ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client: ${OBJECTFILES} ${MKDIR} -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM} ${LINK.cc} -o ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client ${OBJECTFILES} ${LDLIBSOPTIONS} + +${OBJECTDIR}/DataPacker.o: DataPacker.cpp + ${MKDIR} -p ${OBJECTDIR} + ${RM} "$@.d" + $(COMPILE.cc) -g -Itinyxml -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/DataPacker.o DataPacker.cpp ${OBJECTDIR}/FEPClient.o: FEPClient.cpp Index: /branches/fep_rpc_client/nbproject/configurations.xml =================================================================== --- /branches/fep_rpc_client/nbproject/configurations.xml (revision 77) +++ /branches/fep_rpc_client/nbproject/configurations.xml (revision 79) @@ -5,4 +5,5 @@ displayName="Header Files" projectFiles="true"> + <itemPath>DataPacker.h</itemPath> <itemPath>FEPClient.h</itemPath> <itemPath>NetworkReader.h</itemPath> @@ -17,4 +18,5 @@ displayName="Source Files" projectFiles="true"> + <itemPath>DataPacker.cpp</itemPath> <itemPath>FEPClient.cpp</itemPath> <itemPath>NetworkReader.cpp</itemPath> @@ -50,8 +52,12 @@ <linkerTool> <linkerLibItems> - <linkerLibFileItem>tinyxml/libtinyxml.a</linkerLibFileItem> + <linkerLibFileItem>tinyxml/tinyxml.a</linkerLibFileItem> </linkerLibItems> </linkerTool> </compileType> + <item path="DataPacker.cpp" ex="false" tool="1" flavor2="0"> + </item> + <item path="DataPacker.h" ex="false" tool="3" flavor2="0"> + </item> <item path="FEPClient.cpp" ex="false" tool="1" flavor2="0"> </item> @@ -91,4 +97,8 @@ </asmTool> </compileType> + <item path="DataPacker.cpp" ex="false" tool="1" flavor2="0"> + </item> + <item path="DataPacker.h" ex="false" tool="3" flavor2="0"> + </item> <item path="FEPClient.cpp" ex="false" tool="1" flavor2="0"> </item> Index: /branches/fep_rpc_client/nbproject/private/private.xml =================================================================== --- /branches/fep_rpc_client/nbproject/private/private.xml (revision 78) +++ /branches/fep_rpc_client/nbproject/private/private.xml (revision 79) @@ -8,9 +8,12 @@ <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2"> <group> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/NetworkReader.h</file> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/FEPClient.cpp</file> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/network.h</file> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/fep.h</file> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/NetworkReader.cpp</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/NetworkReader.cpp</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/NetworkReader.h</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/network.h</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/FEPClient.cpp</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/fep.h</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/DataPacker.h</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/DataPacker.cpp</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/FEPClient.h</file> </group> </open-files> Index: /branches/ATMSDriver/build/built-jar.properties =================================================================== --- /branches/ATMSDriver/build/built-jar.properties (revision 77) +++ /branches/ATMSDriver/build/built-jar.properties (revision 79) @@ -1,4 +1,4 @@ -#Wed, 13 Sep 2017 17:07:03 -0700 +#Mon, 02 Oct 2017 13:41:31 -0700 -/home/andrew/branches/ATMSDriver= +/home/andrew/tmcsimulator/branches/ATMSDriver= Index: /branches/ATMSDriver/nbproject/private/private.xml =================================================================== --- /branches/ATMSDriver/nbproject/private/private.xml (revision 77) +++ /branches/ATMSDriver/nbproject/private/private.xml (revision 79) @@ -3,9 +3,5 @@ <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/2" lastBookmarkId="0"/> <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2"> - <group> - <file>file:/home/andrew/branches/ATMSDriver/src/atmsdriver/ATMSDriver.java</file> - <file>file:/home/andrew/branches/ATMSDriver/src/atmsdriver/NetworkReader.java</file> - <file>file:/home/andrew/branches/ATMSDriver/src/atmsdriver/network/model/Network.java</file> - </group> + <group/> </open-files> </project-private>

Index: /trunk/paramics_status.log =================================================================== --- /trunk/paramics_status.log (revision 79) +++ /trunk/paramics_status.log (revision 79) @@ -0,0 +1,25 @@ + + LOADING + 1 + + + + WARMING + 1 + + + + LOADED + 1 + + + + WARMING + 1 + + + + LOADED + 1 + + Index: /trunk/config/paramics_simulator_config.properties =================================================================== --- /trunk/config/paramics_simulator_config.properties (revision 60) +++ /trunk/config/paramics_simulator_config.properties (revision 79) @@ -1,4 +1,4 @@ -WorkingDirectory = C:/paramics/ -#WorkingDirectory = .\/ +#WorkingDirectory = C:/paramics/ +WorkingDirectory = ./ IncidentUpdateFile = exchange.xml ParamicsStatusFile = paramics_status.xml Index: /trunk/config/vds_data/lds.txt =================================================================== --- /trunk/config/vds_data/lds.txt (revision 79) +++ /trunk/config/vds_data/lds.txt (revision 79) @@ -0,0 +1,163 @@ +lds_id line drop sch lineinfo system_key sch_seq glo_seq count freeway Dir ca_pm lds_name +1205270 5 19 1 1 1123005673 26492 1357648 20 5 S 33 MAIN 1 +1208933 6 15 2 2 1123005691 26491 1357639 19 73 S 26.3 S OF 55 +1203081 6 17 2 2 1123005691 26491 1357639 19 55 N 4.58 BRISTOL +1203083 6 18 2 2 1123005691 26491 1357639 19 55 S 4.7 BAKER 1 +1210174 6 19 2 2 1123005691 26491 1357639 19 55 S 5.06 BAKER 2 +1210163 6 20 2 2 1123005691 26491 1357639 19 55 N 5.51 PAULARINO 1 +1204875 22 1 4 4 1123005726 26490 1357624 19 5 N 24.5 N OF SAND CNYN +1204847 22 2 4 4 1123005726 26490 1357624 19 5 N 24.05 SAND CANYON 2 +1204832 22 3 4 4 1123005726 26490 1357624 19 5 S 23.69 SAND CANYON 1 +1204973 22 4 4 4 1123005726 26490 1357624 19 5 N 26.56 CULVER 1 +1205003 22 5 4 4 1123005726 26490 1357624 19 5 N 26.81 CULVER 2 +1204958 22 6 4 4 1123005726 26490 1357624 19 5 S 26.35 CULVER 1 +1204988 22 7 4 4 1123005726 26490 1357624 19 5 S 26.66 CULVER 2 +1204928 22 8 4 4 1123005726 26490 1357624 19 5 N 25.15 JEFFREY 2 +1205077 22 9 4 4 1123005726 26490 1357624 19 5 N 28.1 TUSTIN RANCH +1205229 22 10 4 4 1123005726 26490 1357624 19 5 S 32 GRAND 2 +1205176 22 11 4 4 1123005726 26490 1357624 19 5 S 30.9 1ST +1205188 22 12 4 4 1123005726 26490 1357624 19 5 N 31.23 4TH +1205219 22 13 4 4 1123005726 26490 1357624 19 5 N 31.9 GRAND 2 +1205238 22 16 4 4 1123005726 26490 1357624 19 5 S 32.25 17TH 1 +1205208 22 17 4 4 1123005726 26490 1357624 19 5 S 31.6 GRAND 1 +1204912 22 18 4 4 1123005726 26490 1357624 19 5 N 25.08 JEFFREY 1 +1204892 22 19 4 4 1123005726 26490 1357624 19 5 S 24.84 JEFFREY 1 +1205094 22 20 4 4 1123005726 26490 1357624 19 5 S 28.35 TUSTIN RANCH +1205156 23 1 23 21 1123005995 26479 1357626 18 5 N 30 B ST. +1205164 23 2 23 21 1123005995 26479 1357626 18 5 N 30.2 S OF 55 +1205167 23 3 23 21 1123005995 26479 1357626 18 5 N 30.4 N OF 55 +1205172 23 4 23 21 1123005995 26479 1357626 18 5 S 30.6 WILLIAMS +1205197 23 5 23 21 1123005995 26479 1357626 18 5 N 31.4 CONCORD +1205254 23 6 23 21 1123005995 26479 1357626 18 5 N 32.5 17TH 2 +1205268 23 7 23 21 1123005995 26479 1357626 18 5 N 32.6 17TH 3 +1209845 23 11 23 21 1123005995 26479 1357626 18 55 N 10.2 N OF 5 OFF +1203261 23 14 23 21 1123005995 26479 1357626 18 55 S 10.4 S OF 5 +1203270 23 15 23 21 1123005995 26479 1357626 18 55 S 10.5 N OF 5 +1209052 26 13 25 25 1123006044 26482 1357604 3 405 S 5.05 SPRUCE +1201409 27 1 26 26 1123006050 26481 1357603 3 405 S 8.9 N OF 55 +1201405 27 2 26 26 1123006050 26481 1357603 3 405 N 8.27 AIRPORT +1208924 29 2 28 28 1123006080 26480 1357609 13 73 N 23.2 N OF BONITA +1208925 29 3 28 28 1123006080 26480 1357609 13 73 S 23.5 BISON 1 +1208926 29 4 28 28 1123006080 26480 1357609 13 73 S 23.7 MACARTHUR 1 +1210382 29 5 28 28 1123006080 26480 1357609 13 73 N 23.9 BISON 2 +1208927 29 6 28 28 1123006080 26480 1357609 13 73 N 24.1 MACARTHUR 2 +1201475 31 1 5 5 1123005744 26489 1357649 18 405 N 9.65 BRISTOL 2 +1201444 31 2 5 5 1123005744 26489 1357649 18 405 N 9.46 BRISTOL 1 +1201459 31 3 5 5 1123005744 26489 1357649 18 405 S 9.54 BRISTOL 2 +1204756 31 5 5 5 1123005744 26489 1357649 18 5 S 22.75 BARRANCA +1201547 31 6 5 5 1123005744 26489 1357649 18 405 S 11.5 HARBOR 2 +1201531 31 7 5 5 1123005744 26489 1357649 18 405 N 11.4 HARBOR 1 +1201564 31 8 5 5 1123005744 26489 1357649 18 405 N 11.6 HARBOR 2 +1201516 31 9 5 5 1123005744 26489 1357649 18 405 S 11.2 HARBOR 1 +1201502 31 11 5 5 1123005744 26489 1357649 18 405 N 10.9 FAIRVIEW +1204802 31 16 5 5 1123005744 26489 1357649 18 5 N 23.2 N OF 133 +1204793 31 17 5 5 1123005744 26489 1357649 18 5 S 23.1 N OF 133 +1204813 31 18 5 5 1123005744 26489 1357649 18 5 S 23.5 S OF SAND CNYN +1204776 31 20 5 5 1123005744 26489 1357649 18 5 S 23.05 S OF 133 +1209055 34 3 31 31 1123006127 26475 1357632 20 405 S 10.48 N OF 73 +1209226 34 4 31 31 1123006127 26475 1357632 20 405 S 12.16 HAMPSHIRE +1201489 34 5 31 31 1123006127 26475 1357632 20 405 S 10.28 FAIRVIEW +1208936 34 19 31 31 1123006127 26475 1357632 20 73 S 27.72 FAIRVIEW +1211667 36 7 32 32 1123006146 26478 1357615 17 133 N 12.77 N OF PORTOLA +1211685 36 8 32 32 1123006146 26478 1357615 17 133 N 12.42 S OF PORTOLA +1211694 36 9 32 32 1123006146 26478 1357615 17 133 N 12.05 IRVINE BLVD 3 +1211719 36 10 32 32 1123006146 26478 1357615 17 133 N 11.35 N OF PM 11 +1211710 36 11 32 32 1123006146 26478 1357615 17 133 S 11.7 IRVINE BLVD 1 +1211726 36 12 32 32 1123006146 26478 1357615 17 133 N 11.08 AT PM 11 +1211733 36 13 32 32 1123006146 26478 1357615 17 133 N 10.73 S OF PM 11 +1211742 36 14 32 32 1123006146 26478 1357615 17 133 N 10.5 N OF MARINE +1211754 36 15 32 32 1123006146 26478 1357615 17 133 N 10.05 MARINE WAY +1211762 36 16 32 32 1123006146 26478 1357615 17 133 N 9.77 N OF 5 +1211774 36 17 32 32 1123006146 26478 1357615 17 133 N 9.37 S OF 5 +1204539 45 1 11 11 1123005841 26484 1357646 19 5 N 16.51 LA PAZ 1 +1204553 45 2 11 11 1123005841 26484 1357646 19 5 N 16.69 LA PAZ 2 +1204566 45 3 11 11 1123005841 26484 1357646 19 5 N 17.43 ALICIA 1 +1204578 45 4 11 11 1123005841 26484 1357646 19 5 N 17.63 ALICIA 2 +1204537 45 5 11 11 1123005841 26484 1357646 19 5 S 16.3 LA PAZ 1 +1204608 45 6 11 11 1123005841 26484 1357646 19 5 N 18.61 EL TORO 1 +1204622 45 7 11 11 1123005841 26484 1357646 19 5 N 18.82 EL TORO 2 +1204637 45 8 11 11 1123005841 26484 1357646 19 5 N 19.33 RED ROBIN +1204551 45 9 11 11 1123005841 26484 1357646 19 5 S 16.5 LA PAZ 2 +1204666 45 10 11 11 1123005841 26484 1357646 19 5 N 20 LAKE FOR2 +1204721 45 11 11 11 1123005841 26484 1357646 19 5 N 22.1 ALTON 2 +1204742 45 12 11 11 1123005841 26484 1357646 19 5 N 22.2 ALTON 3 +1204564 45 13 11 11 1123005841 26484 1357646 19 5 S 17.26 ALICIA 1 +1204706 45 15 11 11 1123005841 26484 1357646 19 5 S 21.92 ALTON 1 +1204576 45 17 11 11 1123005841 26484 1357646 19 5 S 17.49 ALICIA 2 +1204606 45 19 11 11 1123005841 26484 1357646 19 5 S 18.5 EL TORO 1 +1204620 45 20 11 11 1123005841 26484 1357646 19 5 S 18.7 EL TORO 2 +1201202 46 1 36 36 1123006209 26472 1357644 20 405 N 4.03 JEFFREY 2 +1201176 46 2 36 36 1123006209 26472 1357644 20 405 N 3.86 JEFFREY 1 +1201245 46 3 36 36 1123006209 26472 1357644 20 405 N 5.55 CULVER 1 +1201321 46 4 36 36 1123006209 26472 1357644 20 405 N 6.85 JAMBOREE1 +1201388 46 5 36 36 1123006209 26472 1357644 20 405 N 7.73 MACARTHUR 1 +1201190 46 6 36 36 1123006209 26472 1357644 20 405 S 4.03 JEFFREY 2 +1201164 46 7 36 36 1123006209 26472 1357644 20 405 S 3.84 JEFFREY 1 +1201275 46 8 36 36 1123006209 26472 1357644 20 405 N 5.74 CULVER 2 +1201261 46 9 36 36 1123006209 26472 1357644 20 405 S 5.69 CULVER 2 +1201231 46 10 36 36 1123006209 26472 1357644 20 405 S 5.5 CULVER 1 +1201356 46 11 36 36 1123006209 26472 1357644 20 405 N 7.07 JAMBOREE2 +1201339 46 12 36 36 1123006209 26472 1357644 20 405 S 7.01 JAMBOREE2 +1201306 46 13 36 36 1123006209 26472 1357644 20 405 S 6.8 JAMBOREE1 +1201371 46 14 36 36 1123006209 26472 1357644 20 405 S 7.69 MACARTHUR1 +1201289 46 15 36 36 1123006209 26472 1357644 20 405 S 6.1 HARVARD +1201216 46 16 36 36 1123006209 26472 1357644 20 405 S 5.01 YALE +1201043 46 17 36 36 1123006209 26472 1357644 20 133 S 9 BARRANCA2 +1201411 46 18 36 36 1123006209 26472 1357644 20 405 S 8.4 RED HILL +1201057 46 19 36 36 1123006209 26472 1357644 20 133 N 9 BARRANCA1 +1201069 46 20 36 36 1123006209 26472 1357644 20 133 N 9.1 BARRANCA2 +1205111 50 1 13 13 1123005873 24148 1357650 19 5 S 29.02 RED HILL +1205128 50 2 13 13 1123005873 24148 1357650 19 5 N 29.24 RED HILL +1205146 50 3 13 13 1123005873 24148 1357650 19 5 N 29.79 NEWPORT +1203244 50 4 13 13 1123005873 24148 1357650 19 55 N 10 MCFADDEN +1203211 50 5 13 13 1123005873 24148 1357650 19 55 N 9.41 EDINGER 2 +1203196 50 6 13 13 1123005873 24148 1357650 19 55 S 9.19 EDINGER 1 +1203165 50 7 13 13 1123005873 24148 1357650 19 55 N 7.85 DYER 1 +1203176 50 8 13 13 1123005873 24148 1357650 19 55 N 8.12 DYER 2 +1203153 50 9 13 13 1123005873 24148 1357650 19 55 S 7.62 DYER 1 +1203115 50 10 13 13 1123005873 24148 1357650 19 55 N 6.94 MACARTHU1 +1203140 50 11 13 13 1123005873 24148 1357650 19 55 N 7.16 MACARTHU2 +1203129 50 12 13 13 1123005873 24148 1357650 19 55 S 7.03 MACARTHU2 +1203103 50 13 13 13 1123005873 24148 1357650 19 55 S 6.88 MACARTHU1 +1203226 50 14 13 13 1123005873 24148 1357650 19 55 S 10 MCFADDEN +1203062 50 16 13 13 1123005873 24148 1357650 19 55 N 3.96 FAIR 2 +1203044 50 17 13 13 1123005873 24148 1357650 19 55 S 3.6 FAIR 1 +1203026 50 18 13 13 1123005873 24148 1357650 19 55 N 3.11 VICTORIA2 +1203085 50 20 13 13 1123005873 24148 1357650 19 55 N 5.8 PAULARINO 2 +1203293 56 1 14 14 1123005892 26482 1357643 20 55 N 11.1 FOURTH 2 +1203274 56 2 14 14 1123005892 26482 1357643 20 55 S 10.84 FOURTH 1 +1203321 56 3 14 14 1123005892 26482 1357643 20 55 N 11.74 17TH 1 +1203335 56 4 14 14 1123005892 26482 1357643 20 55 N 12 17TH 2 +1203307 56 5 14 14 1123005892 26482 1357643 20 55 S 11.62 17TH 1 +1212485 56 15 14 14 1123005892 26482 1357643 20 73 N 27.4 BEAR 2 +1208935 56 16 14 14 1123005892 26482 1357643 20 73 S 27.2 BEAR 1 +1208931 56 17 14 14 1123005892 26482 1357643 20 73 S 25.25 ORCHID +1208932 56 18 14 14 1123005892 26482 1357643 20 73 N 25.7 CAMPUS +1208934 56 19 14 14 1123005892 26482 1357643 20 73 N 26.7 N OF 55 +1201119 73 1 18 18 1123005950 26481 1357636 16 405 N 1.11 IRVINE C2 +1201130 73 2 18 18 1123005950 26481 1357636 16 405 S 1.57 S OF 133 +1201133 73 3 18 18 1123005950 26481 1357636 16 405 S 1.93 N OF 133 +1201092 73 4 18 18 1123005950 26481 1357636 16 405 N 0.93 IRVINE C1 +1201150 73 5 18 18 1123005950 26481 1357636 16 405 N 2.99 SAND CANYON +1201105 73 6 18 18 1123005950 26481 1357636 16 405 S 0.96 IRVINE C2 +1209051 73 7 18 18 1123005950 26481 1357636 16 405 N 3.31 N OF SAND CANYON +1209054 73 11 18 18 1123005950 26481 1357636 16 405 S 1.73 AT 133 +1201136 73 12 18 18 1123005950 26481 1357636 16 405 S 2.88 SAND CANYON +1201080 73 13 18 18 1123005950 26481 1357636 16 405 S 0.77 IRVINE C1 +1204941 73 15 18 18 1123005950 26481 1357636 16 5 S 25.8 YALE +1205068 73 16 18 18 1123005950 26481 1357636 16 5 N 27.7 JAMBOREE 2 +1205019 73 17 18 18 1123005950 26481 1357636 16 5 S 27.43 JAMBOREE 1 +1205034 73 18 18 18 1123005950 26481 1357636 16 5 N 27.55 JAMBOREE 1 +1205051 73 19 18 18 1123005950 26481 1357636 16 5 S 27.7 JAMBOREE 2 +1209050 73 20 18 18 1123005950 26481 1357636 16 405 N 2.35 LAGUNA CANYON RD +1204649 74 1 19 19 1123005967 26480 1357638 18 5 S 19.8 LAKE FOREST 1 +1204664 74 4 19 19 1123005967 26480 1357638 18 5 S 19.9 LAKE FOREST 2 +1204696 74 5 19 19 1123005967 26480 1357638 18 5 N 20.59 BAKE 1 +1204698 74 6 19 19 1123005967 26480 1357638 18 5 N 20.94 BAKE 2 +1204694 74 7 19 19 1123005967 26480 1357638 18 5 S 20.59 BAKE 1 +1204700 74 8 19 19 1123005967 26480 1357638 18 5 S 20.95 BAKE 2 +1204681 74 15 19 19 1123005967 26480 1357638 18 5 N 20.23 OLDFIELD +1204702 74 17 19 19 1123005967 26480 1357638 18 5 S 21.25 At 405 +1201117 74 18 19 19 1123005967 26480 1357638 18 405 S 0.6 N OF 5 + + Index: /trunk/config/vds_data/loop.txt =================================================================== --- /trunk/config/vds_data/loop.txt (revision 79) +++ /trunk/config/vds_data/loop.txt (revision 79) @@ -0,0 +1,1792 @@ +FWY Dir POSTMI LDS_ID VDS_ID LOOP_ID LOC LANE LOOP_LOC PARAMICS_NAME PARAMICS_LANE +5 S 16.3 1204537 1204538 1211007 ML 1 ML_1 5s16.3ml 4 +5 S 16.3 1204537 1204538 1211008 ML 2 ML_2 5s16.3ml 3 +5 S 16.3 1204537 1204538 1211009 ML 3 ML_3 5s16.3ml 2 +5 S 16.3 1204537 1204538 1211010 ML 4 ML_4 5s16.3ml 1 +5 S 16.3 1204537 1211848 1211011 DM 1 DEMAND 5s16.3ora 0 +5 S 16.3 1204537 1211848 1211012 PA 2 PASSAGE 5s16.3ora 0 +5 S 16.3 1204537 1211848 1211013 QU 3 QUEUE 5s16.3ora 0 +5 S 16.3 1204537 1211848 1211014 OR 4 RAMP_ON 5s16.3ora 0 +5 S 16.3 1204537 1211848 1211015 RH 5 RAMP_HOV 5s16.3ora 0 +5 S 16.3 1204537 1211182 1211016 HV 1 SD_1 5s16.3hv 1 +5 S 16.5 1204551 1204552 1210995 ML 1 ML_1 5s16.5ml 4 +5 S 16.5 1204551 1204552 1210996 ML 2 ML_2 5s16.5ml 3 +5 S 16.5 1204551 1204552 1210997 ML 3 ML_3 5s16.5ml 2 +5 S 16.5 1204551 1204552 1210998 ML 4 ML_4 5s16.5ml 1 +5 S 16.5 1204551 1211177 1210999 HV 1 SD_1 5s16.5hv 1 +5 S 16.5 1204551 1211178 1211000 DM 1 DEMAND 5s16.5ora 0 +5 S 16.5 1204551 1211178 1211001 PA 2 PASSAGE 5s16.5ora 0 +5 S 16.5 1204551 1211178 1211002 QU 3 QUEUE 5s16.5ora 0 +5 S 16.5 1204551 1211178 1211003 OR 4 RAMP_ON 5s16.5ora 0 +5 S 16.5 1204551 1211180 1211004 FR 1 RAMP_OFF 5s16.5fr 1 +5 S 16.5 1204551 1211180 1211005 FR 2 SD_2 ? 0 +5 S 16.5 1204551 1211180 1211006 FR 3 SD_3 ? 0 +5 S 16.5 1204551 1211178 1211179 RH 5 RAMP_HOV 5s16.5ora 0 +5 N 16.51 1204539 1204540 1204541 QU 2 QUEUE 5n16.52ora 0 +5 N 16.51 1204539 1204540 1204542 DM 3 DEMAND 5n16.52ora 0 +5 N 16.51 1204539 1204540 1204543 PA 4 PASSAGE 5n16.52ora 0 +5 N 16.51 1204539 1204544 1204545 FR 1 RAMP_OFF 5n16.37fr 1 +5 N 16.51 1204539 1204546 1204547 ML 1 ML_1 5n16.5ml 4 +5 N 16.51 1204539 1204546 1204548 ML 2 ML_2 5n16.5ml 3 +5 N 16.51 1204539 1204546 1204549 ML 3 ML_3 5n16.5ml 2 +5 N 16.51 1204539 1204546 1204550 ML 4 ML_4 5n16.5ml 1 +5 N 16.51 1204539 1210085 1210084 HV 1 SD_1 5n16.5hv 1 +5 N 16.51 1204539 1204540 1210372 OR 1 RAMP_ON 5n16.52ora 0 +5 N 16.51 1204539 1204540 1211111 RH 5 RAMP_HOV 5n16.52ora 0 +5 N 16.69 1204553 1204554 1204555 OR 1 RAMP_ON 5n16.6ora 0 +5 N 16.69 1204553 1204554 1204556 QU 2 QUEUE 5n16.6ora 0 +5 N 16.69 1204553 1204554 1204557 DM 3 DEMAND 5n16.6ora 0 +5 N 16.69 1204553 1204554 1204558 PA 4 PASSAGE 5n16.6ora 0 +5 N 16.69 1204553 1204559 1204560 ML 1 ML_1 5n16.6ml 4 +5 N 16.69 1204553 1204559 1204561 ML 2 ML_2 5n16.6ml 3 +5 N 16.69 1204553 1204559 1204562 ML 3 ML_3 5n16.6ml 2 +5 N 16.69 1204553 1204559 1204563 ML 4 ML_4 5n16.6ml 1 +5 N 16.69 1204553 1210087 1210086 HV 1 SD_1 5n16.6hv 1 +5 S 17.26 1204564 1204565 1210354 ML 1 ML_1 5s17.29ml 5 +5 S 17.26 1204564 1204565 1210355 ML 2 ML_2 5s17.29ml 4 +5 S 17.26 1204564 1204565 1210356 ML 3 ML_3 5s17.29ml 3 +5 S 17.26 1204564 1204565 1210357 ML 4 ML_4 5s17.29ml 2 +5 S 17.26 1204564 1204565 1210358 ML 5 ML_5 5s17.29ml 1 +5 S 17.26 1204564 1210367 1210359 DM 1 DEMAND 5s17.26ora 0 +5 S 17.26 1204564 1210367 1210360 PA 2 PASSAGE 5s17.26ora 0 +5 S 17.26 1204564 1210367 1210361 QU 3 QUEUE 5s17.26ora 0 +5 S 17.26 1204564 1210367 1210362 OR 4 RAMP_ON 5s17.26ora 0 +5 S 17.26 1204564 1210367 1210363 RH 5 RAMP_HOV 5s17.26ora 0 +5 S 17.26 1204564 1210368 1210366 HV 1 SD_1 5s17.29hv 1 +5 N 17.43 1204566 1204567 1204568 QU 2 QUEUE 5n17.44ora 0 +5 N 17.43 1204566 1204567 1204569 DM 3 DEMAND 5n17.44ora 0 +5 N 17.43 1204566 1204567 1204570 PA 4 PASSAGE 5n17.44ora 0 +5 N 17.43 1204566 1204571 1204572 ML 1 ML_1 5n17.43ml 4 +5 N 17.43 1204566 1204571 1204573 ML 2 ML_2 5n17.43ml 3 +5 N 17.43 1204566 1204571 1204574 ML 3 ML_3 5n17.43ml 2 +5 N 17.43 1204566 1204571 1204575 ML 4 ML_4 5n17.43ml 1 +5 N 17.43 1204566 1210089 1210088 HV 1 SD_1 5n17.43ml 6 +5 N 17.43 1204566 1210089 1210123 HV 2 SD_3 ? 0 +5 N 17.43 1204566 1204567 1210371 OR 1 RAMP_ON 5n17.44ora 0 +5 S 17.49 1204576 1204577 1210341 ML 1 ML_1 5s17.47ml 5 +5 S 17.49 1204576 1204577 1210342 ML 2 ML_2 5s17.47ml 4 +5 S 17.49 1204576 1204577 1210343 ML 3 ML_3 5s17.47ml 3 +5 S 17.49 1204576 1204577 1210344 ML 4 ML_4 5s17.47ml 2 +5 S 17.49 1204576 1211804 1210345 DM 1 DEMAND 5s17.49ora 0 +5 S 17.49 1204576 1211804 1210346 PA 2 PASSAGE 5s17.49ora 0 +5 S 17.49 1204576 1211804 1210347 QU 3 QUEUE 5s17.49ora 0 +5 S 17.49 1204576 1211804 1210348 OR 4 RAMP_ON 5s17.49ora 0 +5 S 17.49 1204576 1211804 1210349 RH 5 RAMP_HOV 5s17.49ora 0 +5 S 17.49 1204576 1211805 1210350 FR 1 RAMP_OFF 5s17.5fr 2 +5 S 17.49 1204576 1211183 1210351 HV 1 SD_1 5s17.47ml 1 +5 S 17.49 1204576 1211805 1210352 FR 2 SD_2 5s17.5fr 1 +5 N 17.63 1204578 1204579 1204580 QU 1 QUEUE 5n17.64ora 0 +5 N 17.63 1204578 1204579 1204581 DM 2 DEMAND 5n17.64ora 0 +5 N 17.63 1204578 1204579 1204582 PA 3 PASSAGE 5n17.64ora 0 +5 N 17.63 1204578 1204583 1204584 FR 1 RAMP_OFF 5n17.3fr 1 +5 N 17.63 1204578 1204591 1204585 HV 2 SD_3 ? 0 +5 N 17.63 1204578 1204586 1204587 ML 1 ML_1 5n17.63ml 5 +5 N 17.63 1204578 1204586 1204588 ML 2 ML_2 5n17.63ml 4 +5 N 17.63 1204578 1204586 1204589 ML 3 ML_3 5n17.63ml 3 +5 N 17.63 1204578 1204586 1204590 ML 4 ML_4 5n17.63ml 2 +5 N 17.63 1204578 1204591 1204592 HV 1 SD_1 5n17.63hv 1 +5 N 17.63 1204578 1204583 1210092 FR 3 SD_5 ? 0 +5 N 17.63 1204578 1204583 1210093 FR 2 SD_4 ? 0 +5 N 17.63 1204578 1204579 1210094 OR 4 RAMP_ON 5n17.64ora 0 +5 N 17.63 1204578 1204586 1210370 ML 5 ML_5 5n17.63ml 1 +5 S 18.5 1204606 1204607 1210327 ML 1 ML_1 5s18.5ml 5 +5 S 18.5 1204606 1204607 1210328 ML 2 ML_2 5s18.5ml 4 +5 S 18.5 1204606 1204607 1210329 ML 3 ML_3 5s18.5ml 3 +5 S 18.5 1204606 1204607 1210330 ML 4 ML_4 5s18.5ml 2 +5 S 18.5 1204606 1204607 1210331 ML 5 ML_5 5s18.5ml 1 +5 S 18.5 1204606 1210339 1210332 DM 1 DEMAND 5s18.5ora 0 +5 S 18.5 1204606 1210339 1210333 PA 2 PASSAGE 5s18.5ora 0 +5 S 18.5 1204606 1210339 1210334 QU 3 QUEUE 5s18.5ora 0 +5 S 18.5 1204606 1210339 1210335 OR 4 RAMP_ON 5s18.5ora 0 +5 S 18.5 1204606 1210339 1210336 RH 5 RAMP_HOV 5s18.5ora 0 +5 S 18.5 1204606 1210340 1210337 HV 1 SD_1 5s18.5hv 2 +5 S 18.5 1204606 1210340 1210338 HV 2 SD_2 5s18.5hv 1 +5 N 18.61 1204608 1204609 1204610 OR 1 RAMP_ON 5n18.62ora 0 +5 N 18.61 1204608 1204609 1204611 QU 2 QUEUE 5n18.62ora 0 +5 N 18.61 1204608 1204609 1204612 DM 3 DEMAND 5n18.62ora 0 +5 N 18.61 1204608 1204609 1204613 PA 4 PASSAGE 5n18.62ora 0 +5 N 18.61 1204608 1204609 1204614 RH 5 RAMP_HOV 5n18.62ora 0 +5 N 18.61 1204608 1204615 1204616 ML 1 ML_1 5n18.61ml 4 +5 N 18.61 1204608 1204615 1204617 ML 2 ML_2 5n18.61ml 3 +5 N 18.61 1204608 1204615 1204618 ML 3 ML_3 5n18.61ml 2 +5 N 18.61 1204608 1204615 1204619 ML 4 ML_4 5n18.61ml 1 +5 N 18.61 1204608 1210103 1210101 HV 1 SD_1 5n18.61hv 1 +5 S 18.7 1204620 1204621 1210307 ML 1 ML_1 5s18.7ml 5 +5 S 18.7 1204620 1204621 1210308 ML 2 ML_2 5s18.7ml 4 +5 S 18.7 1204620 1204621 1210309 ML 3 ML_3 5s18.7ml 3 +5 S 18.7 1204620 1204621 1210310 ML 4 ML_4 5s18.7ml 2 +5 S 18.7 1204620 1204621 1210311 ML 5 ML_5 5s18.7ml 1 +5 S 18.7 1204620 1210320 1210312 DM 1 DEMAND 5s18.7ora 0 +5 S 18.7 1204620 1210320 1210313 PA 2 PASSAGE 5s18.7ora 0 +5 S 18.7 1204620 1210320 1210314 QU 3 QUEUE 5s18.7ora 0 +5 S 18.7 1204620 1210320 1210315 OR 4 RAMP_ON 5s18.7ora 0 +5 S 18.7 1204620 1210321 1210316 FR 1 RAMP_OFF 5s18.7fr 2 +5 S 18.7 1204620 1210321 1210317 FR 2 SD_3 5s18.7fr 1 +5 S 18.7 1204620 1210322 1210318 HV 1 SD_1 5s18.7hv 2 +5 S 18.7 1204620 1210322 1210319 HV 2 SD_2 5s18.7hv 1 +5 N 18.82 1204622 1204623 1204624 OR 1 RAMP_ON 5n18.82ora 0 +5 N 18.82 1204622 1204623 1204625 QU 2 QUEUE 5n18.82ora 0 +5 N 18.82 1204622 1204623 1204626 DM 3 DEMAND 5n18.82ora 0 +5 N 18.82 1204622 1204623 1204627 PA 4 PASSAGE 5n18.82ora 0 +5 N 18.82 1204622 1204628 1204629 FR 1 RAMP_OFF 5n18.5fr 1 +5 N 18.82 1204622 1210106 1204630 HV 1 SD_1 5n18.82hv 1 +5 N 18.82 1204622 1204628 1210104 FR 2 SD_3 ? 0 +5 N 18.82 1204622 1204628 1210105 FR 3 SD_5 ? 0 +5 N 19.33 1204637 1204638 1204639 ML 1 ML_1 5n19.33ml 7 +5 N 19.33 1204637 1204638 1204640 ML 2 ML_2 5n19.33ml 6 +5 N 19.33 1204637 1204638 1204641 ML 3 ML_3 5n19.33ml 5 +5 N 19.33 1204637 1204638 1204642 ML 4 ML_4 5n19.33ml 4 +5 S 19.33 1204637 1204643 1204645 OS 1 OS_1 5s19.33ml 6 +5 S 19.33 1204637 1204643 1204646 OS 2 OS_2 5s19.33ml 5 +5 S 19.33 1204637 1204643 1204647 OS 3 OS_3 5s19.33ml 4 +5 S 19.33 1204637 1204643 1204648 OS 4 OS_4 5s19.33ml 3 +5 N 19.33 1204637 1204638 1210107 ML 5 ML_5 5n19.33ml 3 +5 N 19.33 1204637 1204638 1210108 ML 6 ML_6 5n19.33ml 2 +5 N 19.33 1204637 1204638 1210111 ML 7 SD_5 5n19.33ml 1 +5 S 19.33 1204637 1204643 1210113 OS 5 OS_5 5s19.33ml 2 +5 S 19.33 1204637 1204643 1210114 OS 6 OS_6 5s19.33ml 1 +5 N 19.33 1204637 1210115 1210116 HV 1 SD_1 5n19.33hv 1 +5 N 19.33 1204637 1210115 1210117 HV 2 SD_2 5s19.33hv 1 +5 S 19.33 1204637 1210121 1210118 OH 1 SD_3 ? 0 +5 S 19.33 1204637 1210121 1210119 OH 2 SD_4 ? 0 +5 S 19.8 1204649 1204650 1210292 ML 1 ML_1 5s19.8ml 6 +5 S 19.8 1204649 1204650 1210293 ML 2 ML_2 5s19.8ml 5 +5 S 19.8 1204649 1204650 1210294 ML 3 ML_3 5s19.8ml 4 +5 S 19.8 1204649 1204650 1210295 ML 4 ML_4 5s19.8ml 3 +5 S 19.8 1204649 1204650 1210296 ML 5 ML_5 5s19.8ml 2 +5 S 19.8 1204649 1204650 1210297 ML 6 ML_6 5s19.8ml 1 +5 S 19.8 1204649 1210304 1210298 DM 1 DEMAND 5s19.8ora 0 +5 S 19.8 1204649 1210304 1210299 PA 2 PASSAGE 5s19.8ora 0 +5 S 19.8 1204649 1210304 1210300 QU 3 QUEUE 5s19.8ora 0 +5 S 19.8 1204649 1210304 1210301 OR 4 RAMP_ON 5s19.8ora 0 +5 S 19.8 1204649 1210305 1210302 HV 1 SD_1 5s19.8hv 2 +5 S 19.8 1204649 1210305 1210303 HV 2 SD_2 5s19.8hv 1 +5 S 19.9 1204664 1204665 1210273 ML 1 ML_1 5s19.9ml 6 +5 S 19.9 1204664 1204665 1210274 ML 2 ML_2 5s19.9ml 5 +5 S 19.9 1204664 1204665 1210275 ML 3 ML_3 5s19.9ml 4 +5 S 19.9 1204664 1204665 1210276 ML 4 ML_4 5s19.9ml 3 +5 S 19.9 1204664 1204665 1210277 ML 5 ML_5 5s19.9ml 2 +5 S 19.9 1204664 1204665 1210278 ML 6 ML_6 5s19.9ml 1 +5 S 19.9 1204664 1210326 1210279 HV 1 SD_1 5s19.9hv 2 +5 S 19.9 1204664 1210326 1210280 HV 2 SD_2 5s19.9hv 1 +5 S 19.9 1204664 1210323 1210281 DM 1 DEMAND 5s19.9ora 0 +5 S 19.9 1204664 1210323 1210282 PA 2 PASSAGE 5s19.9ora 0 +5 S 19.9 1204664 1210323 1210283 QU 3 QUEUE 5s19.9ora 0 +5 S 19.9 1204664 1210323 1210284 OR 4 RAMP_ON 5s19.9ora 0 +5 S 19.9 1204664 1210323 1210285 RH 5 RAMP_HOV 5s19.9ora 0 +5 S 19.9 1204664 1210324 1210287 FR 1 RAMP_OFF 5s19.9fr 2 +5 S 19.9 1204664 1210324 1210288 FR 2 SD_3 5s19.9fr 1 +5 S 19.9 1204664 1210324 1210289 FR 3 SD_4 5s19.9ff 1 +5 S 19.9 1204664 1210325 1210290 OC 1 SD_5 ? 0 +5 N 20 1204666 1204667 1204668 OR 1 RAMP_ON 5n20ora 0 +5 N 20 1204666 1204667 1204669 QU 5 QUEUE 5n20ora 0 +5 N 20 1204666 1204667 1204670 DM 3 DEMAND 5n20ora 0 +5 N 20 1204666 1204667 1204671 PA 4 PASSAGE 5n20ora 0 +5 N 20 1204666 1204672 1204673 ML 1 ML_1 5n20ml 5 +5 N 20 1204666 1204672 1204674 ML 2 ML_2 5n20ml 4 +5 N 20 1204666 1204672 1204675 ML 3 ML_3 5n20ml 3 +5 N 20 1204666 1204672 1204676 ML 4 ML_4 5n20ml 2 +5 N 20 1204666 1204672 1204677 ML 5 ML_5 5n20ml 1 +5 N 20 1204666 1204678 1204679 FR 1 RAMP_OFF 5n20fr 1 +5 N 20 1204666 1211117 1204680 HV 1 SD_1 5n20hv 2 +5 N 20 1204666 1211117 1211113 HV 2 SD_2 5n20hv 1 +5 N 20 1204666 1204667 1211114 OR 2 RAMP_HOV 5n20ora 0 +5 N 20 1204666 1211118 1211115 CD 1 COLL_DIST_1 5n20cd 2 +5 N 20 1204666 1211118 1211116 CD 2 COLL_DIST_2 5n20cd 1 +5 N 20.23 1204681 1204682 1204683 ML 1 ML_1 5n20.23ml 5 +5 N 20.23 1204681 1204682 1204684 ML 2 ML_2 5n20.23ml 4 +5 N 20.23 1204681 1204682 1204685 ML 3 ML_3 5n20.23ml 3 +5 N 20.23 1204681 1204682 1204686 ML 4 ML_4 5n20.23ml 2 +5 N 20.23 1204681 1204682 1204687 ML 5 ML_5 5n20.23ml 1 +5 S 20.23 1204681 1204688 1204689 OS 1 OS_1 5s20.23ml 5 +5 S 20.23 1204681 1204688 1204690 OS 2 OS_2 5s20.23ml 4 +5 S 20.23 1204681 1204688 1204692 OS 4 OS_4 5s20.23ml 3 +5 S 20.23 1204681 1204688 1204693 OS 5 OS_5 5s20.23ml 1 +5 N 20.23 1204681 1210271 1210262 CD 1 COLL_DIST_1 5n20.23cd 4 +5 N 20.23 1204681 1210271 1210263 CD 2 COLL_DIST_2 5n20.23cd 3 +5 N 20.23 1204681 1210271 1210264 CD 3 SD_5 5n20.23cd 2 +5 N 20.23 1204681 1210271 1210265 CD 4 SD_6 5n20.23cd 1 +5 N 20.23 1204681 1210270 1210266 HV 1 SD_1 5n20.23hv 2 +5 N 20.23 1204681 1210270 1210267 HV 2 SD_2 5n20.23hv 1 +5 S 20.23 1204681 1210272 1210268 OH 1 SD_3 5s20.23hv 1 +5 S 20.23 1204681 1210272 1210269 OH 2 SD_4 5n20.23ml 6 +5 S 20.24 1204681 1204688 1204691 OS 3 OS_3 5s20.23ml 2 +5 N 20.59 1204696 1204697 1208301 ML 1 ML_1 5n20.59ml 6 +5 N 20.59 1204696 1204697 1208302 ML 2 ML_2 5n20.59ml 5 +5 N 20.59 1204696 1204697 1208303 ML 3 ML_3 5n20.59ml 4 +5 N 20.59 1204696 1204697 1208304 ML 4 ML_4 5n20.59ml 3 +5 S 20.59 1204694 1204695 1208305 ML 1 ML_1 5s20.59ml 6 +5 S 20.59 1204694 1204695 1208306 ML 2 ML_2 5s20.59ml 5 +5 S 20.59 1204694 1204695 1208307 ML 3 ML_3 5s20.59ml 4 +5 S 20.59 1204694 1204695 1208308 ML 4 ML_4 5s20.59ml 3 +5 S 20.59 1204694 1204695 1208309 ML 5 ML_5 5s20.59ml 2 +5 S 20.59 1204694 1204695 1210243 ML 6 ML_6 5s20.59ml 1 +5 S 20.59 1204694 1210256 1210244 CD 1 COLL_DIST_1 5s20.59cd 3 +5 S 20.59 1204694 1210256 1210245 CD 2 COLL_DIST_2 5s20.59cd 2 +5 S 20.59 1204694 1210256 1210246 CD 3 SD_3 5s20.59cd 1 +5 S 20.59 1204694 1210254 1210247 DM 1 DEMAND 5s20.59or 0 +5 S 20.59 1204694 1210254 1210248 PA 2 PASSAGE 5s20.59or 0 +5 S 20.59 1204694 1210254 1210249 QU 3 QUEUE 5s20.59or 0 +5 S 20.59 1204694 1210254 1210251 OR 4 RAMP_ON 5s20.59or 0 +5 S 20.59 1204694 1210255 1210252 HV 1 SD_1 5s20.59hv 2 +5 S 20.59 1204694 1210255 1210253 HV 2 SD_2 5s20.59hv 1 +5 N 20.59 1204696 1204697 1211119 ML 5 ML_5 5n20.59ml 2 +5 N 20.59 1204696 1204697 1211120 ML 6 ML_6 5n20.59ml 1 +5 N 20.59 1204696 1211133 1211121 HV 1 SD_1 5n20.59hv 1 +5 N 20.59 1204696 1211133 1211122 HV 2 SD_2 5n20.59hv_2 1 +5 N 20.59 1204696 1211134 1211123 OR 1 RAMP_ON 5n20.59or 0 +5 N 20.59 1204696 1211134 1211124 PA 2 PASSAGE 5n20.59or 0 +5 N 20.59 1204696 1211134 1211125 DM 3 DEMAND 5n20.59or 0 +5 N 20.59 1204696 1211134 1211126 QU 4 QUEUE 5n20.59or 0 +5 N 20.59 1204696 1211136 1211128 CD 1 COLL_DIST_1 5n20.59cd 2 +5 N 20.59 1204696 1211136 1211129 CD 2 COLL_DIST_2 5n20.59cd 1 +5 N 20.59 1204696 1211135 1211131 FR 1 RAMP_OFF 5n20.59fr 1 +5 N 20.59 1204696 1211135 1211132 FR 3 SD_3 5n20.59fr 1 +5 N 20.94 1204698 1204699 1208310 ML 1 ML_1 5n20.94ml 3 +5 N 20.94 1204698 1204699 1208311 ML 2 ML_2 5n20.94ml 2 +5 N 20.94 1204698 1204699 1208312 ML 3 ML_3 5n20.94ml 1 +5 N 20.94 1204698 1211146 1208313 FF 1 SD_2 5n20.94ml 3 +5 N 20.94 1204698 1211147 1211137 DM 4 DEMAND 5n20.94or 0 +5 N 20.94 1204698 1211147 1211138 PA 3 PASSAGE 5n20.94or 0 +5 N 20.94 1204698 1211147 1211139 OR 1 RAMP_ON 5n20.94or 0 +5 N 20.94 1204698 1211147 1211140 OR 2 RAMP_HOV 5n20.94or 0 +5 N 20.94 1204698 1211147 1211141 QU 5 QUEUE 5n20.94or 0 +5 N 20.94 1204698 1211146 1211142 FF 2 SD_3 5n20.94ml 2 +5 N 20.94 1204698 1211146 1211143 FF 3 SD_4 5n20.94ml 1 +5 N 20.94 1204698 1211148 1211144 CD 1 COLL_DIST_1 5n20.94cd 2 +5 N 20.94 1204698 1211148 1211145 CD 2 COLL_DIST_2 5n20.94cd 1 +5 S 20.95 1204700 1204701 1208314 ML 1 ML_1 5s20.95ml 6 +5 S 20.95 1204700 1204701 1208315 ML 2 ML_2 5s20.95ml 5 +5 S 20.95 1204700 1204701 1208316 ML 3 ML_3 5s20.95ml 4 +5 S 20.95 1204700 1204701 1208317 ML 4 ML_4 5s20.95ml 3 +5 S 20.95 1204700 1204701 1210225 ML 5 ML_5 5s20.95ml 2 +5 S 20.95 1204700 1204701 1210226 ML 6 ML_6 5s20.95ml 1 +5 S 20.95 1204700 1210257 1210227 DM 1 DEMAND 5s20.95or 0 +5 S 20.95 1204700 1210257 1210228 PA 2 PASSAGE 5s20.95or 0 +5 S 20.95 1204700 1210257 1210229 QU 3 QUEUE 5s20.95or 0 +5 S 20.95 1204700 1210257 1210230 OR 4 RAMP_ON 5s20.95or 0 +5 S 20.95 1204700 1210259 1210231 FR 1 RAMP_OFF 5s20.95fr_2 1 +5 S 20.95 1204700 1210257 1210233 RH 5 RAMP_HOV 5s20.95or 0 +5 S 20.95 1204700 1210259 1210234 FR 2 SD_3 5s20.95fr 2 +5 S 20.95 1204700 1210259 1210235 FR 3 SD_4 5s20.95fr 1 +5 S 20.95 1204700 1210260 1210237 CD 1 SD_2 5s20.95cd_2 2 +5 S 20.95 1204700 1210260 1210238 CD 2 SD_1 5s20.95cd_2 1 +5 S 20.95 1204700 1210261 1210239 FC 1 SD_6 5s20.95cd_1 1 +5 S 20.95 1204700 1210258 1210240 CD 1 COLL_DIST_1 5s20.95ff 3 +5 S 20.95 1204700 1210258 1210241 CD 2 COLL_DIST_2 5s20.95ff 2 +5 S 20.95 1204700 1210258 1210242 CD 3 SD_5 5s20.95ff 1 +5 S 21.25 1204702 1211853 1211154 ML 1 ML_1 ? 0 +5 S 21.25 1204702 1211853 1211155 ML 2 ML_2 ? 0 +5 S 21.25 1204702 1211853 1211156 ML 3 ML_3 ? 0 +5 N 21.25 1204702 1204703 1211157 OS 1 OS_1 5n21.25os 3 +5 N 21.25 1204702 1204703 1211158 OS 2 OS_2 5n21.25os 2 +5 N 21.25 1204702 1204703 1211159 OS 3 OS_3 5n21.25os 1 +5 N 21.25 1204702 1211856 1211160 OH 1 SD_2 5n21.25oh 1 +5 S 21.25 1204702 1211854 1211161 HV 1 SD_1 ? 0 +5 S 21.25 1204702 1211855 1211162 FF 1 SD_3 5s20.95cd 3 +5 S 21.25 1204702 1211855 1211163 FF 2 SD_4 5s20.95cd 2 +5 S 21.25 1204702 1211855 1211164 FF 3 SD_5 5s20.95cd 1 +5 N 21.25 1204702 1211857 1211165 OC 1 COLL_DIST_1 5n21.25cd 2 +5 N 21.25 1204702 1211857 1211166 OC 2 COLL_DIST_2 5n21.25cd 1 +5 S 21.92 1204706 1204707 1204708 OR 1 RAMP_ON 5s21.92ora 0 +5 S 21.92 1204706 1204707 1204709 QU 2 QUEUE 5s21.92ora 0 +5 S 21.92 1204706 1204707 1204710 DM 3 DEMAND 5s21.92ora 0 +5 S 21.92 1204706 1204707 1204711 PA 4 PASSAGE 5s21.92ora 0 +5 S 21.92 1204706 1211151 1204713 FC 1 COLL_DIST_1 5s21.92cd 2 +5 S 21.92 1204706 1204714 1204715 HV 1 SD_1 5s21.92hv 1 +5 S 21.92 1204706 1204716 1204717 ML 1 ML_1 5s22.1ml 3 +5 S 21.92 1204706 1204716 1204718 ML 2 ML_2 5s22.1ml 2 +5 S 21.92 1204706 1204716 1204719 ML 3 ML_3 5s22.1ml 1 +5 S 21.92 1204706 1211151 1204720 FC 2 SD_3 5s21.92cd 1 +5 N 22.1 1204721 1204722 1204723 OR 1 RAMP_ON 5n22.1ora 0 +5 N 22.1 1204721 1204722 1204724 QU 2 QUEUE 5n22.1ora 0 +5 N 22.1 1204721 1204722 1204725 DM 3 DEMAND 5n22.1ora 0 +5 N 22.1 1204721 1204722 1204726 PA 4 PASSAGE 5n22.1ora 0 +5 N 22.1 1204721 1204727 1204728 FR 1 RAMP_OFF 5n22.1fr 1 +5 N 22.1 1204721 1204729 1204730 HV 1 SD_1 5n22.1hv 1 +5 N 22.1 1204721 1204731 1204732 ML 1 ML_1 5n22.1ml 4 +5 N 22.1 1204721 1204731 1204733 ML 2 ML_2 5n22.1ml 3 +5 N 22.1 1204721 1204731 1204734 ML 3 ML_3 5n22.1ml 2 +5 N 22.1 1204721 1204731 1204735 ML 4 ML_4 5n22.1ml 1 +5 N 22.1 1204721 1204731 1204736 ML 5 ML_5 ? 0 +5 N 22.1 1204721 1208955 1208956 OH 1 SD_2 ? 0 +5 S 22.1 1204721 1204712 1211149 FR 1 SD_4 5s21.92fr 2 +5 S 22.1 1204721 1204712 1211150 FR 2 SD_5 5s21.92fr 1 +5 S 22.14 1204721 1204737 1204738 OS 1 OS_1 5s22.14ml 4 +5 S 22.14 1204721 1204737 1204739 OS 2 OS_2 5s22.14ml 3 +5 S 22.14 1204721 1204737 1204740 OS 3 OS_3 5s22.14ml 2 +5 S 22.14 1204721 1204737 1204741 OS 4 OS_4 5s22.14ml 1 +5 N 22.2 1204742 1204743 1204744 OR 1 RAMP_ON 5n22.2ora 0 +5 N 22.2 1204742 1204743 1204745 QU 2 QUEUE 5n22.2ora 0 +5 N 22.2 1204742 1204743 1204746 DM 3 DEMAND 5n22.2ora 0 +5 N 22.2 1204742 1204743 1204747 PA 4 PASSAGE 5n22.2ora 0 +5 N 22.2 1204742 1204748 1204749 HV 1 SD_1 5n22.2hv 1 +5 N 22.2 1204742 1204750 1204751 ML 1 ML_1 5n22.2ml 4 +5 N 22.2 1204742 1204750 1204752 ML 2 ML_2 5n22.2ml 3 +5 N 22.2 1204742 1204750 1204753 ML 3 ML_3 5n22.2ml 2 +5 N 22.2 1204742 1204750 1204754 ML 4 ML_4 5n22.2ml 1 +5 N 22.2 1204742 1204750 1204755 ML 5 ML_5 ? 0 +5 N 22.75 1204756 1204757 1204758 OH 1 SD_2 5n22.75hv 1 +5 S 22.75 1204756 1204759 1204760 HV 1 SD_1 5s22.75hv 1 +5 S 22.75 1204756 1204761 1204762 ML 1 ML_1 5s22.75ml 4 +5 S 22.75 1204756 1204761 1204763 ML 2 ML_2 5s22.75ml 3 +5 S 22.75 1204756 1204761 1204764 ML 3 ML_3 5s22.75ml 2 +5 S 22.75 1204756 1204761 1204765 ML 4 ML_4 5s22.75ml 1 +5 N 22.75 1204756 1204766 1204767 OS 1 OS_1 5n22.75ml 5 +5 N 22.75 1204756 1204766 1204768 OS 2 OS_2 5n22.75ml 4 +5 N 22.75 1204756 1204766 1204769 OS 3 OS_3 5n22.75ml 2 +5 N 22.75 1204756 1204766 1204770 OS 4 OS_4 5n22.75ml 2 +5 N 22.75 1204756 1204766 1204771 OS 5 OS_5 5n22.75ml 1 +5 N 22.75 1204756 1204772 1204773 HN 1 RAMP_ON 5n22.75ff 1 +5 S 22.75 1204756 1204774 1204775 HF 1 RAMP_OFF ? 0 +5 S 22.75 1204756 1212715 1212713 FF 1 SD_4 5s22.75ff 1 +5 S 22.75 1204756 1212715 1212714 FF 2 SD_5 ? 0 +5 S 23.05 1204776 1204777 1204778 HV 1 SD_1 5s23.05hv 1 +5 S 23.05 1204776 1204779 1204780 OH 1 SD_2 ? 0 +5 S 23.05 1204776 1204781 1204782 ML 1 ML_1 5s23.05ml 5 +5 S 23.05 1204776 1204781 1204783 ML 2 ML_2 5s23.05ml 4 +5 S 23.05 1204776 1204781 1204784 ML 3 ML_3 5s23.05ml 3 +5 S 23.05 1204776 1204781 1204785 ML 4 ML_4 5s23.05ml 2 +5 S 23.05 1204776 1204781 1204786 ML 5 ML_5 5s23.05ml 1 +5 N 23.05 1204776 1204787 1204788 OS 1 OS_1 ? 0 +5 N 23.05 1204776 1204787 1204789 OS 2 OS_2 ? 0 +5 N 23.05 1204776 1204787 1204790 OS 3 OS_3 ? 0 +5 N 23.05 1204776 1204787 1204791 OS 4 OS_4 ? 0 +5 N 23.05 1204776 1204787 1204792 OS 5 OS_5 ? 0 +5 N 23.05 1204776 1212730 1212728 FO 1 SD_3 ? 0 +5 N 23.05 1204776 1212730 1212729 FO 2 SD_4 ? 0 +5 S 23.1 1204793 1204794 1204795 FR 1 RAMP_OFF ? 0 +5 S 23.1 1204793 1204796 1204797 HV 1 SD_1 ? 0 +5 S 23.1 1204793 1204798 1204799 ML 1 ML_1 ? 0 +5 S 23.1 1204793 1204798 1204800 ML 2 ML_2 ? 0 +5 S 23.1 1204793 1204798 1204801 ML 3 ML_3 ? 0 +5 N 23.2 1204802 1204803 1204804 FF 1 SD_2 5n23.2ff 2 +5 N 23.2 1204802 1204803 1204805 FF 2 SD_3 5n23.2ff 1 +5 N 23.2 1204802 1204806 1204807 HV 1 SD_1 5n23.2hv 1 +5 N 23.2 1204802 1204808 1204809 ML 1 ML_1 5n23.2ml 4 +5 N 23.2 1204802 1204808 1204810 ML 2 ML_2 5n23.2ml 3 +5 N 23.2 1204802 1204808 1204811 ML 3 ML_3 5n23.2ml 2 +5 N 23.2 1204802 1204808 1204812 ML 4 ML_4 5n23.2ml 1 +5 S 23.2 1204802 1212706 1212704 FF 1 SD_4 5s23.05ff 2 +5 S 23.2 1204802 1212706 1212705 FF 2 SD_5 5s23.05ff 1 +5 S 23.5 1204813 1204814 1204815 HV 1 SD_1 5s23.5hv 1 +5 S 23.5 1204813 1204816 1204817 ML 1 ML_1 5s23.5ml 6 +5 S 23.5 1204813 1204816 1204818 ML 2 ML_2 5s23.5ml 5 +5 S 23.5 1204813 1204816 1204819 ML 3 ML_3 5s23.5ml 4 +5 S 23.5 1204813 1204816 1204820 ML 4 ML_4 5s23.5ml 3 +5 S 23.5 1204813 1204816 1204821 ML 5 ML_5 5s23.5ml 2 +5 S 23.5 1204813 1204816 1204822 ML 6 ML_6 5s23.5ml 1 +5 N 23.5 1204813 1204823 1204824 OH 1 SD_2 5n23.5hv 1 +5 N 23.5 1204813 1204825 1204826 OS 1 OS_1 5n23.5ml 6 +5 N 23.5 1204813 1204825 1204827 OS 2 OS_2 5n23.5ml 5 +5 N 23.5 1204813 1204825 1204828 OS 3 OS_3 5n23.5ml 4 +5 N 23.5 1204813 1204825 1204829 OS 4 OS_4 5n23.5ml 3 +5 N 23.5 1204813 1204825 1204830 OS 5 OS_5 5n23.5ml 2 +5 N 23.5 1204813 1204825 1204831 OS 6 OS_6 5n23.5ml 1 +5 S 23.69 1204832 1204833 1204834 OR 1 RAMP_ON 5s23.69ora 0 +5 S 23.69 1204832 1204833 1204835 QU 2 QUEUE 5s23.69ora 0 +5 S 23.69 1204832 1204833 1204836 DM 3 DEMAND 5s23.69ora 0 +5 S 23.69 1204832 1204833 1204837 PA 4 PASSAGE 5s23.69ora 0 +5 S 23.69 1204832 1204833 1204838 RH 5 RAMP_HOV 5s23.69ora 0 +5 S 23.69 1204832 1204839 1204840 HV 1 SD_1 5s23.69hv 1 +5 S 23.69 1204832 1204841 1204842 ML 1 ML_1 5s23.69ml 5 +5 S 23.69 1204832 1204841 1204843 ML 2 ML_2 5s23.69ml 4 +5 S 23.69 1204832 1204841 1204844 ML 3 ML_3 5s23.69ml 3 +5 S 23.69 1204832 1204841 1204845 ML 4 ML_4 5s23.69ml 2 +5 S 23.69 1204832 1204841 1204846 ML 5 ML_5 5s23.69ml 1 +5 N 24.05 1204847 1204848 1204849 OR 1 RAMP_ON 5n24.05ora 0 +5 N 24.05 1204847 1204848 1204850 QU 2 QUEUE 5n24.05ora 0 +5 N 24.05 1204847 1204848 1204851 DM 3 DEMAND 5n24.05ora 0 +5 N 24.05 1204847 1204848 1204852 PA 4 PASSAGE 5n24.05ora 0 +5 N 24.05 1204847 1204848 1204853 RH 5 RAMP_HOV 5n24.05ora 0 +5 N 24.05 1204847 1204854 1204855 FR 1 RAMP_OFF 5n24.05fr 1 +5 N 24.05 1204847 1204854 1204856 FR 2 SD_2 5n24.05fr 2 +5 S 24.05 1204847 1204857 1204858 OF 1 SD_4 5s24.05fr 1 +5 N 24.05 1204847 1204859 1204860 HV 1 SD_1 5n24.05hv 1 +5 N 24.05 1204847 1204861 1204862 ML 1 ML_1 5n24.05ml 5 +5 N 24.05 1204847 1204861 1204863 ML 2 ML_2 5n24.05ml 4 +5 N 24.05 1204847 1204861 1204864 ML 3 ML_3 5n24.05ml 3 +5 N 24.05 1204847 1204861 1204865 ML 4 ML_4 5n24.05ml 2 +5 N 24.05 1204847 1204861 1204866 ML 5 ML_5 5n24.05ml 1 +5 S 24.05 1204847 1204867 1204868 OH 1 SD_3 5s24.05ml 6 +5 S 24.05 1204847 1204869 1204870 OS 1 OS_1 5s24.05ml 5 +5 S 24.05 1204847 1204869 1204871 OS 2 OS_2 5s24.05ml 4 +5 S 24.05 1204847 1204869 1204872 OS 3 OS_3 5s24.05ml 3 +5 S 24.05 1204847 1204869 1204873 OS 4 OS_4 5s24.05ml 2 +5 S 24.05 1204847 1204869 1204874 OS 5 OS_5 5s24.05ml 1 +5 N 24.5 1204875 1204876 1204877 HV 1 SD_1 5n24.5hv 1 +5 N 24.5 1204875 1204878 1204879 ML 1 ML_1 5n24.5ml 5 +5 N 24.5 1204875 1204878 1204880 ML 2 ML_2 5n24.5ml 4 +5 N 24.5 1204875 1204878 1204881 ML 3 ML_3 5n24.5ml 3 +5 N 24.5 1204875 1204878 1204882 ML 4 ML_4 5n24.5ml 2 +5 N 24.5 1204875 1204878 1204883 ML 5 ML_5 5n24.5ml 1 +5 S 24.5 1204875 1204884 1204885 OH 1 SD_2 5s24.5hv 1 +5 S 24.5 1204875 1204886 1204887 OS 1 OS_1 5s24.5ml 5 +5 S 24.5 1204875 1204886 1204888 OS 2 OS_2 5s24.5ml 4 +5 S 24.5 1204875 1204886 1204889 OS 3 OS_3 5s24.5ml 3 +5 S 24.5 1204875 1204886 1204890 OS 4 OS_4 5s24.5ml 2 +5 S 24.5 1204875 1204886 1204891 OS 5 OS_5 5s24.5ml 1 +5 S 24.84 1204892 1204893 1204894 OR 1 RAMP_ON 5s24.84ora 0 +5 S 24.84 1204892 1204893 1204895 QU 2 QUEUE 5s24.84ora 0 +5 S 24.84 1204892 1204893 1204896 DM 3 DEMAND 5s24.84ora 0 +5 S 24.84 1204892 1204893 1204897 PA 4 PASSAGE 5s24.84ora 0 +5 S 24.84 1204892 1204893 1204898 RH 5 RAMP_HOV 5s24.84ora 0 +5 S 24.84 1204892 1204899 1204900 FR 1 RAMP_OFF 5s24.84fr 1 +5 S 24.84 1204892 1204899 1204901 FR 2 SD_2 ? 0 +5 S 24.84 1204892 1204902 1204903 HV 1 SD_1 5s24.84hv 1 +5 S 24.84 1204892 1204904 1204905 ML 1 ML_1 5s24.84ml 5 +5 S 24.84 1204892 1204904 1204906 ML 2 ML_2 5s24.84ml 4 +5 S 24.84 1204892 1204904 1204907 ML 3 ML_3 5s24.84ml 3 +5 S 24.84 1204892 1204904 1204908 ML 4 ML_4 5s24.84ml 2 +5 S 24.84 1204892 1204904 1204909 ML 5 ML_5 5s24.84ml 1 +5 S 24.84 1204892 1204910 1204911 OH 1 SD_3 ? 0 +5 N 25.08 1204912 1204913 1204914 OR 1 RAMP_ON 5n25.08ora 0 +5 N 25.08 1204912 1204913 1204915 QU 2 QUEUE 5n25.08ora 0 +5 N 25.08 1204912 1204913 1204916 DM 3 DEMAND 5n25.08ora 0 +5 N 25.08 1204912 1204913 1204917 PA 4 PASSAGE 5n25.08ora 0 +5 N 25.08 1204912 1204913 1204918 RH 5 RAMP_HOV 5n25.08ora 0 +5 N 25.08 1204912 1204919 1204920 FR 1 RAMP_OFF 5n25.08fr 2 +5 N 25.08 1204912 1204919 1204921 FR 2 SD_2 5n25.08fr 1 +5 N 25.08 1204912 1204922 1204923 HV 1 SD_1 5n25.08hv 1 +5 N 25.08 1204912 1204924 1204925 ML 4 ML_4 5n25.08ml 2 +5 N 25.08 1204912 1204924 1204926 ML 5 ML_5 5n25.08ml 1 +5 N 25.08 1204912 1204924 1204927 ML 3 ML_3 5n25.08ml 3 +5 N 25.08 1204912 1204924 1212843 ML 1 ML_1 5n25.08ml 5 +5 N 25.08 1204912 1204924 1212844 ML 2 ML_2 5n25.08ml 4 +5 N 25.15 1204928 1204929 1204930 OR 1 RAMP_ON 5n25.15ora 0 +5 N 25.15 1204928 1204929 1204931 QU 2 QUEUE 5n25.15ora 0 +5 N 25.15 1204928 1204929 1204932 DM 3 DEMAND 5n25.15ora 0 +5 N 25.15 1204928 1204929 1204933 PA 4 PASSAGE 5n25.15ora 0 +5 N 25.15 1204928 1204929 1204934 RH 5 RAMP_HOV 5n25.15ora 0 +5 N 25.15 1204928 1204935 1204936 HV 1 SD_1 5n25.15hv 1 +5 N 25.15 1204928 1204937 1204938 ML 4 ML_4 5n25.15ml 2 +5 N 25.15 1204928 1204937 1204939 ML 5 ML_5 5n25.15ml 1 +5 N 25.15 1204928 1204937 1204940 ML 3 ML_3 5n25.15ml 3 +5 N 25.15 1204928 1204937 1212845 ML 1 ML_1 5n25.15ml 5 +5 N 25.15 1204928 1204937 1212846 ML 2 ML_2 5n25.15ml 4 +5 S 25.8 1204941 1204942 1204943 HV 1 SD_1 5s25.8hv 1 +5 S 25.8 1204941 1204944 1204945 ML 1 ML_1 5s25.8ml 5 +5 S 25.8 1204941 1204944 1204946 ML 2 ML_2 5s25.8ml 4 +5 S 25.8 1204941 1204944 1204947 ML 3 ML_3 5s25.8ml 3 +5 S 25.8 1204941 1204944 1204948 ML 4 ML_4 5s25.8ml 2 +5 S 25.8 1204941 1204944 1204949 ML 5 ML_5 5s25.8ml 1 +5 N 25.8 1204941 1204950 1204951 OS 1 OS_1 5n25.8ml 5 +5 N 25.8 1204941 1204950 1204952 OS 2 OS_2 5n25.8ml 4 +5 N 25.8 1204941 1204950 1204953 OS 3 OS_3 5n25.8ml 3 +5 N 25.8 1204941 1204950 1204954 OS 4 OS_4 5n25.8ml 2 +5 N 25.8 1204941 1204950 1204955 OS 5 OS_5 5n25.8ml 1 +5 N 25.8 1204941 1204956 1204957 OH 1 SD_2 5n25.8hv 1 +5 S 26.35 1204958 1204959 1204960 OR 1 RAMP_ON 5s26.35ora 0 +5 S 26.35 1204958 1204959 1204961 QU 2 QUEUE 5s26.35ora 0 +5 S 26.35 1204958 1204959 1204962 DM 3 DEMAND 5s26.35ora 0 +5 S 26.35 1204958 1204959 1204963 PA 4 PASSAGE 5s26.35ora 0 +5 S 26.35 1204958 1204959 1204964 RH 5 RAMP_HOV 5s26.35ora 0 +5 S 26.35 1204958 1204965 1204966 HV 1 SD_1 5s26.35hv 1 +5 S 26.35 1204958 1204967 1204968 ML 1 ML_1 5s26.35ml 5 +5 S 26.35 1204958 1204967 1204969 ML 2 ML_2 5s26.35ml 4 +5 S 26.35 1204958 1204967 1204970 ML 3 ML_3 5s26.35ml 3 +5 S 26.35 1204958 1204967 1204971 ML 4 ML_4 5s26.35ml 2 +5 S 26.35 1204958 1204967 1204972 ML 5 ML_5 5s26.35ml 1 +5 N 26.56 1204973 1204974 1204975 OR 1 RAMP_ON 5n26.56ora 0 +5 N 26.56 1204973 1204974 1204976 QU 2 QUEUE 5n26.56ora 0 +5 N 26.56 1204973 1204974 1204977 DM 3 DEMAND 5n26.56ora 0 +5 N 26.56 1204973 1204974 1204978 PA 4 PASSAGE 5n26.56ora 0 +5 N 26.56 1204973 1204980 1204981 HV 1 SD_1 5n26.56hv 1 +5 N 26.56 1204973 1204982 1204983 ML 1 ML_1 5n26.56ml 5 +5 N 26.56 1204973 1204982 1204984 ML 2 ML_2 5n26.56ml 4 +5 N 26.56 1204973 1204982 1204985 ML 3 ML_3 5n26.56ml 3 +5 N 26.56 1204973 1204982 1204986 ML 4 ML_4 5n26.56ml 2 +5 N 26.56 1204973 1204982 1204987 ML 5 ML_5 5n26.56ml 1 +5 S 26.66 1204988 1204989 1204990 QU 1 QUEUE 5s26.66ora 0 +5 S 26.66 1204988 1204989 1204991 DM 2 DEMAND 5s26.66ora 0 +5 S 26.66 1204988 1204989 1204992 PA 3 PASSAGE 5s26.66ora 0 +5 S 26.66 1204988 1204993 1204994 FR 1 RAMP_OFF 5s26.66fr 1 +5 S 26.66 1204988 1204995 1204996 HV 1 SD_1 5s26.66hv 1 +5 S 26.66 1204988 1204997 1204998 ML 1 ML_1 5s26.66ml 5 +5 S 26.66 1204988 1204997 1204999 ML 2 ML_2 5s26.66ml 4 +5 S 26.66 1204988 1204997 1205000 ML 3 ML_3 5s26.66ml 3 +5 S 26.66 1204988 1204997 1205001 ML 4 ML_4 5s26.66ml 2 +5 S 26.66 1204988 1204997 1205002 ML 5 ML_5 5s26.66ml 1 +5 N 26.81 1205003 1205004 1205005 QU 1 QUEUE 5n26.81ora 0 +5 N 26.81 1205003 1205004 1205006 DM 2 DEMAND 5n26.81ora 0 +5 N 26.81 1205003 1205004 1205007 PA 3 PASSAGE 5n26.81ora 0 +5 N 26.81 1205003 1205008 1205009 OF 1 SD_3 5n26.56fr 1 +5 N 26.81 1205003 1205010 1205011 HV 1 SD_1 5n26.81hv 1 +5 N 26.81 1205003 1205012 1205013 ML 1 ML_1 5n26.81ml 6 +5 N 26.81 1205003 1205012 1205014 ML 2 ML_2 5n26.81ml 5 +5 N 26.81 1205003 1205012 1205015 ML 3 ML_3 5n26.81ml 4 +5 N 26.81 1205003 1205012 1205016 ML 4 ML_4 5n26.81ml 3 +5 N 26.81 1205003 1205012 1205017 ML 5 ML_5 5n26.81ml 2 +5 N 26.81 1205003 1205012 1205018 ML 6 ML_6 5n26.81ml 1 +5 S 27.43 1205019 1205020 1205021 OR 1 RAMP_ON 5s27.43ora 0 +5 S 27.43 1205019 1205020 1205022 QU 2 QUEUE 5s27.43ora 0 +5 S 27.43 1205019 1205020 1205023 DM 3 DEMAND 5s27.43ora 0 +5 S 27.43 1205019 1205020 1205024 PA 4 PASSAGE 5s27.43ora 0 +5 S 27.43 1205019 1205020 1205025 RH 5 RAMP_HOV 5s27.43ora 0 +5 S 27.43 1205019 1205026 1205027 HV 1 SD_1 5s27.43hv 1 +5 S 27.43 1205019 1205028 1205029 ML 1 ML_1 5s27.43ml 6 +5 S 27.43 1205019 1205028 1205030 ML 2 ML_2 5s27.43ml 5 +5 S 27.43 1205019 1205028 1205031 ML 3 ML_3 5s27.43ml 4 +5 S 27.43 1205019 1205028 1205032 ML 4 ML_4 5s27.43ml 3 +5 S 27.43 1205019 1205028 1205033 ML 5 ML_5 5s27.43ml 2 +5 S 27.43 1205019 1205028 1212847 ML 6 ML_6 5s27.43ml 1 +5 N 27.55 1205034 1205035 1205036 OR 1 RAMP_ON 5n27.55ora 0 +5 N 27.55 1205034 1205035 1205037 QU 2 QUEUE 5n27.55ora 0 +5 N 27.55 1205034 1205035 1205038 DM 3 DEMAND 5n27.55ora 0 +5 N 27.55 1205034 1205035 1205039 PA 4 PASSAGE 5n27.55ora 0 +5 N 27.55 1205034 1205035 1205040 RH 5 RAMP_HOV 5n27.55ora 0 +5 N 27.55 1205034 1205041 1205042 FR 1 RAMP_OFF 5n27.55fr 1 +5 N 27.55 1205034 1205045 1205048 ML 3 ML_3 5n27.55ml 3 +5 N 27.55 1205034 1205045 1205049 ML 4 ML_4 5n27.55ml 2 +5 N 27.55 1205034 1205045 1205050 ML 5 ML_5 5n27.55ml 1 +5 S 27.7 1205051 1205052 1205053 OR 1 RAMP_ON 5s27.7ora 0 +5 S 27.7 1205051 1205052 1205054 QU 2 QUEUE 5s27.7ora 0 +5 S 27.7 1205051 1205052 1205055 DM 3 DEMAND 5s27.7ora 0 +5 S 27.7 1205051 1205052 1205056 PA 4 PASSAGE 5s27.7ora 0 +5 S 27.7 1205051 1205052 1205057 RH 5 RAMP_HOV 5s27.7ora 0 +5 S 27.7 1205051 1205058 1205059 FR 1 RAMP_OFF 5s27.7fr 1 +5 S 27.7 1205051 1205062 1205066 ML 4 ML_4 5s27.7ml 2 +5 S 27.7 1205051 1205062 1205067 ML 5 ML_5 5s27.7ml 1 +5 N 27.7 1205068 1205071 1205075 ML 4 ML_4 5n27.56ml 3 +5 N 27.7 1205068 1205071 1205076 ML 5 ML_5 5n27.56ml 2 +5 N 27.7 1205068 1210814 1210807 DM 1 DEMAND 5n27.56ora 0 +5 N 27.7 1205068 1210814 1210808 PA 2 PASSAGE 5n27.56ora 0 +5 N 27.7 1205068 1210814 1210809 QU 3 QUEUE 5n27.56ora 0 +5 N 27.7 1205068 1205071 1210810 ML 6 ML_6 5n27.56ml 1 +5 N 27.7 1205068 1210814 1210811 OR 4 RAMP_ON 5n27.56ora 0 +5 N 27.7 1205068 1210814 1210813 RH 5 RAMP_HOV 5n27.56ora 0 +5 N 28.1 1205077 1205078 1205079 OR 1 RAMP_ON 5n28.1ora 0 +5 N 28.1 1205077 1205078 1205080 QU 2 QUEUE 5n28.1ora 0 +5 N 28.1 1205077 1205078 1205081 DM 3 DEMAND 5n28.1ora 0 +5 N 28.1 1205077 1205078 1205082 PA 4 PASSAGE 5n28.1ora 0 +5 N 28.1 1205077 1205078 1205083 RH 5 RAMP_HOV 5n28.1ora 0 +5 N 28.1 1205077 1205084 1205085 FR 1 RAMP_OFF 5n28.1fr 1 +5 N 28.1 1205077 1205086 1205087 HV 1 SD_1 5n28.1hv 1 +5 N 28.1 1205077 1205088 1205089 ML 1 ML_1 5n28.1ml 5 +5 N 28.1 1205077 1205088 1205090 ML 2 ML_2 5n28.1ml 4 +5 N 28.1 1205077 1205088 1205091 ML 3 ML_3 5n28.1ml 3 +5 N 28.1 1205077 1205088 1205092 ML 4 ML_4 5n28.1ml 2 +5 N 28.1 1205077 1205088 1205093 ML 5 ML_5 5n28.1ml 1 +5 S 28.35 1205094 1205095 1205096 OR 1 RAMP_ON 5s28.35ora 0 +5 S 28.35 1205094 1205095 1205097 QU 2 QUEUE 5s28.35ora 0 +5 S 28.35 1205094 1205095 1205098 DM 3 DEMAND 5s28.35ora 0 +5 S 28.35 1205094 1205095 1205099 PA 4 PASSAGE 5s28.35ora 0 +5 S 28.35 1205094 1205095 1205100 RH 5 RAMP_HOV 5s28.35ora 0 +5 S 28.35 1205094 1205101 1205102 FR 1 RAMP_OFF 5s28.35fr 1 +5 S 28.35 1205094 1205103 1205104 HV 1 SD_1 5s28.35hv 1 +5 S 28.35 1205094 1205105 1205106 ML 1 ML_1 5s28.35ml 5 +5 S 28.35 1205094 1205105 1205107 ML 2 ML_2 5s28.35ml 4 +5 S 28.35 1205094 1205105 1205108 ML 3 ML_3 5s28.35ml 3 +5 S 28.35 1205094 1205105 1205109 ML 4 ML_4 5s28.35ml 2 +5 S 28.35 1205094 1205105 1205110 ML 5 ML_5 5s28.35ml 1 +5 S 29.02 1205111 1205112 1205113 OR 1 RAMP_ON 5s29.02ora 0 +5 S 29.02 1205111 1205112 1205114 QU 2 QUEUE 5s29.02ora 0 +5 S 29.02 1205111 1205112 1205115 DM 3 DEMAND 5s29.02ora 0 +5 S 29.02 1205111 1205112 1205116 PA 4 PASSAGE 5s29.02ora 0 +5 S 29.02 1205111 1205112 1205117 RH 5 RAMP_HOV 5s29.02ora 0 +5 N 29.02 1205111 1208538 1205119 OF 1 SD_2 5n28.58fr 1 +5 S 29.02 1205111 1205120 1205121 HV 1 SD_1 ? 0 +5 S 29.02 1205111 1205122 1205123 ML 1 ML_1 5s29.79ml 6 +5 S 29.02 1205111 1205122 1205124 ML 2 ML_2 5s29.79ml 5 +5 S 29.02 1205111 1205122 1205125 ML 3 ML_3 5s29.79ml 4 +5 S 29.02 1205111 1205122 1205126 ML 4 ML_4 5s29.79ml 3 +5 S 29.02 1205111 1205122 1205127 ML 5 ML_5 5s29.79ml 2 +5 N 29.24 1205128 1205129 1205130 OR 1 RAMP_ON 5n29.24ora 0 +5 N 29.24 1205128 1205129 1205131 QU 2 QUEUE 5n29.24ora 0 +5 N 29.24 1205128 1205129 1205132 DM 3 DEMAND 5n29.24ora 0 +5 N 29.24 1205128 1205129 1205133 PA 4 PASSAGE 5n29.24ora 0 +5 N 29.24 1205128 1205129 1205134 RH 5 RAMP_HOV 5n29.24ora 0 +5 N 29.24 1205128 1205135 1205136 ML 1 ML_1 5n29.24ml 5 +5 N 29.24 1205128 1205135 1205137 ML 2 ML_2 5n29.24ml 4 +5 N 29.24 1205128 1205135 1205138 ML 3 ML_3 5n29.24ml 3 +5 N 29.24 1205128 1205135 1208493 ML 5 ML_5 5n29.24ml 1 +5 N 29.24 1205128 1205135 1208495 ML 4 ML_4 5n29.24ml 2 +5 N 29.24 1205128 1208537 1208534 HV 1 SD_1 5n29.24hv 1 +5 N 29.24 1205128 1208540 1208539 OF 1 SD_3 ? 0 +5 N 29.79 1205146 1205147 1205148 OR 1 RAMP_ON 5n29.79orb 0 +5 N 29.79 1205146 1205147 1205149 QU 2 QUEUE 5n29.79orb 0 +5 N 29.79 1205146 1205147 1205150 DM 3 DEMAND 5n29.79orb 0 +5 N 29.79 1205146 1205147 1205151 PA 4 PASSAGE 5n29.79orb 0 +5 N 29.79 1205146 1205152 1205153 ML 1 ML_1 5n29.79ml 5 +5 N 29.79 1205146 1205152 1205154 ML 2 ML_2 5n29.79ml 4 +5 N 29.79 1205146 1205152 1205155 ML 3 ML_3 5n29.79ml 3 +5 N 29.79 1205146 1205152 1208356 ML 4 ML_4 5n29.79ml 2 +5 N 29.79 1205146 1205152 1208357 ML 5 ML_5 5n29.79ml 1 +5 N 29.79 1205146 1208365 1208361 HV 1 SD_1 5n29.79hv 1 +5 N 29.79 1205146 1205139 1208501 OS 1 OS_1 5s29.79ml 6 +5 N 29.79 1205146 1205139 1208502 OS 2 OS_2 5s29.79ml 5 +5 N 29.79 1205146 1205139 1208503 OS 3 OS_3 5s29.79ml 4 +5 N 29.79 1205146 1205139 1208504 OS 4 OS_4 5s29.79ml 3 +5 N 29.79 1205146 1205139 1208505 OS 5 OS_5 5s29.79ml 2 +5 N 29.79 1205146 1205139 1208506 OS 6 OS_6 5s29.79ml 1 +5 N 29.79 1205146 1208962 1208507 OH 1 SD_2 5s29.79hv 1 +5 N 29.79 1205146 1208963 1208957 FO 1 COLL_DIST_1 ? 0 +5 N 29.79 1205146 1208963 1208958 FO 2 COLL_DIST_2 ? 0 +5 N 29.79 1205146 1208964 1208959 OF 1 SD_3 ? 0 +5 N 29.79 1205146 1208964 1208960 OF 2 SD_4 ? 0 +5 N 29.79 1205146 1212052 1208961 OF 1 SD_5 ? 0 +5 N 30 1205156 1205157 1205158 ML 1 ML_1 5n30ml 5 +5 N 30 1205156 1205157 1205159 ML 2 ML_2 5n30ml 4 +5 N 30 1205156 1205157 1205160 ML 3 ML_3 5n30ml 3 +5 N 30 1205156 1205157 1205161 ML 4 ML_4 5n30ml 2 +5 N 30 1205156 1205157 1205162 ML 5 ML_5 5n30ml 1 +5 S 30 1205156 1205157 1205163 ML 6 ML_6 5s29.79ml 1 +5 N 30 1205156 1208975 1208966 HV 1 SD_1 5n30ml 6 +5 S 30 1205156 1208976 1208969 OS 1 OS_1 5s30.2ml 5 +5 S 30 1205156 1208976 1208970 OS 2 OS_2 5s30.2ml 4 +5 S 30 1205156 1208976 1208971 OS 3 OS_3 5s30.2ml 3 +5 S 30 1205156 1208976 1208972 OS 4 OS_4 5s30.2ml 2 +5 S 30 1205156 1208977 1208974 OH 1 SD_2 5s30.2ml 1 +5 N 30.2 1205164 1205165 1208978 ML 1 ML_1 5n30.2ml 5 +5 N 30.2 1205164 1205165 1208979 ML 2 ML_2 5n30.2ml 4 +5 N 30.2 1205164 1205165 1208980 ML 3 ML_3 5n30.2ml 3 +5 N 30.2 1205164 1205165 1208981 ML 4 ML_4 5n30.2ml 2 +5 N 30.2 1205164 1205165 1208982 ML 5 ML_5 5n30.2ml 1 +5 N 30.2 1205164 1205166 1208983 OS 1 OS_1 5s30.2ml 5 +5 N 30.2 1205164 1205166 1208984 OS 2 OS_2 5s30.2ml 4 +5 N 30.2 1205164 1205166 1208985 OS 3 OS_3 5s30.2ml 3 +5 N 30.2 1205164 1205166 1208986 OS 4 OS_4 5s30.2ml 2 +5 N 30.2 1205164 1208989 1208987 HV 1 SD_1 5n30.2hv 1 +5 N 30.2 1205164 1208993 1208988 OH 1 SD_2 5s30.2ml 1 +5 N 30.2 1205164 1208990 1208991 FF 1 SD_3 5n30.2ff 1 +5 N 30.4 1205167 1205168 1208994 ML 1 ML_1 5n30.4ml 5 +5 N 30.4 1205167 1205168 1208995 ML 2 ML_2 5n30.4ml 4 +5 N 30.4 1205167 1205168 1208996 ML 3 ML_3 5n30.4ml 3 +5 N 30.4 1205167 1205168 1208997 ML 4 ML_4 5n30.4ml 2 +5 N 30.4 1205167 1205169 1208998 OS 1 OS_1 5s30.4ml 5 +5 N 30.4 1205167 1205169 1208999 OS 2 OS_2 5s30.4ml 4 +5 N 30.4 1205167 1205169 1209001 OS 3 OS_3 5s30.4ml 3 +5 N 30.4 1205167 1205169 1209003 OS 4 OS_4 5s30.4ml 2 +5 N 30.4 1205167 1205169 1209004 OS 5 OS_5 5s30.4ml 1 +5 N 30.4 1205167 1209011 1209005 HV 1 SD_1 5n30.4ml 1 +5 S 30.4 1205167 1209014 1209007 OH 1 SD_2 5s30.4hv 1 +5 N 30.4 1205167 1209012 1209008 FF 1 SD_3 5n30.4ffa 1 +5 N 30.4 1205167 1209012 1209009 FF 2 SD_4 5n30.4ffb 1 +5 N 30.4 1205167 1209013 1209010 FF 1 SD_5 5n30.4ffb 2 +5 S 30.6 1205172 1205173 1211174 HV 1 SD_4 5s30.6hv 1 +5 N 30.6 1205172 1205171 1211175 OH 1 SD_5 5n30.6hv 1 +5 S 30.9 1205176 1205177 1205178 OR 1 RAMP_ON 5s30.9orb 0 +5 S 30.9 1205176 1205177 1205179 QU 2 QUEUE 5s30.9orb 0 +5 S 30.9 1205176 1205177 1205180 DM 3 DEMAND 5s30.9orb 0 +5 N 30.9 1205176 1205177 1205181 PA 4 PASSAGE 5s30.9orb 0 +5 S 30.9 1205176 1205182 1205183 ML 1 ML_1 5s30.9ml 5 +5 S 30.9 1205176 1205182 1205184 ML 2 ML_2 5s30.9ml 4 +5 S 30.9 1205176 1205182 1205185 ML 3 ML_3 5s30.9ml 3 +5 S 30.9 1205176 1205182 1205186 ML 4 ML_4 5s30.9ml 2 +5 S 30.9 1205176 1205182 1205187 ML 5 ML_5 5s30.9ml 1 +5 N 30.9 1205176 1205175 1208318 OS 1 OS_1 5n30.9ml 5 +5 N 30.9 1205176 1205175 1208319 OS 2 OS_2 5n30.9ml 4 +5 N 30.9 1205176 1205175 1208320 OS 3 OS_3 5n30.9ml 3 +5 N 30.9 1205176 1205175 1208498 OS 4 OS_4 5n30.9ml 2 +5 N 30.9 1205176 1205175 1208500 OS 5 OS_5 5n30.9ml 1 +5 S 30.9 1205176 1209694 1209504 HV 1 SD_1 5s30.9hv 1 +5 N 30.9 1205176 1209693 1209505 OH 1 SD_6 5n30.9hv 1 +5 N 30.9 1205176 1209697 1209695 OF 2 SD_3 ? 0 +5 N 30.9 1205176 1209697 1209696 OF 1 RAMP_OFF 5n30.8fr 1 +5 S 30.9 1205176 1209840 1211152 HB 1 SD_5 ? 0 +5 N 30.9 1205176 1209841 1211153 FO 1 SD_4 ? 0 +5 N 31.1 1205188 1205193 1205194 ML 1 ML_1 5n31.23ml 5 +5 N 31.1 1205188 1205193 1205195 ML 2 ML_2 5n31.23ml 4 +5 N 31.1 1205188 1205193 1205196 ML 3 ML_3 5n31.23ml 3 +5 S 31.23 1205188 1205189 1205190 OS 1 OS_1 5s31.23ml 5 +5 S 31.23 1205188 1205189 1205191 OS 2 OS_2 5s31.23ml 4 +5 S 31.23 1205188 1205189 1205192 OS 3 OS_3 5s31.23ml 3 +5 N 31.23 1205188 1205193 1209711 ML 4 ML_4 5n31.23ml 2 +5 N 31.23 1205188 1205193 1209712 ML 5 ML_5 5n31.23ml 1 +5 N 31.23 1205188 1205189 1209713 OS 4 OS_4 5s31.23ml 2 +5 N 31.23 1205188 1205189 1209714 OS 5 OS_5 5s31.23ml 1 +5 N 31.23 1205188 1209726 1209715 DM 1 DEMAND 5n31.23ora 0 +5 N 31.23 1205188 1209726 1209716 PA 2 PASSAGE 5n31.23ora 0 +5 N 31.23 1205188 1209726 1209717 QU 3 QUEUE 5n31.23ora 0 +5 N 31.23 1205188 1209726 1209718 OR 4 RAMP_ON 5n31.23ora 0 +5 S 31.23 1205188 1209728 1209719 OH 1 SD_1 5s31.23hv 2 +5 S 31.23 1205188 1209728 1209720 OH 2 SD_2 5s31.23hv 1 +5 N 31.23 1205188 1209727 1209721 HV 1 SD_3 5n31.23hv 1 +5 S 31.23 1205188 1209731 1209723 OF 1 SD_4 5s31.23fr 2 +5 S 31.23 1205188 1209731 1209724 OF 2 SD_5 5s31.23fr 1 +5 N 31.23 1205188 1212741 1212737 HB 1 COLL_DIST_1 ? 0 +5 S 31.23 1205188 1212742 1212738 HB 1 SD_6 ? 0 +5 S 31.4 1205197 1205198 1205199 OH 1 SD_3 5n31.4hv 2 +5 S 31.4 1205197 1205200 1205201 OS 1 OS_1 5s31.4ml 6 +5 S 31.4 1205197 1205200 1205202 OS 2 OS_2 5s31.4ml 5 +5 S 31.4 1205197 1205200 1205203 OS 3 OS_3 5s31.4ml 4 +5 N 31.4 1205197 1205204 1205205 ML 1 ML_1 5n31.4ml 6 +5 N 31.4 1205197 1205204 1205206 ML 2 ML_2 5n31.4ml 5 +5 N 31.4 1205197 1205204 1205207 ML 3 ML_3 5n31.4ml 4 +5 N 31.4 1205197 1205204 1209732 ML 4 ML_4 5n31.4ml 3 +5 N 31.4 1205197 1205204 1209733 ML 5 ML_5 5n31.4ml 2 +5 N 31.4 1205197 1205204 1209734 ML 6 ML_6 5n31.4ml 1 +5 S 31.4 1205197 1205200 1209735 OS 4 OS_4 5s31.4ml 3 +5 S 31.4 1205197 1205200 1209736 OS 5 OS_5 5s31.4ml 2 +5 S 31.4 1205197 1205200 1209737 OS 6 OS_6 5s31.4ml 1 +5 S 31.4 1205197 1205198 1209742 OH 2 SD_4 5n31.4hv 1 +5 N 31.4 1205197 1209746 1209743 HV 1 SD_1 5n31.4hv 2 +5 N 31.4 1205197 1209746 1209744 HV 2 SD_2 5n31.4hv 1 +5 S 31.6 1205208 1205211 1205212 ML 1 ML_1 5s31.6ml 6 +5 S 31.6 1205208 1205211 1205213 ML 2 ML_2 5s31.6ml 5 +5 S 31.6 1205208 1205211 1205214 ML 3 ML_3 5s31.6ml 4 +5 N 31.6 1205208 1205215 1205216 OS 1 OS_1 5n31.6ml 5 +5 N 31.6 1205208 1205215 1205217 OS 2 OS_2 5n31.6ml 4 +5 N 31.6 1205208 1205215 1205218 OS 3 OS_3 5n31.6ml 3 +5 S 31.6 1205208 1205211 1209748 ML 4 ML_4 5s31.6ml 3 +5 S 31.6 1205208 1205211 1209749 ML 5 ML_5 5s31.6ml 2 +5 S 31.6 1205208 1205211 1209750 ML 6 ML_6 5s31.6ml 1 +5 N 31.6 1205208 1205215 1209751 OS 4 OS_4 5n31.6ml 2 +5 N 31.6 1205208 1205215 1209752 OS 5 OS_5 5n31.6ml 1 +5 S 31.6 1205208 1212046 1209754 HV 1 SD_1 5s31.6hv 1 +5 N 31.6 1205208 1212047 1209755 OH 1 SD_2 5n31.6hv 0 +5 S 31.6 1205208 1212780 1212778 OR 1 SD_3 ? 0 +5 S 31.6 1205208 1212781 1212779 FR 1 SD_4 ? 0 +5 N 31.9 1205219 1205220 1205221 OR 1 RAMP_ON 5n31.9ora 0 +5 N 31.9 1205219 1205220 1205222 QU 2 QUEUE 5n31.9ora 0 +5 N 31.9 1205219 1205220 1205223 DM 3 DEMAND 5n31.9ora 0 +5 N 31.9 1205219 1205220 1205224 PA 4 PASSAGE 5n31.9ora 0 +5 N 31.9 1205219 1205225 1205226 ML 1 ML_1 5n31.9ml 5 +5 N 31.9 1205219 1205225 1205227 ML 2 ML_2 5n31.9ml 4 +5 N 31.9 1205219 1205225 1205228 ML 3 ML_3 5n31.9ml 3 +5 N 31.9 1205219 1205225 1209759 ML 4 ML_4 5n31.9ml 2 +5 N 31.9 1205219 1205225 1209760 ML 5 ML_5 5n31.9ml 1 +5 N 31.9 1205219 1209763 1209761 FR 1 RAMP_OFF 5n31.9fr 1 +5 N 31.9 1205219 1209764 1209762 HV 1 SD_1 5n31.9hv 1 +5 S 32 1205229 1205230 1205231 ML 1 ML_1 5s32ml 5 +5 S 32 1205229 1205230 1205232 ML 2 ML_2 5s32ml 4 +5 S 32 1205229 1205230 1205233 ML 3 ML_3 5s32ml 3 +5 S 32 1205229 1205230 1209765 ML 4 ML_4 5s32ml 2 +5 S 32 1205229 1205230 1209766 ML 5 ML_5 5s32ml 1 +5 S 32 1205229 1209777 1209767 DM 1 DEMAND 5s32ora 0 +5 S 32 1205229 1209777 1209768 PA 2 PASSAGE 5s32ora 0 +5 S 32 1205229 1209777 1209769 QU 3 QUEUE 5s32ora 0 +5 S 32 1205229 1209777 1209770 OR 4 RAMP_ON 5s32ora 0 +5 S 32 1205229 1209778 1209771 FR 1 RAMP_OFF 5s32fr 1 +5 S 32 1205229 1209779 1209772 HV 1 SD_1 5s32hv 1 +5 S 32 1205229 1209779 1209773 HV 2 SD_2 ? 0 +5 S 32.25 1205238 1205239 1205240 OR 1 RAMP_ON 5s32.25ora 0 +5 S 32.25 1205238 1205239 1205241 QU 2 QUEUE 5s32.25ora 0 +5 S 32.25 1205238 1205239 1205242 DM 3 DEMAND 5s32.25ora 0 +5 S 32.25 1205238 1205239 1205243 PA 4 PASSAGE 5s32.25ora 0 +5 S 32.25 1205238 1205244 1205245 FR 1 RAMP_OFF 5s32.58fr 1 +5 S 32.25 1205238 1205246 1205247 ML 1 ML_1 5s32.25ml 5 +5 S 32.25 1205238 1205246 1205248 ML 2 ML_2 5s32.25ml 4 +5 S 32.25 1205238 1205246 1205249 ML 3 ML_3 5s32.25ml 3 +5 S 32.25 1205238 1205246 1209819 ML 4 ML_4 5s32.25ml 2 +5 S 32.25 1205238 1205246 1209820 ML 5 ML_5 5s32.25ml 1 +5 N 32.25 1205238 1205250 1209821 OS 4 OS_4 5n32.3ml 2 +5 N 32.25 1205238 1205250 1209822 OS 5 OS_5 5n32.3ml 1 +5 S 32.25 1205238 1209826 1209823 HV 1 SD_1 5s32.25hv 1 +5 N 32.25 1205238 1209827 1209824 OH 1 SD_2 5n32.3hv 1 +5 N 32.3 1205238 1205250 1205251 OS 1 OS_1 5n32.3ml 5 +5 N 32.3 1205238 1205250 1205252 OS 2 OS_2 5n32.3ml 4 +5 N 32.3 1205238 1205250 1205253 OS 3 OS_3 5n32.3ml 3 +5 N 32.5 1205254 1205255 1205256 OR 1 RAMP_ON 5n32.5ora 0 +5 N 32.5 1205254 1205255 1205257 QU 2 QUEUE 5n32.5ora 0 +5 N 32.5 1205254 1205255 1205258 DM 3 DEMAND 5n32.5ora 0 +5 N 32.5 1205254 1205255 1205259 PA 4 PASSAGE 5n32.5ora 0 +5 N 32.5 1205254 1205260 1205261 FR 1 RAMP_OFF 5n32.5fr 1 +5 N 32.5 1205254 1205262 1205263 ML 1 ML_1 5n32.5ml 5 +5 N 32.5 1205254 1205262 1205264 ML 2 ML_2 5n32.5ml 4 +5 N 32.5 1205254 1205262 1205265 ML 3 ML_3 5n32.5ml 3 +5 N 32.5 1205254 1205262 1209782 ML 4 ML_4 5n32.5ml 2 +5 N 32.5 1205254 1205262 1209783 ML 5 ML_5 5n32.5ml 1 +5 N 32.5 1205254 1209931 1209930 HV 1 SD_1 5n32.5hv 1 +5 S 32.58 1205254 1205266 1205267 OH 1 SD_2 ? 0 +5 N 32.6 1205268 1205269 1208291 ML 2 ML_2 5n32.6ml 4 +5 N 32.6 1205268 1205269 1208297 ML 1 ML_1 5n32.6ml 5 +5 N 32.6 1205268 1205269 1209934 ML 3 ML_3 5n32.6ml 3 +5 N 32.6 1205268 1205269 1209935 ML 4 ML_4 5n32.6ml 2 +5 N 32.6 1205268 1205269 1209936 ML 5 ML_5 5n32.6ml 1 +5 N 32.6 1205268 1209943 1209938 DM 1 DEMAND 5n32.6ora 0 +5 N 32.6 1205268 1209943 1209939 PA 2 PASSAGE 5n32.6ora 0 +5 N 32.6 1205268 1209943 1209940 QU 3 QUEUE 5n32.6ora 0 +5 N 32.6 1205268 1209943 1209941 OR 4 RAMP_ON 5n32.6ora 0 +5 N 32.6 1205268 1209944 1209942 HV 1 SD_1 5n32.6hv 1 +5 S 33 1205270 1205271 1205272 OR 1 RAMP_ON 5s33ora 0 +5 S 33 1205270 1205271 1205273 QU 2 QUEUE 5s33ora 0 +5 S 33 1205270 1205271 1205274 DM 3 DEMAND 5s33ora 0 +5 S 33 1205270 1205271 1205275 PA 4 PASSAGE 5s33ora 0 +5 S 33 1205270 1205276 1205277 ML 1 ML_1 5s33ml 5 +5 S 33 1205270 1205276 1205278 ML 2 ML_2 5s33ml 4 +5 S 33 1205270 1205276 1205279 ML 3 ML_3 5s33ml 3 +5 S 33 1205270 1205276 1209945 ML 4 ML_4 5s33ml 2 +5 S 33 1205270 1205276 1209947 ML 5 ML_5 5s33ml 1 +5 S 33 1205270 1209950 1209948 HV 1 SD_1 5s33hv 1 +5 N 33 1205270 1209951 1209949 OH 1 SD_2 ? 0 +55 N 3.11 1203026 1203027 1203028 OR 1 RAMP_ON 55n3.07ora 0 +55 N 3.11 1203026 1203027 1203029 QU 2 QUEUE 55n3.07ora 0 +55 N 3.11 1203026 1203027 1203030 DM 3 DEMAND 55n3.07ora 0 +55 N 3.11 1203026 1203027 1203031 PA 4 PASSAGE 55n3.07ora 0 +55 S 3.11 1203026 1203032 1203033 OF 1 SD_1 55s3.07fr 2 +55 S 3.11 1203026 1203032 1203034 OF 2 SD_2 55s3.07fr 1 +55 N 3.11 1203026 1203035 1203036 ML 1 ML_1 55n3.07ml 4 +55 N 3.11 1203026 1203035 1203037 ML 2 ML_2 55n3.07ml 3 +55 N 3.11 1203026 1203035 1203038 ML 3 ML_3 55n3.07ml 2 +55 N 3.11 1203026 1203035 1203039 ML 4 ML_4 55n3.07ml 1 +55 S 3.11 1203026 1203040 1203041 OS 1 OS_1 55s3.07ml 3 +55 S 3.11 1203026 1203040 1203042 OS 2 OS_2 55s3.07ml 2 +55 S 3.11 1203026 1203040 1203043 OS 3 OS_3 55s3.07ml 1 +55 S 3.6 1203044 1203045 1203046 OR 1 RAMP_ON 55s3.59ora 0 +55 S 3.6 1203044 1203045 1203047 QU 2 QUEUE 55s3.59ora 0 +55 S 3.6 1203044 1203045 1203048 DM 3 DEMAND 55s3.59ora 0 +55 S 3.6 1203044 1203045 1203049 PA 4 PASSAGE 55s3.59ora 0 +55 S 3.6 1203044 1203050 1203051 ML 1 ML_1 55s3.59ml 4 +55 S 3.6 1203044 1203050 1203052 ML 2 ML_2 55s3.59ml 3 +55 S 3.6 1203044 1203050 1203053 ML 3 ML_3 55s3.59ml 2 +55 S 3.6 1203044 1203050 1203054 ML 4 ML_4 55s3.59ml 1 +55 N 3.6 1203044 1203055 1203056 OF 1 SD_1 55n3.59fr 1 +55 N 3.6 1203044 1203057 1203058 OS 1 OS_1 55n3.59ml 4 +55 N 3.6 1203044 1203057 1203059 OS 2 OS_2 55n3.59ml 3 +55 N 3.6 1203044 1203057 1203060 OS 3 OS_3 55n3.59ml 2 +55 N 3.6 1203044 1203057 1203061 OS 4 OS_4 55n3.59ml 1 +55 N 3.96 1203062 1203063 1203064 OR 1 RAMP_ON 55n3.97ora 0 +55 N 3.96 1203062 1203063 1203065 QU 2 QUEUE 55n3.97ora 0 +55 N 3.96 1203062 1203063 1203066 DM 3 DEMAND 55n3.97ora 0 +55 N 3.96 1203062 1203063 1203067 PA 4 PASSAGE 55n3.97ora 0 +55 S 3.96 1203062 1203068 1203069 OF 1 SD_1 55s3.97fr 2 +55 S 3.96 1203062 1203068 1203070 OF 2 SD_2 55s3.97fr 1 +55 N 3.96 1203062 1203071 1203072 ML 1 ML_1 55n3.97ml 4 +55 N 3.96 1203062 1203071 1203073 ML 2 ML_2 55n3.97ml 3 +55 N 3.96 1203062 1203071 1203074 ML 3 ML_3 55n3.97ml 2 +55 N 3.96 1203062 1203071 1203075 ML 4 ML_4 55n3.97ml 1 +55 S 3.96 1203062 1203076 1203077 OS 1 OS_1 55s3.97ml 4 +55 S 3.96 1203062 1203076 1203078 OS 2 OS_2 55s3.97ml 3 +55 S 3.96 1203062 1203076 1203079 OS 3 OS_3 55s3.97ml 2 +55 S 3.96 1203062 1203076 1203080 OS 4 OS_4 55s3.97ml 1 +55 N 4.58 1203081 1203082 1210208 ML 1 ML_1 55n4.58ml 4 +55 N 4.58 1203081 1203082 1210209 ML 2 ML_2 55n4.58ml 3 +55 N 4.58 1203081 1203082 1210210 ML 3 ML_3 55n4.58ml 2 +55 N 4.58 1203081 1203082 1210211 ML 4 ML_4 55n4.58ml 1 +55 S 4.58 1203081 1210220 1210212 OS 1 OS_1 55s4.58ml 4 +55 S 4.58 1203081 1210220 1210213 OS 2 OS_2 55s4.58ml 3 +55 S 4.58 1203081 1210220 1210214 OS 3 OS_3 55s4.58ml 2 +55 S 4.58 1203081 1210220 1210215 OS 4 OS_4 55s4.58ml 1 +55 N 4.58 1203081 1210221 1210216 FF 1 SD_4 55n4.58ff 2 +55 N 4.58 1203081 1210221 1210217 FF 2 SD_5 55n4.58ff 1 +55 S 4.58 1203081 1210222 1210218 FO 1 SD_1 55s4.58ff 1 +55 S 4.58 1203081 1210222 1210219 FO 2 SD_2 ? 0 +55 S 4.7 1203083 1203084 1210195 ML 1 ML_1 55s4.7ml 3 +55 S 4.7 1203083 1203084 1210196 ML 2 ML_2 55s4.7ml 2 +55 S 4.7 1203083 1203084 1210197 ML 3 ML_3 55s4.7ml 1 +55 N 4.7 1203083 1210205 1210198 OS 1 OS_1 55n4.7ml 3 +55 N 4.7 1203083 1210205 1210199 OS 2 OS_2 55n4.7ml 2 +55 N 4.7 1203083 1210205 1210200 OS 3 OS_3 55n4.7ml 1 +55 S 4.7 1203083 1210206 1210201 DM 1 DEMAND 55s4.7or 0 +55 S 4.7 1203083 1210206 1210202 PA 2 PASSAGE 55s4.7or 0 +55 S 4.7 1203083 1210206 1210203 QU 3 QUEUE 55s4.7or 0 +55 S 4.7 1203083 1210207 1210204 FR 1 SD_1 ? 0 +55 S 5.06 1210174 1210189 1210175 ML 1 ML_1 55s5.06ml 3 +55 S 5.06 1210174 1210189 1210176 ML 2 ML_2 55s5.06ml 2 +55 S 5.06 1210174 1210189 1210177 ML 3 ML_3 55s5.06ml 1 +55 N 5.06 1210174 1210190 1210178 OS 1 OS_1 55n5.06ml 3 +55 N 5.06 1210174 1210190 1210179 OS 2 OS_2 55n5.06ml 2 +55 N 5.06 1210174 1210190 1210180 OS 3 OS_3 55n5.06ml 1 +55 S 5.06 1210174 1210191 1210181 FF 1 SD_1 55s5.06ff 2 +55 S 5.06 1210174 1210191 1210182 FF 2 SD_2 55s5.06ff 1 +55 N 5.06 1210174 1210194 1210185 FO 1 SD_3 55n5.06ff 2 +55 N 5.06 1210174 1210194 1210186 FO 2 SD_4 55n5.06ff 1 +55 S 5.06 1210174 1210192 1210187 FR 1 SD_6 ? 0 +55 S 5.06 1210174 1210193 1210188 OR 1 SD_5 55s5.06or 0 +55 N 5.51 1210163 1210172 1210164 ML 1 ML_1 55n5.51ml 4 +55 N 5.51 1210163 1210172 1210165 ML 2 ML_2 55n5.51ml 3 +55 N 5.51 1210163 1210172 1210166 ML 3 ML_3 55n5.51ml 2 +55 N 5.51 1210163 1210172 1210167 ML 4 ML_4 55n5.51ml 1 +55 S 5.51 1210163 1210173 1210168 OS 1 OS_1 55s5.5ml 4 +55 S 5.51 1210163 1210173 1210169 OS 2 OS_2 55s5.5ml 3 +55 S 5.51 1210163 1210173 1210170 OS 3 OS_3 55s5.5ml 2 +55 S 5.51 1210163 1210173 1210171 OS 4 OS_4 55s5.5ml 1 +55 N 5.8 1203085 1203086 1203087 DM 1 DEMAND 55n5.87ora 0 +55 N 5.8 1203085 1203090 1203091 ML 1 ML_1 55n5.87ml 3 +55 N 5.8 1203085 1203090 1203092 ML 2 ML_2 55n5.87ml 2 +55 N 5.8 1203085 1203090 1203093 ML 3 ML_3 55n5.87ml 1 +55 S 5.8 1203085 1203095 1203096 OS 1 OS_1 55s5.81ml 3 +55 S 5.8 1203085 1203095 1203097 OS 2 OS_2 55s5.81ml 2 +55 S 5.8 1203085 1203095 1203098 OS 3 OS_3 55s5.81ml 1 +55 N 5.8 1203085 1203086 1210152 PA 2 PASSAGE 55n5.87ora 0 +55 N 5.8 1203085 1203086 1210153 QU 3 QUEUE 55n5.87ora 0 +55 S 5.8 1203085 1210161 1210154 OF 1 SD_1 55s5.8fra 1 +55 S 5.8 1203085 1203088 1210155 FO 1 SD_2 55s5.8ff 1 +55 N 5.8 1203085 1210160 1210156 FF 1 SD_4 55n5.8ff 1 +55 N 5.8 1203085 1210162 1210157 FF 1 SD_5 ? 0 +55 S 5.8 1203085 1210159 1210158 OF 1 SD_3 55s5.8frb 1 +55 S 6.88 1203103 1203104 1203105 QU 1 QUEUE 55s6.88ora 0 +55 S 6.88 1203103 1203104 1203106 DM 2 DEMAND 55s6.88ora 0 +55 S 6.88 1203103 1203104 1203107 PA 3 PASSAGE 55s6.88ora 0 +55 S 6.88 1203103 1203108 1203109 HV 1 SD_1 ? 0 +55 S 6.88 1203103 1203110 1203111 ML 1 ML_1 55s6.88ml 4 +55 S 6.88 1203103 1203110 1203112 ML 2 ML_2 55s6.88ml 3 +55 S 6.88 1203103 1203110 1203113 ML 3 ML_3 55s6.88ml 2 +55 S 6.88 1203103 1203110 1203114 ML 4 ML_4 55s6.88ml 1 +55 N 6.94 1203115 1203116 1203117 QU 2 QUEUE 55n6.94ora 0 +55 N 6.94 1203115 1203116 1203118 DM 3 DEMAND 55n6.94ora 0 +55 N 6.94 1203115 1203116 1203119 PA 1 PASSAGE 55n6.94ora 0 +55 N 6.94 1203115 1203120 1203121 FR 1 RAMP_OFF 55n6.94fr 1 +55 N 6.94 1203115 1203122 1203123 HV 1 SD_1 ? 0 +55 N 6.94 1203115 1203124 1203125 ML 1 ML_1 55n6.94ml 4 +55 N 6.94 1203115 1203124 1203126 ML 2 ML_2 55n6.94ml 3 +55 N 6.94 1203115 1203124 1203127 ML 3 ML_3 55n6.94ml 2 +55 N 6.94 1203115 1203124 1203128 ML 4 ML_4 55n6.94ml 1 +55 S 7.03 1203129 1203130 1203131 QU 1 QUEUE 55s7.03ora 0 +55 S 7.03 1203129 1203130 1203132 DM 2 DEMAND 55s7.03ora 0 +55 S 7.03 1203129 1203130 1203133 PA 3 PASSAGE 55s7.03ora 0 +55 S 7.03 1203129 1203134 1203135 HV 1 SD_1 55s7.03ml 4 +55 S 7.03 1203129 1203136 1203137 ML 1 ML_1 55s7.03ml 3 +55 S 7.03 1203129 1203136 1203138 ML 2 ML_2 55s7.03ml 2 +55 S 7.03 1203129 1203136 1203139 ML 3 ML_3 55s7.03ml 1 +55 N 7.16 1203140 1203141 1203142 OR 1 RAMP_ON 55n7.16ora 0 +55 N 7.16 1203140 1203141 1203143 QU 2 QUEUE 55n7.16ora 0 +55 N 7.16 1203140 1203141 1203144 DM 3 DEMAND 55n7.16ora 0 +55 N 7.16 1203140 1203141 1203145 PA 4 PASSAGE 55n7.16ora 0 +55 N 7.16 1203140 1203146 1203147 HV 1 SD_1 ? 0 +55 N 7.16 1203140 1203148 1203149 ML 1 ML_1 55n7.16ml 4 +55 N 7.16 1203140 1203148 1203150 ML 2 ML_2 55n7.16ml 3 +55 N 7.16 1203140 1203148 1203151 ML 3 ML_3 55n7.16ml 2 +55 N 7.16 1203140 1203148 1203152 ML 4 ML_4 55n7.16ml 1 +55 S 7.62 1203153 1203154 1203155 OR 1 RAMP_ON 55s7.62ora 0 +55 S 7.62 1203153 1203154 1203156 QU 2 QUEUE 55s7.62ora 0 +55 S 7.62 1203153 1203154 1203157 DM 3 DEMAND 55s7.62ora 0 +55 S 7.62 1203153 1203154 1203158 PA 4 PASSAGE 55s7.62ora 0 +55 S 7.62 1203153 1203159 1203160 HV 1 SD_1 55s7.62ml 5 +55 S 7.62 1203153 1203161 1203162 ML 1 ML_1 55s7.62ml 3 +55 S 7.62 1203153 1203161 1203163 ML 2 ML_2 55s7.62ml 2 +55 S 7.62 1203153 1203161 1203164 ML 3 ML_3 55s7.62ml 1 +55 S 7.62 1203153 1203161 1213047 ML 4 ML_4 55s7.62ml 4 +55 N 7.85 1203165 1203166 1203167 QU 1 QUEUE 55n7.85ora 0 +55 N 7.85 1203165 1203166 1203168 DM 2 DEMAND 55n7.85ora 0 +55 N 7.85 1203165 1203166 1203169 PA 3 PASSAGE 55n7.85ora 0 +55 N 7.85 1203165 1203170 1203171 HV 1 SD_1 55n7.85ml 1 +55 N 7.85 1203165 1203172 1203173 ML 1 ML_1 55n7.85ml 5 +55 N 7.85 1203165 1203172 1203174 ML 2 ML_2 55n7.85ml 4 +55 N 7.85 1203165 1203172 1203175 ML 3 ML_3 55n7.85ml 3 +55 N 7.85 1203165 1203172 1213048 ML 4 ML_4 55n7.85ml 2 +55 N 8.12 1203176 1203177 1203178 OR 1 RAMP_ON 55n8.12ora 0 +55 N 8.12 1203176 1203177 1203179 QU 2 QUEUE 55n8.12ora 0 +55 N 8.12 1203176 1203177 1203180 DM 3 DEMAND 55n8.12ora 0 +55 N 8.12 1203176 1203177 1203181 PA 4 PASSAGE 55n8.12ora 0 +55 N 8.12 1203176 1203182 1203183 HV 1 SD_1 55n8.12ml 4 +55 N 8.12 1203176 1203184 1203185 ML 1 ML_1 55n8.12ml 3 +55 N 8.12 1203176 1203184 1203186 ML 2 ML_2 55n8.12ml 2 +55 N 8.12 1203176 1203184 1203187 ML 3 ML_3 55n8.12ml 1 +55 S 8.12 1203176 1203188 1203189 OS 1 OS_1 55s8.12ml 4 +55 S 8.12 1203176 1203188 1203190 OS 2 OS_2 55s8.12ml 3 +55 S 8.12 1203176 1203188 1203191 OS 3 OS_3 55s8.12ml 2 +55 S 8.12 1203176 1203188 1203192 OS 4 OS_4 55s8.12ml 1 +55 S 8.12 1203176 1203193 1203194 OF 1 RAMP_OFF 55s8.12fr 1 +55 S 8.12 1203176 1208965 1203195 OH 1 SD_3 55s8.12ml 5 +55 S 9.19 1203196 1203197 1203198 OR 1 RAMP_ON 55s9.19ora 0 +55 S 9.19 1203196 1203197 1203199 QU 2 QUEUE 55s9.19ora 0 +55 S 9.19 1203196 1203197 1203200 DM 3 DEMAND 55s9.19ora 0 +55 S 9.19 1203196 1203197 1203201 PA 4 PASSAGE 55s9.19ora 0 +55 S 9.19 1203196 1203202 1203203 FR 1 RAMP_OFF 55s9.19fr 1 +55 S 9.19 1203196 1203204 1203205 HV 1 SD_1 55s9.19ml 5 +55 S 9.19 1203196 1203206 1203207 ML 1 ML_1 55s9.19ml 4 +55 S 9.19 1203196 1203206 1203208 ML 2 ML_2 55s9.19ml 3 +55 S 9.19 1203196 1203206 1203209 ML 3 ML_3 55s9.19ml 2 +55 S 9.19 1203196 1203206 1203210 ML 4 ML_4 55s9.19ml 1 +55 N 9.19 1203196 1211173 1211167 OS 1 OS_1 55n9.19ml 4 +55 N 9.19 1203196 1211173 1211168 OS 2 OS_2 55n9.19ml 3 +55 N 9.19 1203196 1211173 1211169 OS 3 OS_3 55n9.19ml 2 +55 N 9.19 1203196 1211173 1211170 OS 4 OS_4 55n9.19ml 1 +55 N 9.19 1203196 1211172 1211171 OH 1 SD_2 55n9.19hv 1 +55 N 9.41 1203211 1203212 1203213 OR 1 RAMP_ON 55n9.41ora 0 +55 N 9.41 1203211 1203212 1203214 QU 2 QUEUE 55n9.41ora 0 +55 N 9.41 1203211 1203212 1203215 DM 3 DEMAND 55n9.41ora 0 +55 N 9.41 1203211 1203212 1203216 PA 4 PASSAGE 55n9.41ora 0 +55 N 9.41 1203211 1203217 1203218 FR 1 RAMP_OFF 55n9.41fr 1 +55 N 9.41 1203211 1203219 1203220 HV 1 SD_1 55n9.41hv 1 +55 N 9.41 1203211 1203221 1203222 ML 1 ML_1 55n9.41ml 4 +55 N 9.41 1203211 1203221 1203223 ML 2 ML_2 55n9.41ml 3 +55 N 9.41 1203211 1203221 1203224 ML 3 ML_3 55n9.41ml 2 +55 N 9.41 1203211 1203221 1203225 ML 4 ML_4 55n9.41ml 1 +55 S 10 1203226 1203227 1203228 OR 1 RAMP_ON 55s10ora 0 +55 S 10 1203226 1203227 1203229 QU 2 QUEUE 55s10ora 0 +55 S 10 1203226 1203227 1203230 DM 3 DEMAND 55s10ora 0 +55 S 10 1203226 1203227 1203231 PA 4 PASSAGE 55s10ora 0 +55 S 10 1203226 1203232 1203233 FR 1 RAMP_OFF 55s10fr 2 +55 S 10 1203226 1203232 1203234 FR 2 SD_2 55s10fr 1 +55 S 10 1203226 1203235 1203236 CD 1 COLL_DIST_1 ? 0 +55 S 10 1203226 1203237 1203238 HV 1 SD_1 55s9.84hv 1 +55 S 10 1203226 1203239 1203240 ML 1 ML_1 55s9.84ml 4 +55 S 10 1203226 1203239 1203241 ML 2 ML_2 55s9.84ml 3 +55 S 10 1203226 1203239 1203242 ML 3 ML_3 55s9.84ml 2 +55 S 10 1203226 1203239 1203243 ML 4 ML_4 55s9.84ml 1 +55 N 10 1203244 1203245 1203246 OR 1 RAMP_ON 55n10ora 0 +55 N 10 1203244 1203245 1203247 QU 2 QUEUE 55n10ora 0 +55 N 10 1203244 1203245 1203248 DM 3 DEMAND 55n10ora 0 +55 N 10 1203244 1203245 1203249 PA 4 PASSAGE 55n10ora 0 +55 N 10 1203244 1203250 1203251 FR 1 RAMP_OFF 55n10fr 1 +55 N 10 1203244 1203252 1203253 HV 1 SD_1 55n10hv 1 +55 N 10 1203244 1203254 1203255 ML 1 ML_1 55n10ml 4 +55 N 10 1203244 1203254 1203256 ML 2 ML_2 55n10ml 3 +55 N 10 1203244 1203254 1203257 ML 3 ML_3 55n10ml 2 +55 N 10 1203244 1203254 1203258 ML 4 ML_4 55n10ml 1 +55 S 10.4 1203261 1203262 1203263 FF 1 SD_5 55s10.2ff 1 +55 S 10.4 1203261 1203264 1203265 HV 1 SD_1 55s10.4hv 1 +55 S 10.4 1203261 1203266 1203267 ML 1 ML_1 55s10.4ml 3 +55 S 10.4 1203261 1203266 1203268 ML 2 ML_2 55s10.4ml 2 +55 S 10.4 1203261 1203266 1203269 ML 3 ML_3 55s10.4ml 1 +55 S 10.4 1209845 1209860 1209846 ML 1 ML_1 ? 0 +55 S 10.4 1209845 1209860 1209847 ML 2 ML_2 ? 0 +55 S 10.4 1209845 1209860 1209848 ML 3 ML_3 ? 0 +55 S 10.4 1209845 1209860 1209849 ML 4 ML_4 ? 0 +55 S 10.4 1209845 1209861 1209854 HV 1 SD_1 ? 0 +55 S 10.4 1209845 1209862 1209856 FF 1 SD_3 ? 0 +55 S 10.4 1209845 1209862 1209857 FF 2 SD_4 ? 0 +55 S 10.4 1209845 1209865 1209858 FO 1 SD_6 ? 0 +55 S 10.4 1203261 1203266 1209866 ML 4 ML_4 ? 0 +55 N 10.4 1203261 1209873 1209867 OS 1 OS_1 55n10.4ml 3 +55 N 10.4 1203261 1209873 1209868 OS 2 OS_2 55n10.4ml 2 +55 N 10.4 1203261 1209873 1209869 OS 3 OS_3 55n10.4ml 1 +55 N 10.4 1203261 1209874 1209870 OH 1 SD_2 55n10.4hv 1 +55 S 10.4 1203261 1209875 1209871 FF 1 SD_3 55s10.4ff 2 +55 S 10.4 1203261 1209875 1209872 FF 2 SD_4 55s10.4ff 1 +55 N 10.4 1209845 1211969 1211968 HB 1 SD_5 ? 0 +55 S 10.5 1203270 1203271 1209876 ML 1 ML_1 55s10.5ml 3 +55 S 10.5 1203270 1203271 1209877 ML 2 ML_2 55s10.5ml 2 +55 S 10.5 1203270 1203271 1209878 ML 3 ML_3 55s10.5ml 1 +55 N 10.5 1203270 1209888 1209880 OS 1 OS_1 55n10.5ml 3 +55 N 10.5 1203270 1209888 1209881 OS 2 OS_2 55n10.5ml 2 +55 N 10.5 1203270 1209888 1209882 OS 3 OS_3 55n10.5ml 1 +55 S 10.5 1203270 1209889 1209883 HV 1 SD_1 55s10.5ml 4 +55 N 10.5 1203270 1209890 1209884 OH 1 SD_2 55n10.5hv 1 +55 N 10.5 1203270 1209892 1209885 OF 1 SD_3 55n10.5fra 1 +55 N 10.5 1203270 1209891 1209886 FO 1 SD_5 55n10.5ff 2 +55 N 10.5 1203270 1209891 1209887 FO 2 SD_6 55n10.5ff 1 +55 N 10.5 1203270 1209893 1209894 OF 1 SD_4 55n10.5frb 1 +55 S 10.84 1203274 1203275 1203276 OR 1 RAMP_ON 55s10.84ora 0 +55 S 10.84 1203274 1203275 1203277 QU 2 QUEUE 55s10.84ora 0 +55 S 10.84 1203274 1203275 1203278 DM 3 DEMAND 55s10.84ora 0 +55 S 10.84 1203274 1203275 1203279 PA 4 PASSAGE 55s10.84ora 0 +55 S 10.84 1203274 1211964 1203281 OC 1 SD_5 ? 0 +55 S 10.84 1203274 1203282 1203283 HV 1 SD_1 55s10.84hv 1 +55 S 10.84 1203274 1203284 1203285 ML 1 ML_1 55s10.84ml 3 +55 S 10.84 1203274 1203284 1203286 ML 2 ML_2 55s10.84ml 2 +55 S 10.84 1203274 1203284 1203287 ML 3 ML_3 55s10.84ml 1 +55 N 10.84 1203274 1203288 1203289 OS 1 OS_1 55n10.84ml 3 +55 N 10.84 1203274 1203288 1203290 OS 2 OS_2 55n10.84ml 2 +55 N 10.84 1203274 1203288 1203291 OS 3 OS_3 55n10.84ml 1 +55 S 10.84 1203274 1209049 1209048 OH 1 SD_2 ? 0 +55 N 10.84 1203274 1211962 1211958 FO 1 COLL_DIST_1 55n10.84ff 2 +55 N 10.84 1203274 1211962 1211959 FO 2 COLL_DIST_2 55n10.84ff 1 +55 S 10.84 1203274 1211963 1211960 FF 1 SD_3 55s10.84ffa 1 +55 S 10.84 1203274 1211963 1211961 FF 1 SD_4 55s10.84ffb 1 +55 N 11.1 1203293 1203294 1203295 OR 1 RAMP_ON 55n11.1ora 0 +55 N 11.1 1203293 1203294 1203296 QU 2 QUEUE 55n11.1ora 0 +55 N 11.1 1203293 1203294 1203297 DM 3 DEMAND 55n11.1ora 0 +55 N 11.1 1203293 1203294 1203298 PA 4 PASSAGE 55n11.1ora 0 +55 N 11.1 1203293 1203299 1203300 FR 1 RAMP_OFF ? 0 +55 N 11.1 1203293 1203301 1203302 HV 1 SD_1 55n11.1hv 1 +55 N 11.1 1203293 1203303 1203304 ML 1 ML_1 55n11.1ml 4 +55 N 11.1 1203293 1203303 1203305 ML 2 ML_2 55n11.1ml 3 +55 N 11.1 1203293 1203303 1203306 ML 3 ML_3 55n11.1ml 2 +55 S 11.1 1203293 1203280 1211965 OF 1 SD_2 55s10.84fr 2 +55 S 11.1 1203293 1203280 1211966 OF 2 SD_3 55s10.84fr 1 +55 N 11.1 1203293 1203303 1212750 ML 4 ML_4 55n11.1ml 1 +55 N 11.1 1203293 1203299 1213009 FR 2 SD_4 ? 0 +55 S 11.62 1203307 1203308 1203309 OR 1 RAMP_ON 55s11.62ora 0 +55 S 11.62 1203307 1203308 1203310 QU 2 QUEUE 55s11.62ora 0 +55 S 11.62 1203307 1203308 1203311 DM 3 DEMAND 55s11.62ora 0 +55 S 11.62 1203307 1203308 1203312 PA 4 PASSAGE 55s11.62ora 0 +55 S 11.62 1203307 1203313 1203314 FR 1 RAMP_OFF 55s11.62fr 1 +55 S 11.62 1203307 1203315 1203316 HV 1 SD_1 55s11.62hv 1 +55 S 11.62 1203307 1203317 1203318 ML 1 ML_1 55s11.62ml 4 +55 S 11.62 1203307 1203317 1203319 ML 2 ML_2 55s11.62ml 3 +55 S 11.62 1203307 1203317 1203320 ML 3 ML_3 55s11.62ml 2 +55 S 11.62 1203307 1203317 1213049 ML 4 ML_4 55s11.62ml 1 +55 N 11.74 1203321 1203322 1203323 OR 1 RAMP_ON 55n11.74ora 0 +55 N 11.74 1203321 1203322 1203324 QU 2 QUEUE 55n11.74ora 0 +55 N 11.74 1203321 1203322 1203325 DM 3 DEMAND 55n11.74ora 0 +55 N 11.74 1203321 1203322 1203326 PA 4 PASSAGE 55n11.74ora 0 +55 N 11.74 1203321 1203327 1203328 FR 1 RAMP_OFF 55n11.74fr 2 +55 N 11.74 1203321 1203329 1203330 HV 1 SD_1 55n11.74hv 1 +55 N 11.74 1203321 1203331 1203332 ML 1 ML_1 55n11.74ml 4 +55 N 11.74 1203321 1203331 1203333 ML 2 ML_2 55n11.74ml 3 +55 N 11.74 1203321 1203331 1203334 ML 3 ML_3 55n11.74ml 2 +55 N 11.74 1203321 1203331 1212757 ML 4 ML_4 55n11.74ml 1 +55 N 11.74 1203321 1203327 1212758 FR 2 SD_3 55n11.74fr 1 +55 N 12 1203335 1203336 1203337 QU 1 QUEUE 55n12ora 0 +55 N 12 1203335 1203336 1203338 DM 2 DEMAND 55n12ora 0 +55 N 12 1203335 1203336 1203339 PA 3 PASSAGE 55n12ora 0 +55 N 12 1203335 1203340 1203341 HV 1 SD_1 55n12hv 1 +55 N 12 1203335 1203342 1203343 ML 1 ML_1 55n12ml 4 +55 N 12 1203335 1203342 1203344 ML 2 ML_2 55n12ml 3 +55 N 12 1203335 1203342 1203345 ML 3 ML_3 55n12ml 2 +55 S 12 1203335 1203346 1203347 OF 1 SD_2 55s12fr 1 +55 N 12 1203335 1203342 1212999 ML 4 ML_4 55n12ml 1 +55 N 12 1203335 1203336 1213000 OR 4 RAMP_ON 55n12ora 0 +405 S 0.6 1201117 1201118 1211055 ML 1 ML_1 405s0.6ml 5 +405 S 0.6 1201117 1201118 1211056 ML 2 ML_2 405s0.6ml 4 +405 S 0.6 1201117 1201118 1211057 ML 3 ML_3 405s0.6ml 3 +405 S 0.6 1201117 1201118 1211058 ML 4 ML_4 405s0.6ml 2 +405 S 0.6 1201117 1201118 1211059 ML 5 ML_5 405s0.6ml 1 +405 N 0.6 1201117 1211066 1211060 OS 1 OS_1 405n0.6ml 3 +405 N 0.6 1201117 1211066 1211061 OS 2 OS_2 405n0.6ml 2 +405 N 0.6 1201117 1211066 1211062 OS 3 OS_3 405n0.6ml 1 +405 S 0.6 1201117 1211065 1211063 HV 1 SD_1 405s0.6hv 1 +405 N 0.6 1201117 1211067 1211064 OH 1 SD_2 405n0.6hv 1 +405 S 0.77 1201080 1201081 1201082 QU 1 QUEUE 405s0.77ora 0 +405 S 0.77 1201080 1201081 1201083 DM 2 DEMAND 405s0.77ora 0 +405 S 0.77 1201080 1201081 1201084 PA 3 PASSAGE 405s0.77ora 0 +405 S 0.77 1201080 1201085 1201086 HV 1 SD_1 405s0.77hv 1 +405 S 0.77 1201080 1201087 1201088 ML 1 ML_1 405s0.77ml 5 +405 S 0.77 1201080 1201087 1201089 ML 2 ML_2 405s0.77ml 4 +405 S 0.77 1201080 1201087 1201090 ML 3 ML_3 405s0.77ml 3 +405 S 0.77 1201080 1201087 1201091 ML 4 ML_4 405s0.77ml 2 +405 S 0.77 1201080 1201081 1211045 OR 4 RAMP_ON 405s0.77ora 0 +405 S 0.77 1201080 1201087 1211046 ML 5 ML_5 405s0.77ml 1 +405 N 0.93 1201092 1201093 1201094 OR 1 RAMP_ON 405n0.9ora 0 +405 N 0.93 1201092 1201093 1201095 QU 2 QUEUE 405n0.9ora 0 +405 N 0.93 1201092 1201093 1201096 DM 3 DEMAND 405n0.9ora 0 +405 N 0.93 1201092 1201093 1201097 PA 4 PASSAGE 405n0.9ora 0 +405 N 0.93 1201092 1201098 1201099 FR 1 RAMP_OFF 405n0.9fr 1 +405 N 0.93 1201092 1201100 1201101 ML 1 ML_1 405n0.9ml 4 +405 N 0.93 1201092 1201100 1201102 ML 2 ML_2 405n0.9ml 3 +405 N 0.93 1201092 1201100 1201103 ML 3 ML_3 405n0.9ml 2 +405 N 0.93 1201092 1201100 1201104 ML 4 ML_4 405n0.9ml 1 +405 N 0.93 1201092 1208954 1208953 HV 1 SD_1 405n0.9ml 5 +405 N 0.93 1201092 1201098 1210822 FR 2 SD_2 405n0.9fr 1 +405 N 0.93 1201092 1210825 1210823 OC 1 COLL_DIST_1 405n0.9ff 2 +405 N 0.93 1201092 1210825 1210824 OC 2 COLL_DIST_2 405n0.9ff 1 +405 S 0.96 1201105 1201106 1201107 QU 1 QUEUE 405s0.96ora 0 +405 S 0.96 1201105 1201106 1201108 DM 2 DEMAND 405s0.96ora 0 +405 S 0.96 1201105 1201106 1201109 PA 3 PASSAGE 405s0.96ora 0 +405 S 0.96 1201105 1201110 1201111 HV 1 SD_1 405s0.96hv 1 +405 S 0.96 1201105 1201112 1201113 ML 1 ML_1 405s0.96ml 4 +405 S 0.96 1201105 1201112 1201114 ML 2 ML_2 405s0.96ml 3 +405 S 0.96 1201105 1201112 1201115 ML 3 ML_3 405s0.96ml 2 +405 S 0.96 1201105 1201112 1201116 ML 4 ML_4 405s0.96ml 1 +405 S 0.96 1201105 1211054 1211052 FR 1 RAMP_OFF 405s0.96fr 2 +405 S 0.96 1201105 1211054 1211053 FR 2 SD_2 405s0.96fr 1 +405 N 1.11 1201119 1201120 1201121 OR 1 RAMP_ON 405n1.11ora 0 +405 N 1.11 1201119 1201120 1201122 QU 2 QUEUE 405n1.11ora 0 +405 N 1.11 1201119 1201120 1201123 DM 3 DEMAND 405n1.11ora 0 +405 N 1.11 1201119 1201120 1201124 PA 4 PASSAGE 405n1.11ora 0 +405 N 1.11 1201119 1201125 1201126 ML 1 ML_1 405n1.11ml 4 +405 N 1.11 1201119 1201125 1201127 ML 2 ML_2 405n1.11ml 3 +405 N 1.11 1201119 1201125 1201128 ML 3 ML_3 405n1.11ml 2 +405 N 1.11 1201119 1201125 1201129 ML 4 ML_4 405n1.11ml 1 +405 N 1.11 1201119 1209043 1209042 HV 1 SD_1 405n1.11ml 5 +405 S 1.57 1201130 1201131 1201132 HV 1 SD_1 405s1.57hv 1 +405 S 1.57 1201130 1209091 1209079 ML 1 ML_1 405s1.57ml 4 +405 S 1.57 1201130 1209091 1209080 ML 2 ML_2 405s1.57ml 3 +405 S 1.57 1201130 1209091 1209081 ML 3 ML_3 405s1.57ml 2 +405 S 1.57 1201130 1209091 1209082 ML 4 ML_4 405s1.57ml 1 +405 S 1.57 1201130 1209092 1209083 OS 1 OS_1 405n1.57ml 5 +405 S 1.57 1201130 1209092 1209084 OS 2 OS_2 405n1.57ml 4 +405 S 1.57 1201130 1209092 1209085 OS 3 OS_3 405n1.57ml 3 +405 S 1.57 1201130 1209092 1209086 OS 4 OS_4 405n1.57ml 2 +405 S 1.57 1201130 1209092 1209087 OS 5 OS_5 405n1.57ml 1 +405 S 1.57 1201130 1209090 1209089 OH 1 SD_2 ? 0 +405 S 1.57 1201130 1210932 1210930 FF 1 SD_4 405s1.57ffa 1 +405 S 1.57 1201130 1210933 1210931 OC 1 COLL_DIST_ON ? 0 +405 S 1.57 1201130 1210935 1210934 FF 1 SD_5 405s1.57ffb 1 +405 S 1.73 1209054 1209094 1209118 CD 2 COLL_DIST_2 405s1.73cd 1 +405 S 1.73 1209054 1209094 1209119 CD 1 COLL_DIST_1 ? 0 +405 S 1.73 1209054 1209123 1209121 FF 1 SD_4 405s1.73ff 1 +405 N 1.73 1209054 1209124 1209122 FO 1 SD_5 405n1.73ff 1 +405 S 1.93 1201133 1201134 1201135 HV 1 SD_1 405s1.93hv 1 +405 S 1.93 1201133 1209161 1209149 ML 1 ML_1 405s1.93ml 4 +405 S 1.93 1201133 1209161 1209150 ML 2 ML_2 405s1.93ml 3 +405 S 1.93 1201133 1209161 1209151 ML 3 ML_3 405s1.93ml 2 +405 S 1.93 1201133 1209161 1209153 ML 4 ML_4 405s1.93ml 1 +405 N 1.93 1201133 1209162 1209154 OS 1 OS_1 405n1.93ml 4 +405 N 1.93 1201133 1209162 1209155 OS 2 OS_2 405n1.93ml 3 +405 N 1.93 1201133 1209162 1209156 OS 3 OS_3 405n1.93ml 2 +405 N 1.93 1201133 1209162 1209157 OS 4 OS_4 405n1.93ml 1 +405 N 1.93 1201133 1209163 1209160 OH 1 SD_2 405n1.93hv 1 +405 S 1.93 1201133 1209476 1209473 FC 1 COLL_DIST_OFF 405s1.93cd 1 +405 N 1.93 1201133 1209477 1209474 FO 1 SD_4 405n1.93ff 2 +405 N 1.93 1201133 1209477 1209475 FO 2 SD_5 405n1.93ff 1 +405 S 1.93 1201133 1210929 1210928 FF 1 COLL_DIST_ON 405s1.93ff 1 +405 N 2.35 1209050 1209176 1209165 ML 1 ML_1 405n2.35ml 5 +405 N 2.35 1209050 1209176 1209166 ML 2 ML_2 405n2.35ml 4 +405 N 2.35 1209050 1209176 1209167 ML 3 ML_3 405n2.35ml 3 +405 N 2.35 1209050 1209176 1209168 ML 4 ML_4 405n2.35ml 2 +405 N 2.35 1209050 1209176 1209169 ML 5 ML_5 405n2.35ml 1 +405 S 2.35 1209050 1209178 1209170 OS 1 OS_1 405s2.35ml 5 +405 S 2.35 1209050 1209178 1209171 OS 2 OS_2 405s2.35ml 4 +405 S 2.35 1209050 1209178 1209172 OS 3 OS_3 405s2.35ml 3 +405 N 2.35 1209050 1209177 1209173 HV 1 SD_1 405n2.35hv 1 +405 S 2.35 1209050 1209179 1209175 OH 1 SD_2 405s2.35hv 1 +405 S 2.35 1209050 1209178 1211050 OS 4 OS_4 405s2.35ml 2 +405 S 2.35 1209050 1209178 1211051 OS 5 OS_5 405s2.35ml 1 +405 S 2.88 1201136 1201137 1201138 OR 1 RAMP_ON 405s2.88ora 0 +405 S 2.88 1201136 1201137 1201139 QU 2 QUEUE 405s2.88spill 1 +405 S 2.88 1201136 1201137 1201140 DM 3 DEMAND 405s2.88orb 2 +405 S 2.88 1201136 1201137 1201141 PA 4 PASSAGE 405s2.88orb 0 +405 S 2.88 1201136 1201137 1201142 RH 5 RAMP_HOV 405s2.88orb 1 +405 S 2.88 1201136 1201143 1201144 HV 1 SD_1 405s2.88hv 1 +405 S 2.88 1201136 1201145 1201146 ML 1 ML_1 405s2.88ml 4 +405 S 2.88 1201136 1201145 1201147 ML 2 ML_2 405s2.88ml 3 +405 S 2.88 1201136 1201145 1201148 ML 3 ML_3 405s2.88ml 2 +405 S 2.88 1201136 1201145 1201149 ML 4 ML_4 405s2.88ml 1 +405 S 2.88 1201136 1211047 1211048 FR 1 RAMP_OFF 405s2.88fr 1 +405 S 2.88 1201136 1211047 1211049 FR 2 SD_2 ? 0 +405 N 2.99 1201150 1201151 1201152 OR 1 RAMP_ON 405n2.99ora 0 +405 N 2.99 1201150 1201151 1201153 QU 2 QUEUE 405n2.99spill 0 +405 N 2.99 1201150 1201151 1201154 DM 3 DEMAND 405n2.99orb 2 +405 N 2.99 1201150 1201151 1201155 PA 4 PASSAGE 405n2.99orb 0 +405 N 2.99 1201150 1201151 1201156 RH 5 RAMP_HOV 405n2.99orb 1 +405 N 2.99 1201150 1201157 1201158 HV 1 SD_1 405n2.99hv 1 +405 N 2.99 1201150 1201159 1201160 ML 1 ML_1 405n2.99ml 4 +405 N 2.99 1201150 1201159 1201161 ML 2 ML_2 405n2.99ml 3 +405 N 2.99 1201150 1201159 1201162 ML 3 ML_3 405n2.99ml 2 +405 N 2.99 1201150 1201159 1201163 ML 4 ML_4 405n2.99ml 1 +405 N 2.99 1201150 1210057 1210056 FR 1 RAMP_OFF 405n2.99fr 1 +405 N 2.99 1201150 1201157 1211041 HV 2 SD_2 405n2.99hv_2 1 +405 N 3.31 1209051 1209059 1209056 ML 1 ML_1 405n3.31ml 4 +405 N 3.31 1209051 1209059 1209057 ML 2 ML_2 405n3.31ml 3 +405 N 3.31 1209051 1209059 1209058 ML 3 ML_3 405n3.31ml 2 +405 N 3.31 1209051 1209059 1209180 ML 4 ML_4 405n3.31ml 1 +405 S 3.31 1209051 1209189 1209181 OS 1 OS_1 405s3.31ml 4 +405 S 3.31 1209051 1209189 1209182 OS 2 OS_2 405s3.31ml 3 +405 S 3.31 1209051 1209189 1209183 OS 3 OS_3 405s3.31ml 2 +405 S 3.31 1209051 1209189 1209184 OS 4 OS_4 405s3.31ml 1 +405 N 3.31 1209051 1209187 1209185 HV 1 SD_1 405n3.31hv 1 +405 S 3.31 1209051 1209190 1209186 OH 1 SD_2 405s3.31hv 1 +405 S 3.84 1201164 1201165 1201166 OR 1 RAMP_ON 405s3.84ora 0 +405 S 3.84 1201164 1201165 1201167 QU 2 QUEUE 405s3.84ora 0 +405 S 3.84 1201164 1201165 1201168 DM 3 DEMAND 405s3.84ora 0 +405 S 3.84 1201164 1201165 1201169 PA 4 PASSAGE 405s3.84ora 0 +405 S 3.84 1201164 1201165 1201170 RH 5 RAMP_HOV 405s3.84ora 0 +405 S 3.84 1201164 1201171 1201172 ML 1 ML_1 405s3.84ml 4 +405 S 3.84 1201164 1201171 1201173 ML 2 ML_2 405s3.84ml 3 +405 S 3.84 1201164 1201171 1201174 ML 3 ML_3 405s3.84ml 2 +405 S 3.84 1201164 1201171 1201175 ML 4 ML_4 405s3.84ml 1 +405 S 3.84 1201164 1209046 1209044 HV 1 SD_1 405s3.84hv 1 +405 N 3.86 1201176 1201177 1201178 QU 1 QUEUE 405n3.86ora 0 +405 N 3.86 1201176 1201177 1201179 DM 2 DEMAND 405n3.86ora 0 +405 N 3.86 1201176 1201177 1201180 PA 3 PASSAGE 405n3.86ora 0 +405 N 3.86 1201176 1201181 1201182 FR 1 RAMP_OFF 405n3.86fr 1 +405 N 3.86 1201176 1201183 1201184 HV 1 SD_1 405n3.86hv 1 +405 N 3.86 1201176 1201185 1201186 ML 1 ML_1 405n3.86ml 4 +405 N 3.86 1201176 1201185 1201187 ML 2 ML_2 405n3.86ml 3 +405 N 3.86 1201176 1201185 1201188 ML 3 ML_3 405n3.86ml 2 +405 N 3.86 1201176 1201185 1201189 ML 4 ML_4 405n3.86ml 1 +405 N 3.86 1201176 1201181 1209896 FR 2 SD_2 ? 0 +405 S 4.03 1201190 1201191 1201192 QU 1 QUEUE 405s4.03ora 0 +405 S 4.03 1201190 1201191 1201193 DM 2 DEMAND 405s4.03ora 0 +405 S 4.03 1201190 1201191 1201194 PA 3 PASSAGE 405s4.03ora 0 +405 S 4.03 1201190 1201195 1201196 FR 1 RAMP_OFF 405s4.03fr 1 +405 S 4.03 1201190 1201197 1201198 ML 1 ML_1 405s4.03ml 4 +405 S 4.03 1201190 1201197 1201199 ML 2 ML_2 405s4.03ml 3 +405 S 4.03 1201190 1201197 1201200 ML 3 ML_3 405s4.03ml 2 +405 S 4.03 1201190 1201197 1201201 ML 4 ML_4 405s4.03ml 1 +405 N 4.03 1201202 1201203 1201204 OR 1 RAMP_ON 405n4.03ora 0 +405 N 4.03 1201202 1201203 1201205 QU 2 QUEUE 405n4.03ora 0 +405 N 4.03 1201202 1201203 1201206 DM 3 DEMAND 405n4.03ora 0 +405 N 4.03 1201202 1201203 1201207 PA 4 PASSAGE 405n4.03ora 0 +405 N 4.03 1201202 1201203 1201208 RH 5 RAMP_HOV ? 0 +405 N 4.03 1201202 1201209 1201210 HV 1 SD_1 405n4.03hv 1 +405 N 4.03 1201202 1201211 1201212 ML 1 ML_1 405n4.03ml 4 +405 N 4.03 1201202 1201211 1201213 ML 2 ML_2 405n4.03ml 3 +405 N 4.03 1201202 1201211 1201214 ML 3 ML_3 405n4.03ml 2 +405 N 4.03 1201202 1201211 1201215 ML 4 ML_4 405n4.03ml 1 +405 S 4.03 1201190 1209047 1209045 HV 1 SD_1 405s4.03hv 1 +405 S 5.01 1201216 1201217 1201218 ML 1 ML_1 405s5.01ml 4 +405 S 5.01 1201216 1201217 1201219 ML 2 ML_2 405s5.01ml 3 +405 S 5.01 1201216 1201217 1201220 ML 3 ML_3 405s5.01ml 2 +405 S 5.01 1201216 1201217 1201221 ML 4 ML_4 405s5.01ml 1 +405 N 5.01 1201216 1201222 1201223 OS 1 OS_1 405n5.01ml 4 +405 N 5.01 1201216 1201222 1201224 OS 2 OS_2 405n5.01ml 3 +405 N 5.01 1201216 1201222 1201225 OS 3 OS_3 405n5.01ml 2 +405 N 5.01 1201216 1201222 1201226 OS 4 OS_4 405n5.01ml 1 +405 S 5.01 1201216 1201227 1201228 HV 1 SD_1 405s5.01hv 1 +405 N 5.01 1201216 1201229 1201230 OH 1 SD_2 405n5.01hv 1 +405 S 5.05 1209052 1209070 1209062 ML 1 ML_1 405s5.05ml 4 +405 S 5.05 1209052 1209070 1209063 ML 2 ML_2 405s5.05ml 3 +405 S 5.05 1209052 1209070 1209064 ML 3 ML_3 405s5.05ml 2 +405 S 5.05 1209052 1209070 1209065 ML 4 ML_4 405s5.05ml 1 +405 S 5.05 1209052 1209068 1209066 HV 1 SD_1 405s5.05hv 1 +405 S 5.05 1209052 1209076 1209067 OS 1 OS_1 405n5.05ml 4 +405 S 5.05 1209052 1209076 1209069 OS 2 OS_2 405n5.05ml 3 +405 S 5.05 1209052 1209075 1209072 OH 1 SD_2 405n5.05hv 1 +405 S 5.05 1209052 1209076 1209073 OS 3 OS_3 405n5.05ml 2 +405 S 5.05 1209052 1209076 1209074 OS 4 OS_4 405n5.05ml 1 +405 S 5.5 1201231 1201232 1201233 OR 1 RAMP_ON 405s5.5ora 0 +405 S 5.5 1201231 1201232 1201234 QU 2 QUEUE 405s5.5ora 0 +405 S 5.5 1201231 1201232 1201235 DM 3 DEMAND 405s5.5ora 0 +405 S 5.5 1201231 1201232 1201236 PA 4 PASSAGE 405s5.5ora 0 +405 S 5.5 1201231 1201232 1201237 RH 5 RAMP_HOV 405s5.5ora 0 +405 S 5.5 1201231 1201238 1201239 HV 1 SD_1 405s5.5hv 1 +405 S 5.5 1201231 1201240 1201241 ML 1 ML_1 405s5.5ml 4 +405 S 5.5 1201231 1201240 1201242 ML 2 ML_2 405s5.5ml 3 +405 S 5.5 1201231 1201240 1201243 ML 3 ML_3 405s5.5ml 2 +405 S 5.5 1201231 1201240 1201244 ML 4 ML_4 405s5.5ml 1 +405 N 5.55 1201245 1201246 1201247 QU 1 QUEUE 405n5.55ora 0 +405 N 5.55 1201245 1201246 1201248 DM 2 DEMAND 405n5.55ora 0 +405 N 5.55 1201245 1201246 1201249 PA 3 PASSAGE 405n5.55ora 0 +405 N 5.55 1201245 1201246 1201250 RH 4 RAMP_HOV ? 0 +405 N 5.55 1201245 1201251 1201252 FR 1 RAMP_OFF 405n5.55fr 1 +405 N 5.55 1201245 1201251 1201253 FR 2 SD_2 ? 0 +405 N 5.55 1201245 1201254 1201255 ML 1 ML_1 405n5.55ml 4 +405 N 5.55 1201245 1201254 1201256 ML 2 ML_2 405n5.55ml 3 +405 N 5.55 1201245 1201254 1201257 ML 3 ML_3 405n5.55ml 2 +405 N 5.55 1201245 1201254 1201258 ML 4 ML_4 405n5.55ml 1 +405 N 5.55 1201245 1201259 1201260 HV 1 SD_1 405n5.55hv 1 +405 N 5.55 1201245 1201246 1210826 OR 5 RAMP_ON 405n5.55ora 0 +405 N 5.55 1201245 1201251 1212696 FR 3 SD_3 ? 0 +405 S 5.69 1201261 1201262 1201263 QU 1 QUEUE 405s5.69ora 0 +405 S 5.69 1201261 1201262 1201264 DM 2 DEMAND 405s5.69ora 0 +405 S 5.69 1201261 1201262 1201265 PA 3 PASSAGE 405s5.69ora 0 +405 S 5.69 1201261 1201266 1201267 FR 1 RAMP_OFF 405s4.69fr 2 +405 S 5.69 1201261 1201268 1201269 HV 1 SD_1 405s5.69hv 1 +405 S 5.69 1201261 1201270 1201271 ML 1 ML_1 405s5.69ml 4 +405 S 5.69 1201261 1201270 1201272 ML 2 ML_2 405s5.69ml 3 +405 S 5.69 1201261 1201270 1201273 ML 3 ML_3 405s5.69ml 2 +405 S 5.69 1201261 1201270 1201274 ML 4 ML_4 405s5.69ml 1 +405 S 5.69 1201261 1201266 1210827 FR 2 SD_2 405s4.69fr 1 +405 N 5.74 1201275 1201276 1201277 OR 1 RAMP_ON 405n5.74ora 0 +405 N 5.74 1201275 1201276 1201278 QU 2 QUEUE 405n5.74ora 0 +405 N 5.74 1201275 1201276 1201279 DM 3 DEMAND 405n5.74ora 0 +405 N 5.74 1201275 1201276 1201280 PA 4 PASSAGE 405n5.74ora 0 +405 N 5.74 1201275 1201281 1201282 HV 1 SD_1 405n5.74hv 1 +405 N 5.74 1201275 1201283 1201284 ML 1 ML_1 405n5.74ml 5 +405 N 5.74 1201275 1201283 1201285 ML 2 ML_2 405n5.74ml 4 +405 N 5.74 1201275 1201283 1201286 ML 3 ML_3 405n5.74ml 3 +405 N 5.74 1201275 1201283 1201287 ML 4 ML_4 405n5.74ml 2 +405 N 5.74 1201275 1201283 1201288 ML 5 ML_5 405n5.74ml 1 +405 S 6.1 1201289 1201290 1201291 HV 1 SD_1 405s6.21hv 1 +405 S 6.1 1201289 1201292 1201293 ML 1 ML_1 405s6.21ml 5 +405 S 6.1 1201289 1201292 1201294 ML 2 ML_2 405s6.21ml 4 +405 S 6.1 1201289 1201292 1201295 ML 3 ML_3 405s6.21ml 3 +405 S 6.1 1201289 1201292 1201296 ML 4 ML_4 405s6.21ml 2 +405 S 6.1 1201289 1201292 1201297 ML 5 ML_5 405s6.21ml 1 +405 N 6.21 1201289 1201298 1201299 OS 1 OS_1 405n6.21ml 5 +405 N 6.21 1201289 1201298 1201300 OS 2 OS_2 405n6.21ml 4 +405 N 6.21 1201289 1201298 1201301 OS 3 OS_3 405n6.21ml 3 +405 N 6.21 1201289 1201298 1201302 OS 4 OS_4 405n6.21ml 2 +405 N 6.21 1201289 1201298 1201303 OS 5 OS_5 405n6.21ml 1 +405 N 6.21 1201289 1201304 1201305 OH 1 SD_2 405n6.21ml 6 +405 S 6.8 1201306 1201307 1201308 OR 1 RAMP_ON 405s6.8ora 0 +405 S 6.8 1201306 1201307 1201309 QU 2 QUEUE 405s6.8ora 0 +405 S 6.8 1201306 1201307 1201310 DM 3 DEMAND 405s6.8ora 0 +405 S 6.8 1201306 1201307 1201311 PA 4 PASSAGE 405s6.8ora 0 +405 S 6.8 1201306 1201307 1201312 RH 5 RAMP_HOV 405s6.8ora 0 +405 S 6.8 1201306 1201313 1201314 HV 1 SD_1 405s6.8hv 1 +405 S 6.8 1201306 1201315 1201316 ML 1 ML_1 405s6.8ml 5 +405 S 6.8 1201306 1201315 1201317 ML 2 ML_2 405s6.8ml 4 +405 S 6.8 1201306 1201315 1201318 ML 3 ML_3 405s6.8ml 3 +405 S 6.8 1201306 1201315 1201319 ML 4 ML_4 405s6.8ml 2 +405 S 6.8 1201306 1201315 1201320 ML 5 ML_5 405s6.8ml 1 +405 N 6.85 1201321 1201322 1201323 OR 1 RAMP_ON 405n6.85ora 0 +405 N 6.85 1201321 1201322 1201324 QU 2 QUEUE 405n6.85ora 0 +405 N 6.85 1201321 1201322 1201325 DM 3 DEMAND 405n6.85ora 0 +405 N 6.85 1201321 1201322 1201326 PA 4 PASSAGE 405n6.85ora 0 +405 N 6.85 1201321 1201327 1201328 FR 1 RAMP_OFF 405n6.85fr 2 +405 N 6.85 1201321 1201327 1201329 FR 2 SD_2 ? 0 +405 N 6.85 1201321 1201327 1201330 FR 3 SD_3 ? 0 +405 N 6.85 1201321 1201331 1201332 HV 1 SD_1 405n6.85hv 1 +405 N 6.85 1201321 1201333 1201334 ML 1 ML_1 405n6.85ml 5 +405 N 6.85 1201321 1201333 1201335 ML 2 ML_2 405n6.85ml 4 +405 N 6.85 1201321 1201333 1201336 ML 3 ML_3 405n6.85ml 3 +405 N 6.85 1201321 1201333 1201337 ML 4 ML_4 405n6.85ml 2 +405 N 6.85 1201321 1201333 1201338 ML 5 ML_5 405n6.85ml 1 +405 S 7.01 1201339 1201340 1201341 OR 1 RAMP_ON 405s7.01ora 0 +405 S 7.01 1201339 1201340 1201342 QU 2 QUEUE 405s7.01ora 0 +405 S 7.01 1201339 1201340 1201343 DM 3 DEMAND 405s7.01ora 0 +405 S 7.01 1201339 1201340 1201344 PA 4 PASSAGE 405s7.01ora 0 +405 S 7.01 1201339 1201345 1201346 FR 1 RAMP_OFF 405s7.01fr 2 +405 S 7.01 1201339 1201345 1201347 FR 2 SD_2 405s7.01fr 1 +405 S 7.01 1201339 1201348 1201349 HV 1 SD_1 405s7.01hv 1 +405 S 7.01 1201339 1201350 1201351 ML 1 ML_1 405s7.01ml 5 +405 S 7.01 1201339 1201350 1201352 ML 2 ML_2 405s7.01ml 4 +405 S 7.01 1201339 1201350 1201353 ML 3 ML_3 405s7.01ml 3 +405 S 7.01 1201339 1201350 1201354 ML 4 ML_4 405s7.01ml 2 +405 S 7.01 1201339 1201350 1201355 ML 5 ML_5 405s7.01ml 1 +405 N 7.07 1201356 1201357 1201358 OR 1 RAMP_ON 405n7.07ora 0 +405 N 7.07 1201356 1201357 1201359 QU 2 QUEUE 405n7.07ora 0 +405 N 7.07 1201356 1201357 1201360 DM 3 DEMAND 405n7.07ora 0 +405 N 7.07 1201356 1201357 1201361 PA 4 PASSAGE 405n7.07ora 0 +405 N 7.07 1201356 1201357 1201362 RH 5 RAMP_HOV ? 0 +405 N 7.07 1201356 1201363 1201364 HV 1 SD_1 405n7.07hv 1 +405 N 7.07 1201356 1201365 1201366 ML 1 ML_1 405n7.07ml 5 +405 N 7.07 1201356 1201365 1201367 ML 2 ML_2 405n7.07ml 4 +405 N 7.07 1201356 1201365 1201368 ML 3 ML_3 405n7.07ml 3 +405 N 7.07 1201356 1201365 1201369 ML 4 ML_4 405n7.07ml 2 +405 N 7.07 1201356 1201365 1201370 ML 5 ML_5 405n7.07ml 1 +405 S 7.69 1201371 1201372 1201373 OR 1 RAMP_ON 405s7.69ora 0 +405 S 7.69 1201371 1201372 1201374 QU 2 QUEUE 405s7.69ora 0 +405 S 7.69 1201371 1201372 1201375 DM 3 DEMAND 405s7.69ora 0 +405 S 7.69 1201371 1201372 1201376 PA 4 PASSAGE 405s7.69ora 0 +405 S 7.69 1201371 1201377 1201378 FR 1 RAMP_OFF 405s7.69fr 2 +405 S 7.69 1201371 1201377 1201379 FR 2 SD_2 405s7.69fr 1 +405 S 7.69 1201371 1201380 1201381 HV 1 SD_1 405s7.69hv 1 +405 S 7.69 1201371 1201382 1201383 ML 1 ML_1 405s7.69ml 5 +405 S 7.69 1201371 1201382 1201384 ML 2 ML_2 405s7.69ml 4 +405 S 7.69 1201371 1201382 1201385 ML 3 ML_3 405s7.69ml 3 +405 S 7.69 1201371 1201382 1201386 ML 4 ML_4 405s7.69ml 2 +405 S 7.69 1201371 1201382 1201387 ML 5 ML_5 405s7.69ml 1 +405 S 7.69 1201371 1201372 1211110 RH 5 RAMP_HOV 405s7.69ora 0 +405 N 7.73 1201388 1201389 1201390 OR 1 RAMP_ON 405n7.73ora 0 +405 N 7.73 1201388 1201389 1201391 QU 2 QUEUE 405n7.73ora 0 +405 N 7.73 1201388 1201389 1201392 DM 3 DEMAND 405n7.73ora 0 +405 N 7.73 1201388 1201389 1201393 PA 4 PASSAGE 405n7.73ora 0 +405 N 7.73 1201388 1201394 1201395 FR 1 RAMP_OFF 405n7.73fr 1 +405 N 7.73 1201388 1201394 1201396 FR 2 SD_2 ? 0 +405 N 7.73 1201388 1201397 1201398 HV 1 SD_1 405n7.73hv 1 +405 N 7.73 1201388 1201399 1201400 ML 1 ML_1 405n7.73ml 5 +405 N 7.73 1201388 1201399 1201401 ML 2 ML_2 405n7.73ml 4 +405 N 7.73 1201388 1201399 1201402 ML 3 ML_3 405n7.73ml 3 +405 N 7.73 1201388 1201399 1201403 ML 4 ML_4 405n7.73ml 2 +405 N 7.73 1201388 1201399 1201404 ML 5 ML_5 405n7.73ml 1 +405 N 7.73 1201388 1201394 1211043 FR 3 SD_4 ? 0 +405 N 7.73 1201388 1201394 1211044 FR 4 SD_5 ? 0 +405 N 8.27 1201405 1201406 1209192 ML 1 ML_1 405n8.27ml 6 +405 N 8.27 1201405 1201406 1209193 ML 2 ML_2 405n8.27ml 5 +405 N 8.27 1201405 1201406 1209194 ML 3 ML_3 405n8.27ml 4 +405 N 8.27 1201405 1201406 1209195 ML 4 ML_4 405n8.27ml 3 +405 N 8.27 1201405 1201407 1209196 HV 1 SD_1 405n8.27hv 1 +405 S 8.27 1201405 1209204 1209197 OS 1 OS_1 405s8.27ml 6 +405 S 8.27 1201405 1209204 1209198 OS 2 OS_2 405s8.27ml 5 +405 S 8.27 1201405 1209204 1209199 OS 3 OS_3 405s8.27ml 4 +405 S 8.27 1201405 1209204 1209200 OS 4 OS_4 405s8.27ml 3 +405 S 8.27 1201405 1209204 1209201 OS 5 OS_5 405s8.27ml 2 +405 S 8.27 1201405 1209204 1209202 OS 6 OS_6 405s8.27ml 1 +405 S 8.27 1201405 1209205 1209203 OH 1 SD_2 405s8.27hv 1 +405 N 8.27 1201405 1201406 1209471 ML 5 ML_5 405n8.27ml 2 +405 N 8.27 1201405 1201406 1209472 ML 6 ML_6 405n8.27ml 1 +405 S 8.4 1201411 1201412 1201413 CD 1 COLL_DIST_1 405s8.4cd 2 +405 S 8.4 1201411 1201412 1201414 CD 2 COLL_DIST_2 405s8.4cd 1 +405 S 8.4 1201411 1201415 1201416 OC 1 COLL_DIST_ON ? 0 +405 S 8.4 1201411 1201417 1201418 HV 1 SD_1 405s8.4hv 1 +405 S 8.4 1201411 1201419 1201420 ML 1 ML_1 405s8.4ml 5 +405 S 8.4 1201411 1201419 1201421 ML 2 ML_2 405s8.4ml 4 +405 S 8.4 1201411 1201419 1201422 ML 3 ML_3 405s8.4ml 3 +405 S 8.4 1201411 1201419 1201423 ML 4 ML_4 405s8.4ml 2 +405 S 8.4 1201411 1201419 1201424 ML 5 ML_5 405s8.4ffa 1 +405 S 8.4 1201411 1201425 1201426 FF 1 SD_2 405s8.4ffb 1 +405 S 8.4 1201411 1201425 1201427 FF 2 SD_3 ? 0 +405 S 8.4 1201411 1201425 1201428 FF 3 SD_4 ? 0 +405 S 8.4 1201411 1201425 1201429 FF 4 SD_5 ? 0 +405 N 8.4 1201411 1201430 1201431 OS 1 OS_1 405n8.4ml 4 +405 N 8.4 1201411 1201430 1201432 OS 2 OS_2 405n8.4ml 3 +405 N 8.4 1201411 1201430 1201433 OS 3 OS_3 405n8.4ml 2 +405 N 8.4 1201411 1201430 1201434 OS 4 OS_4 405n8.4ml 1 +405 N 8.4 1201411 1201435 1201436 OH 1 SD_6 405n8.4hv 1 +405 S 8.9 1201409 1201410 1209125 ML 1 ML_1 405s8.9ml 4 +405 S 8.9 1201409 1201410 1209126 ML 2 ML_2 405s8.9ml 3 +405 S 8.9 1201409 1201410 1209127 ML 3 ML_3 405s8.9ml 2 +405 S 8.9 1201409 1201410 1209128 ML 4 ML_4 405s8.9ml 1 +405 S 8.9 1201409 1209143 1209131 HV 1 SD_1 405s8.9hv 1 +405 N 8.9 1201409 1209144 1209132 OS 1 OS_1 405n8.9ml 4 +405 N 8.9 1201409 1209144 1209133 OS 2 OS_2 405n8.9ml 3 +405 N 8.9 1201409 1209144 1209134 OS 3 OS_3 405n8.9ml 2 +405 N 8.9 1201409 1209144 1209135 OS 4 OS_4 405n8.9ml 1 +405 N 8.9 1201409 1209145 1209136 OH 1 SD_2 405n8.9hv 1 +405 S 8.9 1201409 1209482 1209478 FF 1 SD_4 405s8.9ff 1 +405 S 8.9 1201409 1209482 1209479 FF 2 SD_5 ? 0 +405 N 8.9 1201409 1209483 1209480 FO 1 SD_6 ? 0 +405 N 8.9 1201409 1209483 1209481 FO 2 SD_3 ? 0 +405 N 9.46 1201444 1201445 1201446 QU 1 QUEUE 405n9.46ora 0 +405 N 9.46 1201444 1201445 1201447 DM 2 DEMAND 405n9.46ora 0 +405 N 9.46 1201444 1201445 1201448 PA 3 PASSAGE 405n9.46ora 0 +405 N 9.46 1201444 1201449 1201450 FR 1 RAMP_OFF 405n9.46fr 1 +405 N 9.46 1201444 1201451 1201452 HV 1 SD_1 405n9.46ml 6 +405 N 9.46 1201444 1201453 1201454 ML 1 ML_1 405n9.46ml 5 +405 N 9.46 1201444 1201453 1201455 ML 2 ML_2 405n9.46ml 4 +405 N 9.46 1201444 1201453 1201456 ML 3 ML_3 405n9.46ml 3 +405 N 9.46 1201444 1201453 1201457 ML 4 ML_4 405n9.46ml 2 +405 N 9.46 1201444 1201453 1201458 ML 5 ML_5 405n9.46ml 1 +405 S 9.54 1201459 1201460 1201461 OR 1 RAMP_ON 405s9.54ora 0 +405 S 9.54 1201459 1201460 1201462 QU 2 QUEUE 405s9.54ora 0 +405 S 9.54 1201459 1201460 1201463 DM 3 DEMAND 405s9.54ora 0 +405 S 9.54 1201459 1201460 1201464 PA 4 PASSAGE 405s9.54ora 0 +405 S 9.54 1201459 1201465 1201466 FR 1 RAMP_OFF 405s9.54fr 2 +405 S 9.54 1201459 1201467 1201468 HV 1 SD_1 405s9.54hv 1 +405 S 9.54 1201459 1201469 1201470 ML 1 ML_1 405s9.54ml 4 +405 S 9.54 1201459 1201469 1201471 ML 2 ML_2 405s9.54ml 3 +405 S 9.54 1201459 1201469 1201472 ML 3 ML_3 405s9.54ml 2 +405 S 9.54 1201459 1201469 1201473 ML 4 ML_4 405s9.54ml 1 +405 S 9.54 1201459 1201469 1201474 ML 5 ML_5 ? 0 +405 N 9.65 1201475 1201476 1201477 OR 1 RAMP_ON 405n9.65ora 0 +405 N 9.65 1201475 1201476 1201478 QU 2 QUEUE 405n9.65ora 0 +405 N 9.65 1201475 1201476 1201479 DM 3 DEMAND 405n9.65ora 0 +405 N 9.65 1201475 1201476 1201480 PA 4 PASSAGE 405n9.65ora 0 +405 N 9.65 1201475 1201481 1201482 ML 1 ML_1 405n9.65ml 5 +405 N 9.65 1201475 1201481 1201483 ML 2 ML_2 405n9.65ml 4 +405 N 9.65 1201475 1201481 1201484 ML 3 ML_3 405n9.65ml 3 +405 N 9.65 1201475 1201481 1201485 ML 4 ML_4 405n9.65ml 2 +405 N 9.65 1201475 1201481 1201486 ML 5 ML_5 405n9.65ml 1 +405 N 9.65 1201475 1201487 1201488 HV 1 SD_1 405n9.65hv 1 +405 S 10.28 1201489 1201490 1201492 DM 1 DEMAND 405s10.3or 0 +405 S 10.28 1201489 1201490 1201493 PA 2 PASSAGE 405s10.3or 0 +405 S 10.28 1201489 1201494 1201495 HV 1 SD_1 405s10.3hv 1 +405 S 10.28 1201489 1201497 1201498 ML 1 ML_1 405s10.3ml 4 +405 S 10.28 1201489 1201497 1201499 ML 2 ML_2 405s10.3ml 3 +405 S 10.28 1201489 1201497 1201500 ML 3 ML_3 405s10.3ml 2 +405 S 10.28 1201489 1201497 1201501 ML 4 ML_4 405s10.3ml 1 +405 S 10.48 1209055 1209217 1209206 ML 1 ML_1 405s10.48ml 4 +405 S 10.48 1209055 1209217 1209207 ML 2 ML_2 405s10.48ml 3 +405 S 10.48 1209055 1209217 1209208 ML 3 ML_3 405s10.48ml 2 +405 S 10.48 1209055 1209217 1209209 ML 4 ML_4 405s10.48ml 1 +405 S 10.48 1209055 1209218 1209210 HV 1 SD_1 405s10.48hv 1 +405 N 10.48 1209055 1209219 1209211 OS 1 OS_1 405n10.48ml 4 +405 N 10.48 1209055 1209219 1209212 OS 2 OS_2 405n10.48ml 3 +405 N 10.48 1209055 1209219 1209213 OS 3 OS_3 405n10.48ml 2 +405 N 10.48 1209055 1209219 1209214 OS 4 OS_4 405n10.48ml 1 +405 N 10.48 1209055 1209220 1209215 OH 1 SD_2 405n10.48hv 1 +405 S 10.48 1209055 1209468 1209457 FF 1 SD_3 405s10.48ff 2 +405 S 10.48 1209055 1209468 1209458 FF 2 SD_4 405s10.48ff 1 +405 N 10.48 1209055 1209485 1209459 FO 1 SD_5 405n10.48ff 3 +405 N 10.48 1209055 1209485 1209460 FO 3 RAMP_HOV 405n10.48ff 1 +405 N 10.48 1209055 1209485 1209461 FO 2 SD_6 405n10.48ff 2 +405 S 10.48 1209055 1209469 1209462 OF 2 COLL_DIST_1 ? 0 +405 S 10.48 1209055 1209469 1209466 OF 1 RAMP_OFF ? 0 +405 N 10.48 1209055 1209484 1209467 OF 1 RAMP_ON ? 0 +405 N 10.9 1201502 1201503 1201504 OR 1 RAMP_ON 405n10.9ora 0 +405 N 10.9 1201502 1201503 1201505 QU 2 QUEUE 405n10.9ora 0 +405 N 10.9 1201502 1201503 1201506 DM 3 DEMAND 405n10.9ora 0 +405 N 10.9 1201502 1201503 1201507 PA 4 PASSAGE 405n10.9ora 0 +405 N 10.9 1201502 1201508 1201509 HV 1 SD_1 405n10.9ml 6 +405 N 10.9 1201502 1201510 1201511 ML 1 ML_1 405n10.9ml 5 +405 N 10.9 1201502 1201510 1201512 ML 2 ML_2 405n10.9ml 4 +405 N 10.9 1201502 1201510 1201513 ML 3 ML_3 405n10.9ml 3 +405 N 10.9 1201502 1201510 1201514 ML 4 ML_4 405n10.9ml 2 +405 N 10.9 1201502 1201510 1201515 ML 5 ML_5 405n10.9ml 1 +405 S 11.2 1201516 1201517 1201518 OR 4 RAMP_ON 405s11.2ora 0 +405 S 11.2 1201516 1201517 1201519 QU 3 QUEUE 405s11.2ora 0 +405 S 11.2 1201516 1201517 1201520 DM 1 DEMAND 405s11.2ora 0 +405 S 11.2 1201516 1201517 1201521 PA 2 PASSAGE 405s11.2ora 0 +405 S 11.2 1201516 1201523 1201524 HV 1 SD_1 405s11.2ml 6 +405 S 11.2 1201516 1201525 1201526 ML 1 ML_1 405s11.2ml 5 +405 S 11.2 1201516 1201525 1201527 ML 2 ML_2 405s11.2ml 4 +405 S 11.2 1201516 1201525 1201528 ML 3 ML_3 405s11.2ml 3 +405 S 11.2 1201516 1201525 1201529 ML 4 ML_4 405s11.2ml 2 +405 S 11.2 1201516 1201525 1201530 ML 5 ML_5 405s11.2ml 1 +405 S 11.2 1201516 1201517 1211193 RH 5 RAMP_HOV 405s11.2ora 0 +405 N 11.4 1201531 1201532 1201533 QU 3 QUEUE 405n11.4spill 0 +405 N 11.4 1201531 1201532 1201534 DM 1 DEMAND 405n11.4orb 0 +405 N 11.4 1201531 1201532 1201535 PA 2 PASSAGE 405n11.4orb 0 +405 N 11.4 1201531 1201536 1201537 FR 1 RAMP_OFF ? 0 +405 N 11.4 1201531 1201539 1201540 HV 1 SD_1 405n11.4hv 1 +405 N 11.4 1201531 1201541 1201542 ML 1 ML_1 405n11.4ml 4 +405 N 11.4 1201531 1201541 1201543 ML 2 ML_2 405n11.4ml 3 +405 N 11.4 1201531 1201541 1201544 ML 3 ML_3 405n11.4ml 2 +405 N 11.4 1201531 1201541 1201545 ML 4 ML_4 405n11.4ml 1 +405 N 11.4 1201531 1201536 1210120 FR 2 SD_4 ? 0 +405 S 11.5 1201547 1201548 1201549 OR 4 RAMP_ON 405s11.5ora 0 +405 S 11.5 1201547 1201548 1201550 QU 3 QUEUE 405s11.5ora 0 +405 S 11.5 1201547 1201548 1201551 DM 1 DEMAND 405s11.5ora 0 +405 S 11.5 1201547 1201548 1201552 PA 2 PASSAGE 405s11.5ora 0 +405 S 11.5 1201547 1201554 1201555 FR 1 RAMP_OFF 405s11.5fr 1 +405 S 11.5 1201547 1201556 1201557 HV 1 SD_1 405s11.5hv 1 +405 S 11.5 1201547 1201558 1201559 ML 1 ML_1 405s11.5ml 5 +405 S 11.5 1201547 1201558 1201560 ML 2 ML_2 405s11.5ml 4 +405 S 11.5 1201547 1201558 1201561 ML 3 ML_3 405s11.5ml 3 +405 S 11.5 1201547 1201558 1201562 ML 4 ML_4 405s11.5ml 2 +405 S 11.5 1201547 1201558 1201563 ML 5 ML_5 405s11.5ml 1 +405 S 11.5 1201547 1201554 1210125 FR 2 SD_4 ? 0 +405 S 11.5 1201547 1201554 1210126 FR 3 SD_5 ? 0 +405 S 11.5 1201547 1201548 1211181 RH 5 RAMP_HOV 405s11.5ora 0 +405 N 11.6 1201564 1201565 1201566 OR 4 RAMP_ON ? 0 +405 N 11.6 1201564 1201565 1201567 QU 3 QUEUE ? 0 +405 N 11.6 1201564 1201565 1201568 DM 1 DEMAND ? 0 +405 N 11.6 1201564 1201565 1201569 PA 2 PASSAGE ? 0 +405 N 11.6 1201564 1201571 1201572 HV 1 SD_1 405n11.6hv 1 +405 N 11.6 1201564 1201573 1201574 ML 1 ML_1 405n11.6ml 4 +405 N 11.6 1201564 1201573 1201575 ML 2 ML_2 405n11.6ml 3 +405 N 11.6 1201564 1201573 1201576 ML 3 ML_3 405n11.6ml 2 +405 N 11.6 1201564 1201573 1201577 ML 4 ML_4 405n11.6ml 1 +405 S 12.16 1209226 1209241 1209227 ML 1 ML_1 405s12.16ml 6 +405 S 12.16 1209226 1209241 1209228 ML 2 ML_2 405s12.16ml 5 +405 S 12.16 1209226 1209241 1209229 ML 3 ML_3 405s12.16ml 4 +405 S 12.16 1209226 1209241 1209230 ML 4 ML_4 405s12.16ml 3 +405 S 12.16 1209226 1209241 1209231 ML 5 ML_5 405s12.16ml 2 +405 S 12.16 1209226 1209241 1209232 ML 6 ML_6 405s12.16ml 1 +405 S 12.16 1209226 1209242 1209233 HV 1 SD_1 405s12.16ml 7 +405 N 12.16 1209226 1209243 1209234 OS 1 OS_1 405n12.16ml 5 +405 N 12.16 1209226 1209243 1209236 OS 2 OS_2 405n12.16ml 4 +405 N 12.16 1209226 1209243 1209237 OS 3 OS_3 405n12.16ml 3 +405 N 12.16 1209226 1209243 1209238 OS 4 OS_4 405n12.16ml 3 +405 N 12.16 1209226 1209243 1209239 OS 5 OS_5 405n12.16ml 1 +405 N 12.16 1209226 1209244 1209240 OH 1 SD_2 405n12.16hv 1 +73 N 23.2 1208924 1210524 1210510 ML 1 ML_1 ? 0 +73 N 23.2 1208924 1210524 1210511 ML 2 ML_2 ? 0 +73 N 23.2 1208924 1210524 1210512 ML 3 ML_3 ? 0 +73 N 23.2 1208924 1210524 1210514 ML 4 ML_4 ? 0 +73 S 23.2 1208924 1210525 1210515 OS 1 OS_1 ? 0 +73 S 23.2 1208924 1210525 1210516 OS 2 OS_2 ? 0 +73 S 23.2 1208924 1210525 1210519 OS 3 OS_3 ? 0 +73 S 23.2 1208924 1210525 1210520 OS 4 OS_4 ? 0 +73 S 23.5 1208925 1210504 1210495 ML 1 ML_1 ? 0 +73 S 23.5 1208925 1210504 1210496 ML 2 ML_2 ? 0 +73 S 23.5 1208925 1210504 1210497 ML 3 ML_3 ? 0 +73 S 23.5 1208925 1210504 1210498 ML 4 ML_4 ? 0 +73 N 23.5 1208925 1210505 1210499 OS 1 OS_1 ? 0 +73 N 23.5 1208925 1210505 1210501 OS 2 OS_2 ? 0 +73 N 23.5 1208925 1210505 1210502 OS 3 OS_3 ? 0 +73 N 23.5 1208925 1210505 1210503 OS 4 OS_4 ? 0 +73 S 23.5 1208925 1210768 1210767 OR 1 RAMP_ON ? 0 +73 S 23.7 1208926 1210494 1210490 ML 1 ML_1 ? 0 +73 S 23.7 1208926 1210494 1210492 ML 2 ML_2 ? 0 +73 S 23.7 1208926 1210494 1210493 ML 3 ML_3 ? 0 +73 S 23.7 1208926 1210770 1210769 OR 1 RAMP_ON ? 0 +73 N 23.9 1210382 1210487 1210480 ML 1 ML_1 ? 0 +73 N 23.9 1210382 1210487 1210481 ML 2 ML_2 ? 0 +73 N 23.9 1210382 1210487 1210482 ML 3 ML_3 ? 0 +73 S 23.9 1210382 1210489 1210483 OS 1 OS_1 ? 0 +73 S 23.9 1210382 1210489 1210484 OS 2 OS_2 ? 0 +73 S 23.9 1210382 1210489 1210485 OS 3 OS_3 ? 0 +73 N 23.9 1210382 1210772 1210771 OR 1 RAMP_ON ? 0 +73 N 24.1 1208927 1210474 1210467 ML 1 ML_1 ? 0 +73 N 24.1 1208927 1210474 1210468 ML 2 ML_2 ? 0 +73 N 24.1 1208927 1210474 1210469 ML 3 ML_3 ? 0 +73 S 24.1 1208927 1210475 1210470 OS 1 OS_1 ? 0 +73 S 24.1 1208927 1210475 1210471 OS 2 OS_2 ? 0 +73 S 24.1 1208927 1210475 1210472 OS 3 OS_3 ? 0 +73 N 24.1 1208927 1210774 1210773 OR 1 RAMP_ON ? 0 +73 S 24.1 1208927 1210799 1210797 OF 1 RAMP_OFF ? 0 +73 S 25.25 1208931 1212454 1212446 ML 1 ML_1 ? 0 +73 S 25.25 1208931 1212454 1212447 ML 2 ML_2 ? 0 +73 S 25.25 1208931 1212454 1212448 ML 3 ML_3 ? 0 +73 N 25.25 1208931 1212455 1212449 OS 1 OS_1 ? 0 +73 N 25.25 1208931 1212455 1212450 OS 2 OS_2 ? 0 +73 N 25.25 1208931 1212455 1212451 OS 3 OS_3 ? 0 +73 N 25.25 1208931 1212455 1212452 OS 4 OS_4 ? 0 +73 S 25.25 1208931 1212504 1212501 FR 1 SD_4 ? 0 +73 S 25.25 1208931 1212504 1212502 FR 2 SD_5 ? 0 +73 N 25.25 1208931 1212505 1212503 FR 1 RAMP_OFF ? 0 +73 N 25.7 1208932 1212463 1212456 ML 1 ML_1 ? 0 +73 N 25.7 1208932 1212463 1212457 ML 2 ML_2 ? 0 +73 N 25.7 1208932 1212463 1212458 ML 3 ML_3 ? 0 +73 S 25.7 1208932 1212464 1212460 OS 2 OS_1 ? 0 +73 S 25.7 1208932 1212464 1212461 OS 3 OS_2 ? 0 +73 S 25.7 1208932 1212464 1212462 OS 4 OS_3 ? 0 +73 S 25.7 1208932 1212506 1212507 FR 1 SD_4 ? 0 +73 S 25.7 1208932 1212506 1212508 FR 2 SD_5 ? 0 +73 N 25.7 1208932 1212514 1212509 DM 1 DEMAND ? 0 +73 N 25.7 1208932 1212514 1212510 PA 2 PASSAGE ? 0 +73 N 25.7 1208932 1212514 1212511 QU 3 QUEUE ? 0 +73 N 25.7 1208932 1212514 1212512 OR 4 RAMP_ON ? 0 +73 S 26.3 1208933 1212472 1212466 ML 2 ML_1 ? 0 +73 S 26.3 1208933 1212472 1212467 ML 3 ML_2 ? 0 +73 S 26.3 1208933 1212518 1212468 FF 1 ML_3 ? 0 +73 N 26.3 1208933 1212473 1212469 OS 1 OS_1 ? 0 +73 N 26.3 1208933 1212473 1212470 OS 2 OS_2 ? 0 +73 N 26.3 1208933 1212473 1212471 OS 3 OS_3 ? 0 +73 S 26.3 1208933 1212519 1212516 FF 1 SD_4 ? 0 +73 S 26.3 1208933 1212519 1212517 FF 2 SD_5 ? 0 +73 N 26.7 1208934 1212479 1212474 ML 1 ML_1 ? 0 +73 N 26.7 1208934 1212479 1212475 ML 2 ML_2 ? 0 +73 S 26.7 1208934 1212480 1212477 OS 2 OS_1 ? 0 +73 S 26.7 1208934 1212480 1212478 OS 3 OS_2 ? 0 +73 N 26.7 1208934 1212544 1212540 FF 1 SD_1 ? 0 +73 N 26.7 1208934 1212544 1212541 FF 2 SD_2 ? 0 +73 S 26.7 1208934 1212545 1212542 FF 1 SD_4 ? 0 +73 S 26.7 1208934 1212545 1212543 FF 2 SD_5 ? 0 +73 S 27.2 1208935 1212484 1212481 ML 1 ML_1 ? 0 +73 S 27.2 1208935 1212484 1212482 ML 2 ML_2 ? 0 +73 S 27.2 1208935 1212484 1212483 ML 3 ML_3 ? 0 +73 S 27.2 1208935 1212525 1212520 DM 1 DEMAND ? 0 +73 S 27.2 1208935 1212525 1212521 PA 2 PASSAGE ? 0 +73 S 27.2 1208935 1212525 1212522 QU 3 QUEUE ? 0 +73 S 27.2 1208935 1212525 1212523 OR 4 RAMP_ON ? 0 +73 N 27.2 1208935 1212526 1212524 FR 1 RAMP_OFF ? 0 +73 N 27.4 1212485 1212489 1212486 ML 1 ML_1 ? 0 +73 N 27.4 1212485 1212489 1212487 ML 2 ML_2 ? 0 +73 N 27.4 1212485 1212489 1212488 ML 3 ML_3 ? 0 +73 N 27.4 1212485 1212532 1212527 DM 1 DEMAND ? 0 +73 N 27.4 1212485 1212532 1212528 PA 2 PASSAGE ? 0 +73 N 27.4 1212485 1212532 1212529 QU 3 QUEUE ? 0 +73 N 27.4 1212485 1212532 1212530 OR 4 RAMP_ON ? 0 +73 S 27.4 1212485 1212533 1212531 FR 1 RAMP_OFF ? 0 +73 S 27.72 1208936 1212495 1212490 ML 1 ML_1 ? 0 +73 S 27.72 1208936 1212495 1212491 ML 2 ML_2 ? 0 +73 N 27.72 1208936 1212496 1212492 OS 1 OS_1 ? 0 +73 N 27.72 1208936 1212496 1212493 OS 2 OS_2 ? 0 +73 N 27.72 1208936 1212496 1212494 OS 3 OS_3 ? 0 +73 S 27.72 1208936 1212537 1212534 DM 1 DEMAND ? 0 +73 S 27.72 1208936 1212537 1212535 PA 2 PASSAGE ? 0 +73 S 27.72 1208936 1212537 1212536 QU 3 QUEUE ? 0 +73 S 27.728 1201489 1209500 1209499 OR 1 SD_3 ? 0 +133 S 9 1201043 1201044 1201045 OR 1 RAMP_ON ? 0 +133 S 9 1201043 1201044 1201046 QU 2 QUEUE ? 0 +133 S 9 1201043 1201044 1201047 DM 3 DEMAND ? 0 +133 S 9 1201043 1201044 1201048 PA 4 PASSAGE ? 0 +133 S 9 1201043 1201044 1201049 RH 5 RAMP_HOV ? 0 +133 S 9 1201043 1201054 1201051 ML 3 ML_3 ? 0 +133 S 9 1201043 1201052 1201053 FR 1 RAMP_OFF ? 0 +133 S 9 1201043 1201054 1201055 ML 1 ML_1 ? 0 +133 S 9 1201043 1201054 1201056 ML 2 ML_2 ? 0 +133 N 9 1201057 1201058 1201059 OR 1 RAMP_ON ? 0 +133 N 9 1201057 1201058 1201060 QU 2 QUEUE ? 0 +133 N 9 1201057 1201058 1201061 DM 3 DEMAND ? 0 +133 N 9 1201057 1201058 1201062 PA 4 PASSAGE ? 0 +133 N 9 1201057 1201058 1201063 RH 5 RAMP_HOV ? 0 +133 N 9 1201057 1201064 1201065 FR 1 RAMP_OFF ? 0 +133 N 9 1201057 1201066 1201067 ML 1 ML_1 ? 0 +133 N 9 1201057 1201066 1201068 ML 2 ML_2 ? 0 +133 N 9.1 1201069 1201070 1201071 OR 1 RAMP_ON ? 0 +133 N 9.1 1201069 1201070 1201072 QU 2 QUEUE ? 0 +133 N 9.1 1201069 1201070 1201073 DM 3 DEMAND ? 0 +133 N 9.1 1201069 1201070 1201074 PA 4 PASSAGE ? 0 +133 N 9.1 1201069 1201070 1201075 RH 5 RAMP_HOV ? 0 +133 N 9.1 1201069 1201076 1201077 ML 1 ML_1 ? 0 +133 N 9.1 1201069 1201076 1201078 ML 2 ML_2 ? 0 +133 N 9.1 1201069 1201076 1201079 ML 3 ML_3 ? 0 +133 N 9.37 1211774 1211784 1211775 ML 1 ML_1 ? 0 +133 N 9.37 1211774 1211784 1211776 ML 2 ML_2 ? 0 +133 N 9.37 1211774 1211785 1211777 FF 1 SD_1 ? 0 +133 N 9.37 1211774 1211785 1211778 FF 2 SD_2 ? 0 +133 N 9.37 1211774 1211786 1211779 OC 1 COLL_DIST_ON ? 0 +133 S 9.37 1211774 1211787 1211780 OS 1 OS_1 ? 0 +133 S 9.37 1211774 1211787 1211781 OS 2 OS_2 ? 0 +133 S 9.37 1211774 1211788 1211782 FO 1 SD_3 ? 0 +133 S 9.37 1211774 1211788 1211783 FO 2 SD_4 ? 0 +133 N 9.77 1211762 1211770 1211763 ML 1 ML_1 ? 0 +133 N 9.77 1211762 1211770 1211764 ML 2 ML_2 ? 0 +133 N 9.77 1211762 1211771 1211765 FF 1 SD_1 ? 0 +133 S 9.77 1211762 1211772 1211766 OS 1 OS_1 ? 0 +133 S 9.77 1211762 1211772 1211767 OS 2 OS_2 ? 0 +133 S 9.77 1211762 1211773 1211768 FO 1 SD_2 ? 0 +133 S 9.77 1211762 1211773 1211769 FO 2 SD_3 ? 0 +133 N 10.05 1211754 1211760 1211755 ML 1 ML_1 ? 0 +133 N 10.05 1211754 1211760 1211756 ML 2 ML_2 ? 0 +133 S 10.05 1211754 1211761 1211757 OS 1 OS_1 ? 0 +133 S 10.05 1211754 1211761 1211758 OS 2 OS_2 ? 0 +133 S 10.05 1211754 1211761 1211759 OS 3 OS_3 ? 0 +133 N 10.5 1211742 1211750 1211743 ML 1 ML_1 ? 0 +133 N 10.5 1211742 1211750 1211744 ML 2 ML_2 ? 0 +133 N 10.5 1211742 1211751 1211745 FF 1 SD_1 ? 0 +133 S 10.5 1211742 1211752 1211746 OS 1 OS_1 ? 0 +133 S 10.5 1211742 1211752 1211747 OS 2 OS_2 ? 0 +133 S 10.5 1211742 1211753 1211748 FO 1 SD_2 ? 0 +133 S 10.5 1211742 1211753 1211749 FO 2 SD_3 ? 0 +133 N 10.73 1211733 1211740 1211734 ML 1 ML_1 ? 0 +133 N 10.73 1211733 1211740 1211735 ML 2 ML_2 ? 0 +133 N 10.73 1211733 1211740 1211736 ML 3 ML_3 ? 0 +133 S 10.73 1211733 1211741 1211737 OS 1 OS_1 ? 0 +133 S 10.73 1211733 1211741 1211738 OS 2 OS_2 ? 0 +133 S 10.73 1211733 1211741 1211739 OS 3 OS_3 ? 0 +133 N 11.08 1211726 1211731 1211727 ML 1 ML_1 ? 0 +133 N 11.08 1211726 1211731 1211728 ML 2 ML_2 ? 0 +133 S 11.08 1211726 1211732 1211729 OS 1 OS_1 ? 0 +133 S 11.08 1211726 1211732 1211730 OS 2 OS_2 ? 0 +133 N 11.35 1211719 1211724 1211720 ML 1 ML_1 ? 0 +133 N 11.35 1211719 1211724 1211721 ML 2 ML_2 ? 0 +133 S 11.35 1211719 1211725 1211722 OS 1 OS_1 ? 0 +133 S 11.35 1211719 1211725 1211723 OS 2 OS_2 ? 0 +133 S 11.7 1211710 1211716 1211711 ML 1 ML_1 ? 0 +133 S 11.7 1211710 1211716 1211712 ML 2 ML_2 ? 0 +133 N 11.7 1211710 1211717 1211713 OS 1 OS_1 ? 0 +133 N 11.7 1211710 1211717 1211714 OS 2 OS_2 ? 0 +133 N 11.7 1211710 1211718 1211715 OF 1 RAMP_OFF ? 0 +133 N 12.05 1211694 1211706 1211695 ML 1 ML_1 ? 0 +133 N 12.05 1211694 1211706 1211696 ML 2 ML_2 ? 0 +133 N 12.05 1211694 1211706 1211697 ML 3 ML_3 ? 0 +133 N 12.05 1211694 1211707 1211698 DM 1 DEMAND ? 0 +133 N 12.05 1211694 1211707 1211699 PA 2 PASSAGE ? 0 +133 N 12.05 1211694 1211707 1211700 QU 3 QUEUE ? 0 +133 N 12.05 1211694 1211707 1211701 OR 4 RAMP_ON ? 0 +133 S 12.05 1211694 1211708 1211702 OS 1 OS_1 ? 0 +133 S 12.05 1211694 1211708 1211703 OS 2 OS_2 ? 0 +133 S 12.05 1211694 1211709 1211704 OF 1 RAMP_OFF ? 0 +133 S 12.05 1211694 1211709 1211705 OF 2 SD_1 ? 0 +133 N 12.42 1211685 1211692 1211686 ML 1 ML_1 ? 0 +133 N 12.42 1211685 1211692 1211687 ML 2 ML_2 ? 0 +133 N 12.42 1211685 1211692 1211688 ML 3 ML_3 ? 0 +133 S 12.42 1211685 1211693 1211689 OS 1 OS_1 ? 0 +133 S 12.42 1211685 1211693 1211690 OS 2 OS_2 ? 0 +133 S 12.42 1211685 1211693 1211691 OS 3 OS_3 ? 0 +133 N 12.77 1211667 1211682 1211668 ML 1 ML_1 ? 0 +133 N 12.77 1211667 1211682 1211669 ML 2 ML_2 ? 0 +133 N 12.77 1211667 1211683 1211674 FF 1 SD_4 ? 0 +133 N 12.77 1211667 1211683 1211675 FF 2 SD_5 ? 0 Index: /trunk/config/atms_driver_config.properties =================================================================== --- /trunk/config/atms_driver_config.properties (revision 79) +++ /trunk/config/atms_driver_config.properties (revision 79) @@ -0,0 +1,4 @@ +LDSFileName = config/vds_data/lds.txt +LoopFileName = config/vds_data/loop.txt +NetworkFileName = networkFile.txt +ExchangeFileName = exchange.xml Index: /trunk/networkFile.txt =================================================================== --- /trunk/networkFile.txt (revision 79) +++ /trunk/networkFile.txt (revision 79) @@ -0,0 +1,16587 @@ + + + + 5 + 20 + 1 + 1 + 1123005673 + 1357648 + 26492 + + + 1205270 + 5 + 19 + MAIN 1 + 33.0 + S + 5 + 0 + 0 + + + 1205272 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205273 + QUEUE + 2 + 0 + 0 + 0 + + + 1205274 + DEMAND + 3 + 0 + 0 + 0 + + + 1205275 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205277 + ML_1 + 1 + 0 + 0 + 0 + + + 1205278 + ML_2 + 2 + 0 + 0 + 0 + + + 1205279 + ML_3 + 3 + 0 + 0 + 0 + + + 1209945 + ML_4 + 4 + 0 + 0 + 0 + + + 1209947 + ML_5 + 5 + 0 + 0 + 0 + + + 1209948 + SD_1 + 1 + 0 + 0 + 0 + + + 1209949 + SD_2 + 1 + 0 + 0 + 0 + + + + + + + 6 + 19 + 2 + 2 + 1123005691 + 1357639 + 26491 + + + 1208933 + 6 + 15 + S OF 55 + 26.3 + S + 73 + 0 + 0 + + + 1212466 + ML_1 + 2 + 0 + 0 + 0 + + + 1212467 + ML_2 + 3 + 0 + 0 + 0 + + + 1212468 + ML_3 + 1 + 0 + 0 + 0 + + + 1212469 + OS_1 + 1 + 0 + 0 + 0 + + + 1212470 + OS_2 + 2 + 0 + 0 + 0 + + + 1212471 + OS_3 + 3 + 0 + 0 + 0 + + + 1212516 + SD_4 + 1 + 0 + 0 + 0 + + + 1212517 + SD_5 + 2 + 0 + 0 + 0 + + + + + 1203081 + 6 + 17 + BRISTOL + 4.58 + N + 55 + 0 + 0 + + + 1210208 + ML_1 + 1 + 0 + 0 + 0 + + + 1210209 + ML_2 + 2 + 0 + 0 + 0 + + + 1210210 + ML_3 + 3 + 0 + 0 + 0 + + + 1210211 + ML_4 + 4 + 0 + 0 + 0 + + + 1210212 + OS_1 + 1 + 0 + 0 + 0 + + + 1210213 + OS_2 + 2 + 0 + 0 + 0 + + + 1210214 + OS_3 + 3 + 0 + 0 + 0 + + + 1210215 + OS_4 + 4 + 0 + 0 + 0 + + + 1210216 + SD_4 + 1 + 0 + 0 + 0 + + + 1210217 + SD_5 + 2 + 0 + 0 + 0 + + + 1210218 + SD_1 + 1 + 0 + 0 + 0 + + + 1210219 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1203083 + 6 + 18 + BAKER 1 + 4.7 + S + 55 + 0 + 0 + + + 1210195 + ML_1 + 1 + 0 + 0 + 0 + + + 1210196 + ML_2 + 2 + 0 + 0 + 0 + + + 1210197 + ML_3 + 3 + 0 + 0 + 0 + + + 1210198 + OS_1 + 1 + 0 + 0 + 0 + + + 1210199 + OS_2 + 2 + 0 + 0 + 0 + + + 1210200 + OS_3 + 3 + 0 + 0 + 0 + + + 1210201 + DEMAND + 1 + 0 + 0 + 0 + + + 1210202 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210203 + QUEUE + 3 + 0 + 0 + 0 + + + 1210204 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1210174 + 6 + 19 + BAKER 2 + 5.06 + S + 55 + 0 + 0 + + + 1210175 + ML_1 + 1 + 0 + 0 + 0 + + + 1210176 + ML_2 + 2 + 0 + 0 + 0 + + + 1210177 + ML_3 + 3 + 0 + 0 + 0 + + + 1210178 + OS_1 + 1 + 0 + 0 + 0 + + + 1210179 + OS_2 + 2 + 0 + 0 + 0 + + + 1210180 + OS_3 + 3 + 0 + 0 + 0 + + + 1210181 + SD_1 + 1 + 0 + 0 + 0 + + + 1210182 + SD_2 + 2 + 0 + 0 + 0 + + + 1210185 + SD_3 + 1 + 0 + 0 + 0 + + + 1210186 + SD_4 + 2 + 0 + 0 + 0 + + + 1210187 + SD_6 + 1 + 0 + 0 + 0 + + + 1210188 + SD_5 + 1 + 0 + 0 + 0 + + + + + 1210163 + 6 + 20 + PAULARINO 1 + 5.51 + N + 55 + 0 + 0 + + + 1210164 + ML_1 + 1 + 0 + 0 + 0 + + + 1210165 + ML_2 + 2 + 0 + 0 + 0 + + + 1210166 + ML_3 + 3 + 0 + 0 + 0 + + + 1210167 + ML_4 + 4 + 0 + 0 + 0 + + + 1210168 + OS_1 + 1 + 0 + 0 + 0 + + + 1210169 + OS_2 + 2 + 0 + 0 + 0 + + + 1210170 + OS_3 + 3 + 0 + 0 + 0 + + + 1210171 + OS_4 + 4 + 0 + 0 + 0 + + + + + + + 22 + 19 + 4 + 4 + 1123005726 + 1357624 + 26490 + + + 1204875 + 22 + 1 + N OF SAND CNYN + 24.5 + N + 5 + 0 + 0 + + + 1204877 + SD_1 + 1 + 0 + 0 + 0 + + + 1204879 + ML_1 + 1 + 0 + 0 + 0 + + + 1204880 + ML_2 + 2 + 0 + 0 + 0 + + + 1204881 + ML_3 + 3 + 0 + 0 + 0 + + + 1204882 + ML_4 + 4 + 0 + 0 + 0 + + + 1204883 + ML_5 + 5 + 0 + 0 + 0 + + + 1204885 + SD_2 + 1 + 0 + 0 + 0 + + + 1204887 + OS_1 + 1 + 0 + 0 + 0 + + + 1204888 + OS_2 + 2 + 0 + 0 + 0 + + + 1204889 + OS_3 + 3 + 0 + 0 + 0 + + + 1204890 + OS_4 + 4 + 0 + 0 + 0 + + + 1204891 + OS_5 + 5 + 0 + 0 + 0 + + + + + 1204847 + 22 + 2 + SAND CANYON 2 + 24.05 + N + 5 + 0 + 0 + + + 1204849 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204850 + QUEUE + 2 + 0 + 0 + 0 + + + 1204851 + DEMAND + 3 + 0 + 0 + 0 + + + 1204852 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204853 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1204855 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204856 + SD_2 + 2 + 0 + 0 + 0 + + + 1204858 + SD_4 + 1 + 0 + 0 + 0 + + + 1204860 + SD_1 + 1 + 0 + 0 + 0 + + + 1204862 + ML_1 + 1 + 0 + 0 + 0 + + + 1204863 + ML_2 + 2 + 0 + 0 + 0 + + + 1204864 + ML_3 + 3 + 0 + 0 + 0 + + + 1204865 + ML_4 + 4 + 0 + 0 + 0 + + + 1204866 + ML_5 + 5 + 0 + 0 + 0 + + + 1204868 + SD_3 + 1 + 0 + 0 + 0 + + + 1204870 + OS_1 + 1 + 0 + 0 + 0 + + + 1204871 + OS_2 + 2 + 0 + 0 + 0 + + + 1204872 + OS_3 + 3 + 0 + 0 + 0 + + + 1204873 + OS_4 + 4 + 0 + 0 + 0 + + + 1204874 + OS_5 + 5 + 0 + 0 + 0 + + + + + 1204832 + 22 + 3 + SAND CANYON 1 + 23.69 + S + 5 + 0 + 0 + + + 1204834 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204835 + QUEUE + 2 + 0 + 0 + 0 + + + 1204836 + DEMAND + 3 + 0 + 0 + 0 + + + 1204837 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204838 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1204840 + SD_1 + 1 + 0 + 0 + 0 + + + 1204842 + ML_1 + 1 + 0 + 0 + 0 + + + 1204843 + ML_2 + 2 + 0 + 0 + 0 + + + 1204844 + ML_3 + 3 + 0 + 0 + 0 + + + 1204845 + ML_4 + 4 + 0 + 0 + 0 + + + 1204846 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1204973 + 22 + 4 + CULVER 1 + 26.56 + N + 5 + 0 + 0 + + + 1204975 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204976 + QUEUE + 2 + 0 + 0 + 0 + + + 1204977 + DEMAND + 3 + 0 + 0 + 0 + + + 1204978 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204981 + SD_1 + 1 + 0 + 0 + 0 + + + 1204983 + ML_1 + 1 + 0 + 0 + 0 + + + 1204984 + ML_2 + 2 + 0 + 0 + 0 + + + 1204985 + ML_3 + 3 + 0 + 0 + 0 + + + 1204986 + ML_4 + 4 + 0 + 0 + 0 + + + 1204987 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1205003 + 22 + 5 + CULVER 2 + 26.81 + N + 5 + 0 + 0 + + + 1205005 + QUEUE + 1 + 0 + 0 + 0 + + + 1205006 + DEMAND + 2 + 0 + 0 + 0 + + + 1205007 + PASSAGE + 3 + 0 + 0 + 0 + + + 1205009 + SD_3 + 1 + 0 + 0 + 0 + + + 1205011 + SD_1 + 1 + 0 + 0 + 0 + + + 1205013 + ML_1 + 1 + 0 + 0 + 0 + + + 1205014 + ML_2 + 2 + 0 + 0 + 0 + + + 1205015 + ML_3 + 3 + 0 + 0 + 0 + + + 1205016 + ML_4 + 4 + 0 + 0 + 0 + + + 1205017 + ML_5 + 5 + 0 + 0 + 0 + + + 1205018 + ML_6 + 6 + 0 + 0 + 0 + + + + + 1204958 + 22 + 6 + CULVER 1 + 26.35 + S + 5 + 0 + 0 + + + 1204960 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204961 + QUEUE + 2 + 0 + 0 + 0 + + + 1204962 + DEMAND + 3 + 0 + 0 + 0 + + + 1204963 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204964 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1204966 + SD_1 + 1 + 0 + 0 + 0 + + + 1204968 + ML_1 + 1 + 0 + 0 + 0 + + + 1204969 + ML_2 + 2 + 0 + 0 + 0 + + + 1204970 + ML_3 + 3 + 0 + 0 + 0 + + + 1204971 + ML_4 + 4 + 0 + 0 + 0 + + + 1204972 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1204988 + 22 + 7 + CULVER 2 + 26.66 + S + 5 + 0 + 0 + + + 1204990 + QUEUE + 1 + 0 + 0 + 0 + + + 1204991 + DEMAND + 2 + 0 + 0 + 0 + + + 1204992 + PASSAGE + 3 + 0 + 0 + 0 + + + 1204994 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204996 + SD_1 + 1 + 0 + 0 + 0 + + + 1204998 + ML_1 + 1 + 0 + 0 + 0 + + + 1204999 + ML_2 + 2 + 0 + 0 + 0 + + + 1205000 + ML_3 + 3 + 0 + 0 + 0 + + + 1205001 + ML_4 + 4 + 0 + 0 + 0 + + + 1205002 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1204928 + 22 + 8 + JEFFREY 2 + 25.15 + N + 5 + 0 + 0 + + + 1204930 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204931 + QUEUE + 2 + 0 + 0 + 0 + + + 1204932 + DEMAND + 3 + 0 + 0 + 0 + + + 1204933 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204934 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1204936 + SD_1 + 1 + 0 + 0 + 0 + + + 1204938 + ML_4 + 4 + 0 + 0 + 0 + + + 1204939 + ML_5 + 5 + 0 + 0 + 0 + + + 1204940 + ML_3 + 3 + 0 + 0 + 0 + + + 1212845 + ML_1 + 1 + 0 + 0 + 0 + + + 1212846 + ML_2 + 2 + 0 + 0 + 0 + + + + + 1205077 + 22 + 9 + TUSTIN RANCH + 28.1 + N + 5 + 0 + 0 + + + 1205079 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205080 + QUEUE + 2 + 0 + 0 + 0 + + + 1205081 + DEMAND + 3 + 0 + 0 + 0 + + + 1205082 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205083 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1205085 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1205087 + SD_1 + 1 + 0 + 0 + 0 + + + 1205089 + ML_1 + 1 + 0 + 0 + 0 + + + 1205090 + ML_2 + 2 + 0 + 0 + 0 + + + 1205091 + ML_3 + 3 + 0 + 0 + 0 + + + 1205092 + ML_4 + 4 + 0 + 0 + 0 + + + 1205093 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1205229 + 22 + 10 + GRAND 2 + 32.0 + S + 5 + 0 + 0 + + + 1205231 + ML_1 + 1 + 0 + 0 + 0 + + + 1205232 + ML_2 + 2 + 0 + 0 + 0 + + + 1205233 + ML_3 + 3 + 0 + 0 + 0 + + + 1209765 + ML_4 + 4 + 0 + 0 + 0 + + + 1209766 + ML_5 + 5 + 0 + 0 + 0 + + + 1209767 + DEMAND + 1 + 0 + 0 + 0 + + + 1209768 + PASSAGE + 2 + 0 + 0 + 0 + + + 1209769 + QUEUE + 3 + 0 + 0 + 0 + + + 1209770 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1209771 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1209772 + SD_1 + 1 + 0 + 0 + 0 + + + 1209773 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1205176 + 22 + 11 + 1ST + 30.9 + S + 5 + 0 + 0 + + + 1205178 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205179 + QUEUE + 2 + 0 + 0 + 0 + + + 1205180 + DEMAND + 3 + 0 + 0 + 0 + + + 1205181 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205183 + ML_1 + 1 + 0 + 0 + 0 + + + 1205184 + ML_2 + 2 + 0 + 0 + 0 + + + 1205185 + ML_3 + 3 + 0 + 0 + 0 + + + 1205186 + ML_4 + 4 + 0 + 0 + 0 + + + 1205187 + ML_5 + 5 + 0 + 0 + 0 + + + 1208318 + OS_1 + 1 + 0 + 0 + 0 + + + 1208319 + OS_2 + 2 + 0 + 0 + 0 + + + 1208320 + OS_3 + 3 + 0 + 0 + 0 + + + 1208498 + OS_4 + 4 + 0 + 0 + 0 + + + 1208500 + OS_5 + 5 + 0 + 0 + 0 + + + 1209504 + SD_1 + 1 + 0 + 0 + 0 + + + 1209505 + SD_6 + 1 + 0 + 0 + 0 + + + 1209695 + SD_3 + 2 + 0 + 0 + 0 + + + 1209696 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1211152 + SD_5 + 1 + 0 + 0 + 0 + + + 1211153 + SD_4 + 1 + 0 + 0 + 0 + + + + + 1205188 + 22 + 12 + 4TH + 31.23 + N + 5 + 0 + 0 + + + 1205194 + ML_1 + 1 + 0 + 0 + 0 + + + 1205195 + ML_2 + 2 + 0 + 0 + 0 + + + 1205196 + ML_3 + 3 + 0 + 0 + 0 + + + 1205190 + OS_1 + 1 + 0 + 0 + 0 + + + 1205191 + OS_2 + 2 + 0 + 0 + 0 + + + 1205192 + OS_3 + 3 + 0 + 0 + 0 + + + 1209711 + ML_4 + 4 + 0 + 0 + 0 + + + 1209712 + ML_5 + 5 + 0 + 0 + 0 + + + 1209713 + OS_4 + 4 + 0 + 0 + 0 + + + 1209714 + OS_5 + 5 + 0 + 0 + 0 + + + 1209715 + DEMAND + 1 + 0 + 0 + 0 + + + 1209716 + PASSAGE + 2 + 0 + 0 + 0 + + + 1209717 + QUEUE + 3 + 0 + 0 + 0 + + + 1209718 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1209719 + SD_1 + 1 + 0 + 0 + 0 + + + 1209720 + SD_2 + 2 + 0 + 0 + 0 + + + 1209721 + SD_3 + 1 + 0 + 0 + 0 + + + 1209723 + SD_4 + 1 + 0 + 0 + 0 + + + 1209724 + SD_5 + 2 + 0 + 0 + 0 + + + 1212737 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1212738 + SD_6 + 1 + 0 + 0 + 0 + + + + + 1205219 + 22 + 13 + GRAND 2 + 31.9 + N + 5 + 0 + 0 + + + 1205221 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205222 + QUEUE + 2 + 0 + 0 + 0 + + + 1205223 + DEMAND + 3 + 0 + 0 + 0 + + + 1205224 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205226 + ML_1 + 1 + 0 + 0 + 0 + + + 1205227 + ML_2 + 2 + 0 + 0 + 0 + + + 1205228 + ML_3 + 3 + 0 + 0 + 0 + + + 1209759 + ML_4 + 4 + 0 + 0 + 0 + + + 1209760 + ML_5 + 5 + 0 + 0 + 0 + + + 1209761 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1209762 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1205238 + 22 + 16 + 17TH 1 + 32.25 + S + 5 + 0 + 0 + + + 1205240 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205241 + QUEUE + 2 + 0 + 0 + 0 + + + 1205242 + DEMAND + 3 + 0 + 0 + 0 + + + 1205243 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205245 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1205247 + ML_1 + 1 + 0 + 0 + 0 + + + 1205248 + ML_2 + 2 + 0 + 0 + 0 + + + 1205249 + ML_3 + 3 + 0 + 0 + 0 + + + 1209819 + ML_4 + 4 + 0 + 0 + 0 + + + 1209820 + ML_5 + 5 + 0 + 0 + 0 + + + 1209821 + OS_4 + 4 + 0 + 0 + 0 + + + 1209822 + OS_5 + 5 + 0 + 0 + 0 + + + 1209823 + SD_1 + 1 + 0 + 0 + 0 + + + 1209824 + SD_2 + 1 + 0 + 0 + 0 + + + 1205251 + OS_1 + 1 + 0 + 0 + 0 + + + 1205252 + OS_2 + 2 + 0 + 0 + 0 + + + 1205253 + OS_3 + 3 + 0 + 0 + 0 + + + + + 1205208 + 22 + 17 + GRAND 1 + 31.6 + S + 5 + 0 + 0 + + + 1205212 + ML_1 + 1 + 0 + 0 + 0 + + + 1205213 + ML_2 + 2 + 0 + 0 + 0 + + + 1205214 + ML_3 + 3 + 0 + 0 + 0 + + + 1205216 + OS_1 + 1 + 0 + 0 + 0 + + + 1205217 + OS_2 + 2 + 0 + 0 + 0 + + + 1205218 + OS_3 + 3 + 0 + 0 + 0 + + + 1209748 + ML_4 + 4 + 0 + 0 + 0 + + + 1209749 + ML_5 + 5 + 0 + 0 + 0 + + + 1209750 + ML_6 + 6 + 0 + 0 + 0 + + + 1209751 + OS_4 + 4 + 0 + 0 + 0 + + + 1209752 + OS_5 + 5 + 0 + 0 + 0 + + + 1209754 + SD_1 + 1 + 0 + 0 + 0 + + + 1209755 + SD_2 + 1 + 0 + 0 + 0 + + + 1212778 + SD_3 + 1 + 0 + 0 + 0 + + + 1212779 + SD_4 + 1 + 0 + 0 + 0 + + + + + 1204912 + 22 + 18 + JEFFREY 1 + 25.08 + N + 5 + 0 + 0 + + + 1204914 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204915 + QUEUE + 2 + 0 + 0 + 0 + + + 1204916 + DEMAND + 3 + 0 + 0 + 0 + + + 1204917 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204918 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1204920 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204921 + SD_2 + 2 + 0 + 0 + 0 + + + 1204923 + SD_1 + 1 + 0 + 0 + 0 + + + 1204925 + ML_4 + 4 + 0 + 0 + 0 + + + 1204926 + ML_5 + 5 + 0 + 0 + 0 + + + 1204927 + ML_3 + 3 + 0 + 0 + 0 + + + 1212843 + ML_1 + 1 + 0 + 0 + 0 + + + 1212844 + ML_2 + 2 + 0 + 0 + 0 + + + + + 1204892 + 22 + 19 + JEFFREY 1 + 24.84 + S + 5 + 0 + 0 + + + 1204894 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204895 + QUEUE + 2 + 0 + 0 + 0 + + + 1204896 + DEMAND + 3 + 0 + 0 + 0 + + + 1204897 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204898 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1204900 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204901 + SD_2 + 2 + 0 + 0 + 0 + + + 1204903 + SD_1 + 1 + 0 + 0 + 0 + + + 1204905 + ML_1 + 1 + 0 + 0 + 0 + + + 1204906 + ML_2 + 2 + 0 + 0 + 0 + + + 1204907 + ML_3 + 3 + 0 + 0 + 0 + + + 1204908 + ML_4 + 4 + 0 + 0 + 0 + + + 1204909 + ML_5 + 5 + 0 + 0 + 0 + + + 1204911 + SD_3 + 1 + 0 + 0 + 0 + + + + + 1205094 + 22 + 20 + TUSTIN RANCH + 28.35 + S + 5 + 0 + 0 + + + 1205096 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205097 + QUEUE + 2 + 0 + 0 + 0 + + + 1205098 + DEMAND + 3 + 0 + 0 + 0 + + + 1205099 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205100 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1205102 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1205104 + SD_1 + 1 + 0 + 0 + 0 + + + 1205106 + ML_1 + 1 + 0 + 0 + 0 + + + 1205107 + ML_2 + 2 + 0 + 0 + 0 + + + 1205108 + ML_3 + 3 + 0 + 0 + 0 + + + 1205109 + ML_4 + 4 + 0 + 0 + 0 + + + 1205110 + ML_5 + 5 + 0 + 0 + 0 + + + + + + + 23 + 18 + 23 + 21 + 1123005995 + 1357626 + 26479 + + + 1205156 + 23 + 1 + B ST. + 30.0 + N + 5 + 0 + 0 + + + 1205158 + ML_1 + 1 + 0 + 0 + 0 + + + 1205159 + ML_2 + 2 + 0 + 0 + 0 + + + 1205160 + ML_3 + 3 + 0 + 0 + 0 + + + 1205161 + ML_4 + 4 + 0 + 0 + 0 + + + 1205162 + ML_5 + 5 + 0 + 0 + 0 + + + 1205163 + ML_6 + 6 + 0 + 0 + 0 + + + 1208966 + SD_1 + 1 + 0 + 0 + 0 + + + 1208969 + OS_1 + 1 + 0 + 0 + 0 + + + 1208970 + OS_2 + 2 + 0 + 0 + 0 + + + 1208971 + OS_3 + 3 + 0 + 0 + 0 + + + 1208972 + OS_4 + 4 + 0 + 0 + 0 + + + 1208974 + SD_2 + 1 + 0 + 0 + 0 + + + + + 1205164 + 23 + 2 + S OF 55 + 30.2 + N + 5 + 0 + 0 + + + 1208978 + ML_1 + 1 + 0 + 0 + 0 + + + 1208979 + ML_2 + 2 + 0 + 0 + 0 + + + 1208980 + ML_3 + 3 + 0 + 0 + 0 + + + 1208981 + ML_4 + 4 + 0 + 0 + 0 + + + 1208982 + ML_5 + 5 + 0 + 0 + 0 + + + 1208983 + OS_1 + 1 + 0 + 0 + 0 + + + 1208984 + OS_2 + 2 + 0 + 0 + 0 + + + 1208985 + OS_3 + 3 + 0 + 0 + 0 + + + 1208986 + OS_4 + 4 + 0 + 0 + 0 + + + 1208987 + SD_1 + 1 + 0 + 0 + 0 + + + 1208988 + SD_2 + 1 + 0 + 0 + 0 + + + 1208991 + SD_3 + 1 + 0 + 0 + 0 + + + + + 1205167 + 23 + 3 + N OF 55 + 30.4 + N + 5 + 0 + 0 + + + 1208994 + ML_1 + 1 + 0 + 0 + 0 + + + 1208995 + ML_2 + 2 + 0 + 0 + 0 + + + 1208996 + ML_3 + 3 + 0 + 0 + 0 + + + 1208997 + ML_4 + 4 + 0 + 0 + 0 + + + 1208998 + OS_1 + 1 + 0 + 0 + 0 + + + 1208999 + OS_2 + 2 + 0 + 0 + 0 + + + 1209001 + OS_3 + 3 + 0 + 0 + 0 + + + 1209003 + OS_4 + 4 + 0 + 0 + 0 + + + 1209004 + OS_5 + 5 + 0 + 0 + 0 + + + 1209005 + SD_1 + 1 + 0 + 0 + 0 + + + 1209007 + SD_2 + 1 + 0 + 0 + 0 + + + 1209008 + SD_3 + 1 + 0 + 0 + 0 + + + 1209009 + SD_4 + 2 + 0 + 0 + 0 + + + 1209010 + SD_5 + 1 + 0 + 0 + 0 + + + + + 1205172 + 23 + 4 + WILLIAMS + 30.6 + S + 5 + 0 + 0 + + + 1211174 + SD_4 + 1 + 0 + 0 + 0 + + + 1211175 + SD_5 + 1 + 0 + 0 + 0 + + + + + 1205197 + 23 + 5 + CONCORD + 31.4 + N + 5 + 0 + 0 + + + 1205199 + SD_3 + 1 + 0 + 0 + 0 + + + 1205201 + OS_1 + 1 + 0 + 0 + 0 + + + 1205202 + OS_2 + 2 + 0 + 0 + 0 + + + 1205203 + OS_3 + 3 + 0 + 0 + 0 + + + 1205205 + ML_1 + 1 + 0 + 0 + 0 + + + 1205206 + ML_2 + 2 + 0 + 0 + 0 + + + 1205207 + ML_3 + 3 + 0 + 0 + 0 + + + 1209732 + ML_4 + 4 + 0 + 0 + 0 + + + 1209733 + ML_5 + 5 + 0 + 0 + 0 + + + 1209734 + ML_6 + 6 + 0 + 0 + 0 + + + 1209735 + OS_4 + 4 + 0 + 0 + 0 + + + 1209736 + OS_5 + 5 + 0 + 0 + 0 + + + 1209737 + OS_6 + 6 + 0 + 0 + 0 + + + 1209742 + SD_4 + 2 + 0 + 0 + 0 + + + 1209743 + SD_1 + 1 + 0 + 0 + 0 + + + 1209744 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1205254 + 23 + 6 + 17TH 2 + 32.5 + N + 5 + 0 + 0 + + + 1205256 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205257 + QUEUE + 2 + 0 + 0 + 0 + + + 1205258 + DEMAND + 3 + 0 + 0 + 0 + + + 1205259 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205261 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1205263 + ML_1 + 1 + 0 + 0 + 0 + + + 1205264 + ML_2 + 2 + 0 + 0 + 0 + + + 1205265 + ML_3 + 3 + 0 + 0 + 0 + + + 1209782 + ML_4 + 4 + 0 + 0 + 0 + + + 1209783 + ML_5 + 5 + 0 + 0 + 0 + + + 1209930 + SD_1 + 1 + 0 + 0 + 0 + + + 1205267 + SD_2 + 1 + 0 + 0 + 0 + + + + + 1205268 + 23 + 7 + 17TH 3 + 32.6 + N + 5 + 0 + 0 + + + 1208291 + ML_2 + 2 + 0 + 0 + 0 + + + 1208297 + ML_1 + 1 + 0 + 0 + 0 + + + 1209934 + ML_3 + 3 + 0 + 0 + 0 + + + 1209935 + ML_4 + 4 + 0 + 0 + 0 + + + 1209936 + ML_5 + 5 + 0 + 0 + 0 + + + 1209938 + DEMAND + 1 + 0 + 0 + 0 + + + 1209939 + PASSAGE + 2 + 0 + 0 + 0 + + + 1209940 + QUEUE + 3 + 0 + 0 + 0 + + + 1209941 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1209942 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1209845 + 23 + 11 + N OF 5 OFF + 10.2 + N + 55 + 0 + 0 + + + 1209846 + ML_1 + 1 + 0 + 0 + 0 + + + 1209847 + ML_2 + 2 + 0 + 0 + 0 + + + 1209848 + ML_3 + 3 + 0 + 0 + 0 + + + 1209849 + ML_4 + 4 + 0 + 0 + 0 + + + 1209854 + SD_1 + 1 + 0 + 0 + 0 + + + 1209856 + SD_3 + 1 + 0 + 0 + 0 + + + 1209857 + SD_4 + 2 + 0 + 0 + 0 + + + 1209858 + SD_6 + 1 + 0 + 0 + 0 + + + 1211968 + SD_5 + 1 + 0 + 0 + 0 + + + + + 1203261 + 23 + 14 + S OF 5 + 10.4 + S + 55 + 0 + 0 + + + 1203263 + SD_5 + 1 + 0 + 0 + 0 + + + 1203265 + SD_1 + 1 + 0 + 0 + 0 + + + 1203267 + ML_1 + 1 + 0 + 0 + 0 + + + 1203268 + ML_2 + 2 + 0 + 0 + 0 + + + 1203269 + ML_3 + 3 + 0 + 0 + 0 + + + 1209866 + ML_4 + 4 + 0 + 0 + 0 + + + 1209867 + OS_1 + 1 + 0 + 0 + 0 + + + 1209868 + OS_2 + 2 + 0 + 0 + 0 + + + 1209869 + OS_3 + 3 + 0 + 0 + 0 + + + 1209870 + SD_2 + 1 + 0 + 0 + 0 + + + 1209871 + SD_3 + 1 + 0 + 0 + 0 + + + 1209872 + SD_4 + 2 + 0 + 0 + 0 + + + + + 1203270 + 23 + 15 + N OF 5 + 10.5 + S + 55 + 0 + 0 + + + 1209876 + ML_1 + 1 + 0 + 0 + 0 + + + 1209877 + ML_2 + 2 + 0 + 0 + 0 + + + 1209878 + ML_3 + 3 + 0 + 0 + 0 + + + 1209880 + OS_1 + 1 + 0 + 0 + 0 + + + 1209881 + OS_2 + 2 + 0 + 0 + 0 + + + 1209882 + OS_3 + 3 + 0 + 0 + 0 + + + 1209883 + SD_1 + 1 + 0 + 0 + 0 + + + 1209884 + SD_2 + 1 + 0 + 0 + 0 + + + 1209885 + SD_3 + 1 + 0 + 0 + 0 + + + 1209886 + SD_5 + 1 + 0 + 0 + 0 + + + 1209887 + SD_6 + 2 + 0 + 0 + 0 + + + 1209894 + SD_4 + 1 + 0 + 0 + 0 + + + + + + + 26 + 3 + 25 + 25 + 1123006044 + 1357604 + 26482 + + + 1209052 + 26 + 13 + SPRUCE + 5.05 + S + 405 + 0 + 0 + + + 1209062 + ML_1 + 1 + 0 + 0 + 0 + + + 1209063 + ML_2 + 2 + 0 + 0 + 0 + + + 1209064 + ML_3 + 3 + 0 + 0 + 0 + + + 1209065 + ML_4 + 4 + 0 + 0 + 0 + + + 1209066 + SD_1 + 1 + 0 + 0 + 0 + + + 1209067 + OS_1 + 1 + 0 + 0 + 0 + + + 1209069 + OS_2 + 2 + 0 + 0 + 0 + + + 1209072 + SD_2 + 1 + 0 + 0 + 0 + + + 1209073 + OS_3 + 3 + 0 + 0 + 0 + + + 1209074 + OS_4 + 4 + 0 + 0 + 0 + + + + + + + 27 + 3 + 26 + 26 + 1123006050 + 1357603 + 26481 + + + 1201409 + 27 + 1 + N OF 55 + 8.9 + S + 405 + 0 + 0 + + + 1209125 + ML_1 + 1 + 0 + 0 + 0 + + + 1209126 + ML_2 + 2 + 0 + 0 + 0 + + + 1209127 + ML_3 + 3 + 0 + 0 + 0 + + + 1209128 + ML_4 + 4 + 0 + 0 + 0 + + + 1209131 + SD_1 + 1 + 0 + 0 + 0 + + + 1209132 + OS_1 + 1 + 0 + 0 + 0 + + + 1209133 + OS_2 + 2 + 0 + 0 + 0 + + + 1209134 + OS_3 + 3 + 0 + 0 + 0 + + + 1209135 + OS_4 + 4 + 0 + 0 + 0 + + + 1209136 + SD_2 + 1 + 0 + 0 + 0 + + + 1209478 + SD_4 + 1 + 0 + 0 + 0 + + + 1209479 + SD_5 + 2 + 0 + 0 + 0 + + + 1209480 + SD_6 + 1 + 0 + 0 + 0 + + + 1209481 + SD_3 + 2 + 0 + 0 + 0 + + + + + 1201405 + 27 + 2 + AIRPORT + 8.27 + N + 405 + 0 + 0 + + + 1209192 + ML_1 + 1 + 0 + 0 + 0 + + + 1209193 + ML_2 + 2 + 0 + 0 + 0 + + + 1209194 + ML_3 + 3 + 0 + 0 + 0 + + + 1209195 + ML_4 + 4 + 0 + 0 + 0 + + + 1209196 + SD_1 + 1 + 0 + 0 + 0 + + + 1209197 + OS_1 + 1 + 0 + 0 + 0 + + + 1209198 + OS_2 + 2 + 0 + 0 + 0 + + + 1209199 + OS_3 + 3 + 0 + 0 + 0 + + + 1209200 + OS_4 + 4 + 0 + 0 + 0 + + + 1209201 + OS_5 + 5 + 0 + 0 + 0 + + + 1209202 + OS_6 + 6 + 0 + 0 + 0 + + + 1209203 + SD_2 + 1 + 0 + 0 + 0 + + + 1209471 + ML_5 + 5 + 0 + 0 + 0 + + + 1209472 + ML_6 + 6 + 0 + 0 + 0 + + + + + + + 29 + 13 + 28 + 28 + 1123006080 + 1357609 + 26480 + + + 1208924 + 29 + 2 + N OF BONITA + 23.2 + N + 73 + 0 + 0 + + + 1210510 + ML_1 + 1 + 0 + 0 + 0 + + + 1210511 + ML_2 + 2 + 0 + 0 + 0 + + + 1210512 + ML_3 + 3 + 0 + 0 + 0 + + + 1210514 + ML_4 + 4 + 0 + 0 + 0 + + + 1210515 + OS_1 + 1 + 0 + 0 + 0 + + + 1210516 + OS_2 + 2 + 0 + 0 + 0 + + + 1210519 + OS_3 + 3 + 0 + 0 + 0 + + + 1210520 + OS_4 + 4 + 0 + 0 + 0 + + + + + 1208925 + 29 + 3 + BISON 1 + 23.5 + S + 73 + 0 + 0 + + + 1210495 + ML_1 + 1 + 0 + 0 + 0 + + + 1210496 + ML_2 + 2 + 0 + 0 + 0 + + + 1210497 + ML_3 + 3 + 0 + 0 + 0 + + + 1210498 + ML_4 + 4 + 0 + 0 + 0 + + + 1210499 + OS_1 + 1 + 0 + 0 + 0 + + + 1210501 + OS_2 + 2 + 0 + 0 + 0 + + + 1210502 + OS_3 + 3 + 0 + 0 + 0 + + + 1210503 + OS_4 + 4 + 0 + 0 + 0 + + + 1210767 + RAMP_ON + 1 + 0 + 0 + 0 + + + + + 1208926 + 29 + 4 + MACARTHUR 1 + 23.7 + S + 73 + 0 + 0 + + + 1210490 + ML_1 + 1 + 0 + 0 + 0 + + + 1210492 + ML_2 + 2 + 0 + 0 + 0 + + + 1210493 + ML_3 + 3 + 0 + 0 + 0 + + + 1210769 + RAMP_ON + 1 + 0 + 0 + 0 + + + + + 1210382 + 29 + 5 + BISON 2 + 23.9 + N + 73 + 0 + 0 + + + 1210480 + ML_1 + 1 + 0 + 0 + 0 + + + 1210481 + ML_2 + 2 + 0 + 0 + 0 + + + 1210482 + ML_3 + 3 + 0 + 0 + 0 + + + 1210483 + OS_1 + 1 + 0 + 0 + 0 + + + 1210484 + OS_2 + 2 + 0 + 0 + 0 + + + 1210485 + OS_3 + 3 + 0 + 0 + 0 + + + 1210771 + RAMP_ON + 1 + 0 + 0 + 0 + + + + + 1208927 + 29 + 6 + MACARTHUR 2 + 24.1 + N + 73 + 0 + 0 + + + 1210467 + ML_1 + 1 + 0 + 0 + 0 + + + 1210468 + ML_2 + 2 + 0 + 0 + 0 + + + 1210469 + ML_3 + 3 + 0 + 0 + 0 + + + 1210470 + OS_1 + 1 + 0 + 0 + 0 + + + 1210471 + OS_2 + 2 + 0 + 0 + 0 + + + 1210472 + OS_3 + 3 + 0 + 0 + 0 + + + 1210773 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1210797 + RAMP_OFF + 1 + 0 + 0 + 0 + + + + + + + 31 + 18 + 5 + 5 + 1123005744 + 1357649 + 26489 + + + 1201475 + 31 + 1 + BRISTOL 2 + 9.65 + N + 405 + 0 + 0 + + + 1201477 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201478 + QUEUE + 2 + 0 + 0 + 0 + + + 1201479 + DEMAND + 3 + 0 + 0 + 0 + + + 1201480 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201482 + ML_1 + 1 + 0 + 0 + 0 + + + 1201483 + ML_2 + 2 + 0 + 0 + 0 + + + 1201484 + ML_3 + 3 + 0 + 0 + 0 + + + 1201485 + ML_4 + 4 + 0 + 0 + 0 + + + 1201486 + ML_5 + 5 + 0 + 0 + 0 + + + 1201488 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1201444 + 31 + 2 + BRISTOL 1 + 9.46 + N + 405 + 0 + 0 + + + 1201446 + QUEUE + 1 + 0 + 0 + 0 + + + 1201447 + DEMAND + 2 + 0 + 0 + 0 + + + 1201448 + PASSAGE + 3 + 0 + 0 + 0 + + + 1201450 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201452 + SD_1 + 1 + 0 + 0 + 0 + + + 1201454 + ML_1 + 1 + 0 + 0 + 0 + + + 1201455 + ML_2 + 2 + 0 + 0 + 0 + + + 1201456 + ML_3 + 3 + 0 + 0 + 0 + + + 1201457 + ML_4 + 4 + 0 + 0 + 0 + + + 1201458 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1201459 + 31 + 3 + BRISTOL 2 + 9.54 + S + 405 + 0 + 0 + + + 1201461 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201462 + QUEUE + 2 + 0 + 0 + 0 + + + 1201463 + DEMAND + 3 + 0 + 0 + 0 + + + 1201464 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201466 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201468 + SD_1 + 1 + 0 + 0 + 0 + + + 1201470 + ML_1 + 1 + 0 + 0 + 0 + + + 1201471 + ML_2 + 2 + 0 + 0 + 0 + + + 1201472 + ML_3 + 3 + 0 + 0 + 0 + + + 1201473 + ML_4 + 4 + 0 + 0 + 0 + + + 1201474 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1204756 + 31 + 5 + BARRANCA + 22.75 + S + 5 + 0 + 0 + + + 1204758 + SD_2 + 1 + 0 + 0 + 0 + + + 1204760 + SD_1 + 1 + 0 + 0 + 0 + + + 1204762 + ML_1 + 1 + 0 + 0 + 0 + + + 1204763 + ML_2 + 2 + 0 + 0 + 0 + + + 1204764 + ML_3 + 3 + 0 + 0 + 0 + + + 1204765 + ML_4 + 4 + 0 + 0 + 0 + + + 1204767 + OS_1 + 1 + 0 + 0 + 0 + + + 1204768 + OS_2 + 2 + 0 + 0 + 0 + + + 1204769 + OS_3 + 3 + 0 + 0 + 0 + + + 1204770 + OS_4 + 4 + 0 + 0 + 0 + + + 1204771 + OS_5 + 5 + 0 + 0 + 0 + + + 1204773 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204775 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1212713 + SD_4 + 1 + 0 + 0 + 0 + + + 1212714 + SD_5 + 2 + 0 + 0 + 0 + + + + + 1201547 + 31 + 6 + HARBOR 2 + 11.5 + S + 405 + 0 + 0 + + + 1201549 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1201550 + QUEUE + 3 + 0 + 0 + 0 + + + 1201551 + DEMAND + 1 + 0 + 0 + 0 + + + 1201552 + PASSAGE + 2 + 0 + 0 + 0 + + + 1201555 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201557 + SD_1 + 1 + 0 + 0 + 0 + + + 1201559 + ML_1 + 1 + 0 + 0 + 0 + + + 1201560 + ML_2 + 2 + 0 + 0 + 0 + + + 1201561 + ML_3 + 3 + 0 + 0 + 0 + + + 1201562 + ML_4 + 4 + 0 + 0 + 0 + + + 1201563 + ML_5 + 5 + 0 + 0 + 0 + + + 1210125 + SD_4 + 2 + 0 + 0 + 0 + + + 1210126 + SD_5 + 3 + 0 + 0 + 0 + + + 1211181 + RAMP_HOV + 5 + 0 + 0 + 0 + + + + + 1201531 + 31 + 7 + HARBOR 1 + 11.4 + N + 405 + 0 + 0 + + + 1201533 + QUEUE + 3 + 0 + 0 + 0 + + + 1201534 + DEMAND + 1 + 0 + 0 + 0 + + + 1201535 + PASSAGE + 2 + 0 + 0 + 0 + + + 1201537 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201540 + SD_1 + 1 + 0 + 0 + 0 + + + 1201542 + ML_1 + 1 + 0 + 0 + 0 + + + 1201543 + ML_2 + 2 + 0 + 0 + 0 + + + 1201544 + ML_3 + 3 + 0 + 0 + 0 + + + 1201545 + ML_4 + 4 + 0 + 0 + 0 + + + 1210120 + SD_4 + 2 + 0 + 0 + 0 + + + + + 1201564 + 31 + 8 + HARBOR 2 + 11.6 + N + 405 + 0 + 0 + + + 1201566 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1201567 + QUEUE + 3 + 0 + 0 + 0 + + + 1201568 + DEMAND + 1 + 0 + 0 + 0 + + + 1201569 + PASSAGE + 2 + 0 + 0 + 0 + + + 1201572 + SD_1 + 1 + 0 + 0 + 0 + + + 1201574 + ML_1 + 1 + 0 + 0 + 0 + + + 1201575 + ML_2 + 2 + 0 + 0 + 0 + + + 1201576 + ML_3 + 3 + 0 + 0 + 0 + + + 1201577 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1201516 + 31 + 9 + HARBOR 1 + 11.2 + S + 405 + 0 + 0 + + + 1201518 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1201519 + QUEUE + 3 + 0 + 0 + 0 + + + 1201520 + DEMAND + 1 + 0 + 0 + 0 + + + 1201521 + PASSAGE + 2 + 0 + 0 + 0 + + + 1201524 + SD_1 + 1 + 0 + 0 + 0 + + + 1201526 + ML_1 + 1 + 0 + 0 + 0 + + + 1201527 + ML_2 + 2 + 0 + 0 + 0 + + + 1201528 + ML_3 + 3 + 0 + 0 + 0 + + + 1201529 + ML_4 + 4 + 0 + 0 + 0 + + + 1201530 + ML_5 + 5 + 0 + 0 + 0 + + + 1211193 + RAMP_HOV + 5 + 0 + 0 + 0 + + + + + 1201502 + 31 + 11 + FAIRVIEW + 10.9 + N + 405 + 0 + 0 + + + 1201504 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201505 + QUEUE + 2 + 0 + 0 + 0 + + + 1201506 + DEMAND + 3 + 0 + 0 + 0 + + + 1201507 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201509 + SD_1 + 1 + 0 + 0 + 0 + + + 1201511 + ML_1 + 1 + 0 + 0 + 0 + + + 1201512 + ML_2 + 2 + 0 + 0 + 0 + + + 1201513 + ML_3 + 3 + 0 + 0 + 0 + + + 1201514 + ML_4 + 4 + 0 + 0 + 0 + + + 1201515 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1204802 + 31 + 16 + N OF 133 + 23.2 + N + 5 + 0 + 0 + + + 1204804 + SD_2 + 1 + 0 + 0 + 0 + + + 1204805 + SD_3 + 2 + 0 + 0 + 0 + + + 1204807 + SD_1 + 1 + 0 + 0 + 0 + + + 1204809 + ML_1 + 1 + 0 + 0 + 0 + + + 1204810 + ML_2 + 2 + 0 + 0 + 0 + + + 1204811 + ML_3 + 3 + 0 + 0 + 0 + + + 1204812 + ML_4 + 4 + 0 + 0 + 0 + + + 1212704 + SD_4 + 1 + 0 + 0 + 0 + + + 1212705 + SD_5 + 2 + 0 + 0 + 0 + + + + + 1204793 + 31 + 17 + N OF 133 + 23.1 + S + 5 + 0 + 0 + + + 1204795 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204797 + SD_1 + 1 + 0 + 0 + 0 + + + 1204799 + ML_1 + 1 + 0 + 0 + 0 + + + 1204800 + ML_2 + 2 + 0 + 0 + 0 + + + 1204801 + ML_3 + 3 + 0 + 0 + 0 + + + + + 1204813 + 31 + 18 + S OF SAND CNYN + 23.5 + S + 5 + 0 + 0 + + + 1204815 + SD_1 + 1 + 0 + 0 + 0 + + + 1204817 + ML_1 + 1 + 0 + 0 + 0 + + + 1204818 + ML_2 + 2 + 0 + 0 + 0 + + + 1204819 + ML_3 + 3 + 0 + 0 + 0 + + + 1204820 + ML_4 + 4 + 0 + 0 + 0 + + + 1204821 + ML_5 + 5 + 0 + 0 + 0 + + + 1204822 + ML_6 + 6 + 0 + 0 + 0 + + + 1204824 + SD_2 + 1 + 0 + 0 + 0 + + + 1204826 + OS_1 + 1 + 0 + 0 + 0 + + + 1204827 + OS_2 + 2 + 0 + 0 + 0 + + + 1204828 + OS_3 + 3 + 0 + 0 + 0 + + + 1204829 + OS_4 + 4 + 0 + 0 + 0 + + + 1204830 + OS_5 + 5 + 0 + 0 + 0 + + + 1204831 + OS_6 + 6 + 0 + 0 + 0 + + + + + 1204776 + 31 + 20 + S OF 133 + 23.05 + S + 5 + 0 + 0 + + + 1204778 + SD_1 + 1 + 0 + 0 + 0 + + + 1204780 + SD_2 + 1 + 0 + 0 + 0 + + + 1204782 + ML_1 + 1 + 0 + 0 + 0 + + + 1204783 + ML_2 + 2 + 0 + 0 + 0 + + + 1204784 + ML_3 + 3 + 0 + 0 + 0 + + + 1204785 + ML_4 + 4 + 0 + 0 + 0 + + + 1204786 + ML_5 + 5 + 0 + 0 + 0 + + + 1204788 + OS_1 + 1 + 0 + 0 + 0 + + + 1204789 + OS_2 + 2 + 0 + 0 + 0 + + + 1204790 + OS_3 + 3 + 0 + 0 + 0 + + + 1204791 + OS_4 + 4 + 0 + 0 + 0 + + + 1204792 + OS_5 + 5 + 0 + 0 + 0 + + + 1212728 + SD_3 + 1 + 0 + 0 + 0 + + + 1212729 + SD_4 + 2 + 0 + 0 + 0 + + + + + + + 34 + 20 + 31 + 31 + 1123006127 + 1357632 + 26475 + + + 1209055 + 34 + 3 + N OF 73 + 10.48 + S + 405 + 0 + 0 + + + 1209206 + ML_1 + 1 + 0 + 0 + 0 + + + 1209207 + ML_2 + 2 + 0 + 0 + 0 + + + 1209208 + ML_3 + 3 + 0 + 0 + 0 + + + 1209209 + ML_4 + 4 + 0 + 0 + 0 + + + 1209210 + SD_1 + 1 + 0 + 0 + 0 + + + 1209211 + OS_1 + 1 + 0 + 0 + 0 + + + 1209212 + OS_2 + 2 + 0 + 0 + 0 + + + 1209213 + OS_3 + 3 + 0 + 0 + 0 + + + 1209214 + OS_4 + 4 + 0 + 0 + 0 + + + 1209215 + SD_2 + 1 + 0 + 0 + 0 + + + 1209457 + SD_3 + 1 + 0 + 0 + 0 + + + 1209458 + SD_4 + 2 + 0 + 0 + 0 + + + 1209459 + SD_5 + 1 + 0 + 0 + 0 + + + 1209460 + RAMP_HOV + 3 + 0 + 0 + 0 + + + 1209461 + SD_6 + 2 + 0 + 0 + 0 + + + 1209462 + COLL_DIST_1 + 2 + 0 + 0 + 0 + + + 1209466 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1209467 + RAMP_ON + 1 + 0 + 0 + 0 + + + + + 1209226 + 34 + 4 + HAMPSHIRE + 12.16 + S + 405 + 0 + 0 + + + 1209227 + ML_1 + 1 + 0 + 0 + 0 + + + 1209228 + ML_2 + 2 + 0 + 0 + 0 + + + 1209229 + ML_3 + 3 + 0 + 0 + 0 + + + 1209230 + ML_4 + 4 + 0 + 0 + 0 + + + 1209231 + ML_5 + 5 + 0 + 0 + 0 + + + 1209232 + ML_6 + 6 + 0 + 0 + 0 + + + 1209233 + SD_1 + 1 + 0 + 0 + 0 + + + 1209234 + OS_1 + 1 + 0 + 0 + 0 + + + 1209236 + OS_2 + 2 + 0 + 0 + 0 + + + 1209237 + OS_3 + 3 + 0 + 0 + 0 + + + 1209238 + OS_4 + 4 + 0 + 0 + 0 + + + 1209239 + OS_5 + 5 + 0 + 0 + 0 + + + 1209240 + SD_2 + 1 + 0 + 0 + 0 + + + + + 1201489 + 34 + 5 + FAIRVIEW + 10.28 + S + 405 + 0 + 0 + + + 1201492 + DEMAND + 1 + 0 + 0 + 0 + + + 1201493 + PASSAGE + 2 + 0 + 0 + 0 + + + 1201495 + SD_1 + 1 + 0 + 0 + 0 + + + 1201498 + ML_1 + 1 + 0 + 0 + 0 + + + 1201499 + ML_2 + 2 + 0 + 0 + 0 + + + 1201500 + ML_3 + 3 + 0 + 0 + 0 + + + 1201501 + ML_4 + 4 + 0 + 0 + 0 + + + 1209499 + SD_3 + 1 + 0 + 0 + 0 + + + + + 1208936 + 34 + 19 + FAIRVIEW + 27.72 + S + 73 + 0 + 0 + + + 1212490 + ML_1 + 1 + 0 + 0 + 0 + + + 1212491 + ML_2 + 2 + 0 + 0 + 0 + + + 1212492 + OS_1 + 1 + 0 + 0 + 0 + + + 1212493 + OS_2 + 2 + 0 + 0 + 0 + + + 1212494 + OS_3 + 3 + 0 + 0 + 0 + + + 1212534 + DEMAND + 1 + 0 + 0 + 0 + + + 1212535 + PASSAGE + 2 + 0 + 0 + 0 + + + 1212536 + QUEUE + 3 + 0 + 0 + 0 + + + + + + + 36 + 17 + 32 + 32 + 1123006146 + 1357615 + 26478 + + + 1211667 + 36 + 7 + N OF PORTOLA + 12.77 + N + 133 + 0 + 0 + + + 1211668 + ML_1 + 1 + 0 + 0 + 0 + + + 1211669 + ML_2 + 2 + 0 + 0 + 0 + + + 1211674 + SD_4 + 1 + 0 + 0 + 0 + + + 1211675 + SD_5 + 2 + 0 + 0 + 0 + + + + + 1211685 + 36 + 8 + S OF PORTOLA + 12.42 + N + 133 + 0 + 0 + + + 1211686 + ML_1 + 1 + 0 + 0 + 0 + + + 1211687 + ML_2 + 2 + 0 + 0 + 0 + + + 1211688 + ML_3 + 3 + 0 + 0 + 0 + + + 1211689 + OS_1 + 1 + 0 + 0 + 0 + + + 1211690 + OS_2 + 2 + 0 + 0 + 0 + + + 1211691 + OS_3 + 3 + 0 + 0 + 0 + + + + + 1211694 + 36 + 9 + IRVINE BLVD 3 + 12.05 + N + 133 + 0 + 0 + + + 1211695 + ML_1 + 1 + 0 + 0 + 0 + + + 1211696 + ML_2 + 2 + 0 + 0 + 0 + + + 1211697 + ML_3 + 3 + 0 + 0 + 0 + + + 1211698 + DEMAND + 1 + 0 + 0 + 0 + + + 1211699 + PASSAGE + 2 + 0 + 0 + 0 + + + 1211700 + QUEUE + 3 + 0 + 0 + 0 + + + 1211701 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1211702 + OS_1 + 1 + 0 + 0 + 0 + + + 1211703 + OS_2 + 2 + 0 + 0 + 0 + + + 1211704 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1211705 + SD_1 + 2 + 0 + 0 + 0 + + + + + 1211719 + 36 + 10 + N OF PM 11 + 11.35 + N + 133 + 0 + 0 + + + 1211720 + ML_1 + 1 + 0 + 0 + 0 + + + 1211721 + ML_2 + 2 + 0 + 0 + 0 + + + 1211722 + OS_1 + 1 + 0 + 0 + 0 + + + 1211723 + OS_2 + 2 + 0 + 0 + 0 + + + + + 1211710 + 36 + 11 + IRVINE BLVD 1 + 11.7 + S + 133 + 0 + 0 + + + 1211711 + ML_1 + 1 + 0 + 0 + 0 + + + 1211712 + ML_2 + 2 + 0 + 0 + 0 + + + 1211713 + OS_1 + 1 + 0 + 0 + 0 + + + 1211714 + OS_2 + 2 + 0 + 0 + 0 + + + 1211715 + RAMP_OFF + 1 + 0 + 0 + 0 + + + + + 1211726 + 36 + 12 + AT PM 11 + 11.08 + N + 133 + 0 + 0 + + + 1211727 + ML_1 + 1 + 0 + 0 + 0 + + + 1211728 + ML_2 + 2 + 0 + 0 + 0 + + + 1211729 + OS_1 + 1 + 0 + 0 + 0 + + + 1211730 + OS_2 + 2 + 0 + 0 + 0 + + + + + 1211733 + 36 + 13 + S OF PM 11 + 10.73 + N + 133 + 0 + 0 + + + 1211734 + ML_1 + 1 + 0 + 0 + 0 + + + 1211735 + ML_2 + 2 + 0 + 0 + 0 + + + 1211736 + ML_3 + 3 + 0 + 0 + 0 + + + 1211737 + OS_1 + 1 + 0 + 0 + 0 + + + 1211738 + OS_2 + 2 + 0 + 0 + 0 + + + 1211739 + OS_3 + 3 + 0 + 0 + 0 + + + + + 1211742 + 36 + 14 + N OF MARINE + 10.5 + N + 133 + 0 + 0 + + + 1211743 + ML_1 + 1 + 0 + 0 + 0 + + + 1211744 + ML_2 + 2 + 0 + 0 + 0 + + + 1211745 + SD_1 + 1 + 0 + 0 + 0 + + + 1211746 + OS_1 + 1 + 0 + 0 + 0 + + + 1211747 + OS_2 + 2 + 0 + 0 + 0 + + + 1211748 + SD_2 + 1 + 0 + 0 + 0 + + + 1211749 + SD_3 + 2 + 0 + 0 + 0 + + + + + 1211754 + 36 + 15 + MARINE WAY + 10.05 + N + 133 + 0 + 0 + + + 1211755 + ML_1 + 1 + 0 + 0 + 0 + + + 1211756 + ML_2 + 2 + 0 + 0 + 0 + + + 1211757 + OS_1 + 1 + 0 + 0 + 0 + + + 1211758 + OS_2 + 2 + 0 + 0 + 0 + + + 1211759 + OS_3 + 3 + 0 + 0 + 0 + + + + + 1211762 + 36 + 16 + N OF 5 + 9.77 + N + 133 + 0 + 0 + + + 1211763 + ML_1 + 1 + 0 + 0 + 0 + + + 1211764 + ML_2 + 2 + 0 + 0 + 0 + + + 1211765 + SD_1 + 1 + 0 + 0 + 0 + + + 1211766 + OS_1 + 1 + 0 + 0 + 0 + + + 1211767 + OS_2 + 2 + 0 + 0 + 0 + + + 1211768 + SD_2 + 1 + 0 + 0 + 0 + + + 1211769 + SD_3 + 2 + 0 + 0 + 0 + + + + + 1211774 + 36 + 17 + S OF 5 + 9.37 + N + 133 + 0 + 0 + + + 1211775 + ML_1 + 1 + 0 + 0 + 0 + + + 1211776 + ML_2 + 2 + 0 + 0 + 0 + + + 1211777 + SD_1 + 1 + 0 + 0 + 0 + + + 1211778 + SD_2 + 2 + 0 + 0 + 0 + + + 1211779 + COLL_DIST_ON + 1 + 0 + 0 + 0 + + + 1211780 + OS_1 + 1 + 0 + 0 + 0 + + + 1211781 + OS_2 + 2 + 0 + 0 + 0 + + + 1211782 + SD_3 + 1 + 0 + 0 + 0 + + + 1211783 + SD_4 + 2 + 0 + 0 + 0 + + + + + + + 45 + 19 + 11 + 11 + 1123005841 + 1357646 + 26484 + + + 1204539 + 45 + 1 + LA PAZ 1 + 16.51 + N + 5 + 0 + 0 + + + 1204541 + QUEUE + 2 + 0 + 0 + 0 + + + 1204542 + DEMAND + 3 + 0 + 0 + 0 + + + 1204543 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204545 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204547 + ML_1 + 1 + 0 + 0 + 0 + + + 1204548 + ML_2 + 2 + 0 + 0 + 0 + + + 1204549 + ML_3 + 3 + 0 + 0 + 0 + + + 1204550 + ML_4 + 4 + 0 + 0 + 0 + + + 1210084 + SD_1 + 1 + 0 + 0 + 0 + + + 1210372 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1211111 + RAMP_HOV + 5 + 0 + 0 + 0 + + + + + 1204553 + 45 + 2 + LA PAZ 2 + 16.69 + N + 5 + 0 + 0 + + + 1204555 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204556 + QUEUE + 2 + 0 + 0 + 0 + + + 1204557 + DEMAND + 3 + 0 + 0 + 0 + + + 1204558 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204560 + ML_1 + 1 + 0 + 0 + 0 + + + 1204561 + ML_2 + 2 + 0 + 0 + 0 + + + 1204562 + ML_3 + 3 + 0 + 0 + 0 + + + 1204563 + ML_4 + 4 + 0 + 0 + 0 + + + 1210086 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1204566 + 45 + 3 + ALICIA 1 + 17.43 + N + 5 + 0 + 0 + + + 1204568 + QUEUE + 2 + 0 + 0 + 0 + + + 1204569 + DEMAND + 3 + 0 + 0 + 0 + + + 1204570 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204572 + ML_1 + 1 + 0 + 0 + 0 + + + 1204573 + ML_2 + 2 + 0 + 0 + 0 + + + 1204574 + ML_3 + 3 + 0 + 0 + 0 + + + 1204575 + ML_4 + 4 + 0 + 0 + 0 + + + 1210088 + SD_1 + 1 + 0 + 0 + 0 + + + 1210123 + SD_3 + 2 + 0 + 0 + 0 + + + 1210371 + RAMP_ON + 1 + 0 + 0 + 0 + + + + + 1204578 + 45 + 4 + ALICIA 2 + 17.63 + N + 5 + 0 + 0 + + + 1204580 + QUEUE + 1 + 0 + 0 + 0 + + + 1204581 + DEMAND + 2 + 0 + 0 + 0 + + + 1204582 + PASSAGE + 3 + 0 + 0 + 0 + + + 1204584 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204585 + SD_3 + 2 + 0 + 0 + 0 + + + 1204587 + ML_1 + 1 + 0 + 0 + 0 + + + 1204588 + ML_2 + 2 + 0 + 0 + 0 + + + 1204589 + ML_3 + 3 + 0 + 0 + 0 + + + 1204590 + ML_4 + 4 + 0 + 0 + 0 + + + 1204592 + SD_1 + 1 + 0 + 0 + 0 + + + 1210092 + SD_5 + 3 + 0 + 0 + 0 + + + 1210093 + SD_4 + 2 + 0 + 0 + 0 + + + 1210094 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210370 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1204537 + 45 + 5 + LA PAZ 1 + 16.3 + S + 5 + 0 + 0 + + + 1211007 + ML_1 + 1 + 0 + 0 + 0 + + + 1211008 + ML_2 + 2 + 0 + 0 + 0 + + + 1211009 + ML_3 + 3 + 0 + 0 + 0 + + + 1211010 + ML_4 + 4 + 0 + 0 + 0 + + + 1211011 + DEMAND + 1 + 0 + 0 + 0 + + + 1211012 + PASSAGE + 2 + 0 + 0 + 0 + + + 1211013 + QUEUE + 3 + 0 + 0 + 0 + + + 1211014 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1211015 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1211016 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1204608 + 45 + 6 + EL TORO 1 + 18.61 + N + 5 + 0 + 0 + + + 1204610 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204611 + QUEUE + 2 + 0 + 0 + 0 + + + 1204612 + DEMAND + 3 + 0 + 0 + 0 + + + 1204613 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204614 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1204616 + ML_1 + 1 + 0 + 0 + 0 + + + 1204617 + ML_2 + 2 + 0 + 0 + 0 + + + 1204618 + ML_3 + 3 + 0 + 0 + 0 + + + 1204619 + ML_4 + 4 + 0 + 0 + 0 + + + 1210101 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1204622 + 45 + 7 + EL TORO 2 + 18.82 + N + 5 + 0 + 0 + + + 1204624 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204625 + QUEUE + 2 + 0 + 0 + 0 + + + 1204626 + DEMAND + 3 + 0 + 0 + 0 + + + 1204627 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204629 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204630 + SD_1 + 1 + 0 + 0 + 0 + + + 1210104 + SD_3 + 2 + 0 + 0 + 0 + + + 1210105 + SD_5 + 3 + 0 + 0 + 0 + + + + + 1204637 + 45 + 8 + RED ROBIN + 19.33 + N + 5 + 0 + 0 + + + 1204639 + ML_1 + 1 + 0 + 0 + 0 + + + 1204640 + ML_2 + 2 + 0 + 0 + 0 + + + 1204641 + ML_3 + 3 + 0 + 0 + 0 + + + 1204642 + ML_4 + 4 + 0 + 0 + 0 + + + 1204645 + OS_1 + 1 + 0 + 0 + 0 + + + 1204646 + OS_2 + 2 + 0 + 0 + 0 + + + 1204647 + OS_3 + 3 + 0 + 0 + 0 + + + 1204648 + OS_4 + 4 + 0 + 0 + 0 + + + 1210107 + ML_5 + 5 + 0 + 0 + 0 + + + 1210108 + ML_6 + 6 + 0 + 0 + 0 + + + 1210111 + SD_5 + 7 + 0 + 0 + 0 + + + 1210113 + OS_5 + 5 + 0 + 0 + 0 + + + 1210114 + OS_6 + 6 + 0 + 0 + 0 + + + 1210116 + SD_1 + 1 + 0 + 0 + 0 + + + 1210117 + SD_2 + 2 + 0 + 0 + 0 + + + 1210118 + SD_3 + 1 + 0 + 0 + 0 + + + 1210119 + SD_4 + 2 + 0 + 0 + 0 + + + + + 1204551 + 45 + 9 + LA PAZ 2 + 16.5 + S + 5 + 0 + 0 + + + 1210995 + ML_1 + 1 + 0 + 0 + 0 + + + 1210996 + ML_2 + 2 + 0 + 0 + 0 + + + 1210997 + ML_3 + 3 + 0 + 0 + 0 + + + 1210998 + ML_4 + 4 + 0 + 0 + 0 + + + 1210999 + SD_1 + 1 + 0 + 0 + 0 + + + 1211000 + DEMAND + 1 + 0 + 0 + 0 + + + 1211001 + PASSAGE + 2 + 0 + 0 + 0 + + + 1211002 + QUEUE + 3 + 0 + 0 + 0 + + + 1211003 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1211004 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1211005 + SD_2 + 2 + 0 + 0 + 0 + + + 1211006 + SD_3 + 3 + 0 + 0 + 0 + + + 1211179 + RAMP_HOV + 5 + 0 + 0 + 0 + + + + + 1204666 + 45 + 10 + LAKE FOR2 + 20.0 + N + 5 + 0 + 0 + + + 1204668 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204669 + QUEUE + 5 + 0 + 0 + 0 + + + 1204670 + DEMAND + 3 + 0 + 0 + 0 + + + 1204671 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204673 + ML_1 + 1 + 0 + 0 + 0 + + + 1204674 + ML_2 + 2 + 0 + 0 + 0 + + + 1204675 + ML_3 + 3 + 0 + 0 + 0 + + + 1204676 + ML_4 + 4 + 0 + 0 + 0 + + + 1204677 + ML_5 + 5 + 0 + 0 + 0 + + + 1204679 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204680 + SD_1 + 1 + 0 + 0 + 0 + + + 1211113 + SD_2 + 2 + 0 + 0 + 0 + + + 1211114 + RAMP_HOV + 2 + 0 + 0 + 0 + + + 1211115 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1211116 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + + + 1204721 + 45 + 11 + ALTON 2 + 22.1 + N + 5 + 0 + 0 + + + 1204723 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204724 + QUEUE + 2 + 0 + 0 + 0 + + + 1204725 + DEMAND + 3 + 0 + 0 + 0 + + + 1204726 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204728 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1204730 + SD_1 + 1 + 0 + 0 + 0 + + + 1204732 + ML_1 + 1 + 0 + 0 + 0 + + + 1204733 + ML_2 + 2 + 0 + 0 + 0 + + + 1204734 + ML_3 + 3 + 0 + 0 + 0 + + + 1204735 + ML_4 + 4 + 0 + 0 + 0 + + + 1204736 + ML_5 + 5 + 0 + 0 + 0 + + + 1208956 + SD_2 + 1 + 0 + 0 + 0 + + + 1211149 + SD_4 + 1 + 0 + 0 + 0 + + + 1211150 + SD_5 + 2 + 0 + 0 + 0 + + + 1204738 + OS_1 + 1 + 0 + 0 + 0 + + + 1204739 + OS_2 + 2 + 0 + 0 + 0 + + + 1204740 + OS_3 + 3 + 0 + 0 + 0 + + + 1204741 + OS_4 + 4 + 0 + 0 + 0 + + + + + 1204742 + 45 + 12 + ALTON 3 + 22.2 + N + 5 + 0 + 0 + + + 1204744 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204745 + QUEUE + 2 + 0 + 0 + 0 + + + 1204746 + DEMAND + 3 + 0 + 0 + 0 + + + 1204747 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204749 + SD_1 + 1 + 0 + 0 + 0 + + + 1204751 + ML_1 + 1 + 0 + 0 + 0 + + + 1204752 + ML_2 + 2 + 0 + 0 + 0 + + + 1204753 + ML_3 + 3 + 0 + 0 + 0 + + + 1204754 + ML_4 + 4 + 0 + 0 + 0 + + + 1204755 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1204564 + 45 + 13 + ALICIA 1 + 17.26 + S + 5 + 0 + 0 + + + 1210354 + ML_1 + 1 + 0 + 0 + 0 + + + 1210355 + ML_2 + 2 + 0 + 0 + 0 + + + 1210356 + ML_3 + 3 + 0 + 0 + 0 + + + 1210357 + ML_4 + 4 + 0 + 0 + 0 + + + 1210358 + ML_5 + 5 + 0 + 0 + 0 + + + 1210359 + DEMAND + 1 + 0 + 0 + 0 + + + 1210360 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210361 + QUEUE + 3 + 0 + 0 + 0 + + + 1210362 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210363 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1210366 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1204706 + 45 + 15 + ALTON 1 + 21.92 + S + 5 + 0 + 0 + + + 1204708 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1204709 + QUEUE + 2 + 0 + 0 + 0 + + + 1204710 + DEMAND + 3 + 0 + 0 + 0 + + + 1204711 + PASSAGE + 4 + 0 + 0 + 0 + + + 1204713 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1204715 + SD_1 + 1 + 0 + 0 + 0 + + + 1204717 + ML_1 + 1 + 0 + 0 + 0 + + + 1204718 + ML_2 + 2 + 0 + 0 + 0 + + + 1204719 + ML_3 + 3 + 0 + 0 + 0 + + + 1204720 + SD_3 + 2 + 0 + 0 + 0 + + + + + 1204576 + 45 + 17 + ALICIA 2 + 17.49 + S + 5 + 0 + 0 + + + 1210341 + ML_1 + 1 + 0 + 0 + 0 + + + 1210342 + ML_2 + 2 + 0 + 0 + 0 + + + 1210343 + ML_3 + 3 + 0 + 0 + 0 + + + 1210344 + ML_4 + 4 + 0 + 0 + 0 + + + 1210345 + DEMAND + 1 + 0 + 0 + 0 + + + 1210346 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210347 + QUEUE + 3 + 0 + 0 + 0 + + + 1210348 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210349 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1210350 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1210351 + SD_1 + 1 + 0 + 0 + 0 + + + 1210352 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1204606 + 45 + 19 + EL TORO 1 + 18.5 + S + 5 + 0 + 0 + + + 1210327 + ML_1 + 1 + 0 + 0 + 0 + + + 1210328 + ML_2 + 2 + 0 + 0 + 0 + + + 1210329 + ML_3 + 3 + 0 + 0 + 0 + + + 1210330 + ML_4 + 4 + 0 + 0 + 0 + + + 1210331 + ML_5 + 5 + 0 + 0 + 0 + + + 1210332 + DEMAND + 1 + 0 + 0 + 0 + + + 1210333 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210334 + QUEUE + 3 + 0 + 0 + 0 + + + 1210335 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210336 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1210337 + SD_1 + 1 + 0 + 0 + 0 + + + 1210338 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1204620 + 45 + 20 + EL TORO 2 + 18.7 + S + 5 + 0 + 0 + + + 1210307 + ML_1 + 1 + 0 + 0 + 0 + + + 1210308 + ML_2 + 2 + 0 + 0 + 0 + + + 1210309 + ML_3 + 3 + 0 + 0 + 0 + + + 1210310 + ML_4 + 4 + 0 + 0 + 0 + + + 1210311 + ML_5 + 5 + 0 + 0 + 0 + + + 1210312 + DEMAND + 1 + 0 + 0 + 0 + + + 1210313 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210314 + QUEUE + 3 + 0 + 0 + 0 + + + 1210315 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210316 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1210317 + SD_3 + 2 + 0 + 0 + 0 + + + 1210318 + SD_1 + 1 + 0 + 0 + 0 + + + 1210319 + SD_2 + 2 + 0 + 0 + 0 + + + + + + + 46 + 20 + 36 + 36 + 1123006209 + 1357644 + 26472 + + + 1201202 + 46 + 1 + JEFFREY 2 + 4.03 + N + 405 + 0 + 0 + + + 1201204 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201205 + QUEUE + 2 + 0 + 0 + 0 + + + 1201206 + DEMAND + 3 + 0 + 0 + 0 + + + 1201207 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201208 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201210 + SD_1 + 1 + 0 + 0 + 0 + + + 1201212 + ML_1 + 1 + 0 + 0 + 0 + + + 1201213 + ML_2 + 2 + 0 + 0 + 0 + + + 1201214 + ML_3 + 3 + 0 + 0 + 0 + + + 1201215 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1201176 + 46 + 2 + JEFFREY 1 + 3.86 + N + 405 + 0 + 0 + + + 1201178 + QUEUE + 1 + 0 + 0 + 0 + + + 1201179 + DEMAND + 2 + 0 + 0 + 0 + + + 1201180 + PASSAGE + 3 + 0 + 0 + 0 + + + 1201182 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201184 + SD_1 + 1 + 0 + 0 + 0 + + + 1201186 + ML_1 + 1 + 0 + 0 + 0 + + + 1201187 + ML_2 + 2 + 0 + 0 + 0 + + + 1201188 + ML_3 + 3 + 0 + 0 + 0 + + + 1201189 + ML_4 + 4 + 0 + 0 + 0 + + + 1209896 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1201245 + 46 + 3 + CULVER 1 + 5.55 + N + 405 + 0 + 0 + + + 1201247 + QUEUE + 1 + 0 + 0 + 0 + + + 1201248 + DEMAND + 2 + 0 + 0 + 0 + + + 1201249 + PASSAGE + 3 + 0 + 0 + 0 + + + 1201250 + RAMP_HOV + 4 + 0 + 0 + 0 + + + 1201252 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201253 + SD_2 + 2 + 0 + 0 + 0 + + + 1201255 + ML_1 + 1 + 0 + 0 + 0 + + + 1201256 + ML_2 + 2 + 0 + 0 + 0 + + + 1201257 + ML_3 + 3 + 0 + 0 + 0 + + + 1201258 + ML_4 + 4 + 0 + 0 + 0 + + + 1201260 + SD_1 + 1 + 0 + 0 + 0 + + + 1210826 + RAMP_ON + 5 + 0 + 0 + 0 + + + 1212696 + SD_3 + 3 + 0 + 0 + 0 + + + + + 1201321 + 46 + 4 + JAMBOREE1 + 6.85 + N + 405 + 0 + 0 + + + 1201323 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201324 + QUEUE + 2 + 0 + 0 + 0 + + + 1201325 + DEMAND + 3 + 0 + 0 + 0 + + + 1201326 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201328 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201329 + SD_2 + 2 + 0 + 0 + 0 + + + 1201330 + SD_3 + 3 + 0 + 0 + 0 + + + 1201332 + SD_1 + 1 + 0 + 0 + 0 + + + 1201334 + ML_1 + 1 + 0 + 0 + 0 + + + 1201335 + ML_2 + 2 + 0 + 0 + 0 + + + 1201336 + ML_3 + 3 + 0 + 0 + 0 + + + 1201337 + ML_4 + 4 + 0 + 0 + 0 + + + 1201338 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1201388 + 46 + 5 + MACARTHUR 1 + 7.73 + N + 405 + 0 + 0 + + + 1201390 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201391 + QUEUE + 2 + 0 + 0 + 0 + + + 1201392 + DEMAND + 3 + 0 + 0 + 0 + + + 1201393 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201395 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201396 + SD_2 + 2 + 0 + 0 + 0 + + + 1201398 + SD_1 + 1 + 0 + 0 + 0 + + + 1201400 + ML_1 + 1 + 0 + 0 + 0 + + + 1201401 + ML_2 + 2 + 0 + 0 + 0 + + + 1201402 + ML_3 + 3 + 0 + 0 + 0 + + + 1201403 + ML_4 + 4 + 0 + 0 + 0 + + + 1201404 + ML_5 + 5 + 0 + 0 + 0 + + + 1211043 + SD_4 + 3 + 0 + 0 + 0 + + + 1211044 + SD_5 + 4 + 0 + 0 + 0 + + + + + 1201190 + 46 + 6 + JEFFREY 2 + 4.03 + S + 405 + 0 + 0 + + + 1201192 + QUEUE + 1 + 0 + 0 + 0 + + + 1201193 + DEMAND + 2 + 0 + 0 + 0 + + + 1201194 + PASSAGE + 3 + 0 + 0 + 0 + + + 1201196 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201198 + ML_1 + 1 + 0 + 0 + 0 + + + 1201199 + ML_2 + 2 + 0 + 0 + 0 + + + 1201200 + ML_3 + 3 + 0 + 0 + 0 + + + 1201201 + ML_4 + 4 + 0 + 0 + 0 + + + 1209045 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1201164 + 46 + 7 + JEFFREY 1 + 3.84 + S + 405 + 0 + 0 + + + 1201166 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201167 + QUEUE + 2 + 0 + 0 + 0 + + + 1201168 + DEMAND + 3 + 0 + 0 + 0 + + + 1201169 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201170 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201172 + ML_1 + 1 + 0 + 0 + 0 + + + 1201173 + ML_2 + 2 + 0 + 0 + 0 + + + 1201174 + ML_3 + 3 + 0 + 0 + 0 + + + 1201175 + ML_4 + 4 + 0 + 0 + 0 + + + 1209044 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1201275 + 46 + 8 + CULVER 2 + 5.74 + N + 405 + 0 + 0 + + + 1201277 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201278 + QUEUE + 2 + 0 + 0 + 0 + + + 1201279 + DEMAND + 3 + 0 + 0 + 0 + + + 1201280 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201282 + SD_1 + 1 + 0 + 0 + 0 + + + 1201284 + ML_1 + 1 + 0 + 0 + 0 + + + 1201285 + ML_2 + 2 + 0 + 0 + 0 + + + 1201286 + ML_3 + 3 + 0 + 0 + 0 + + + 1201287 + ML_4 + 4 + 0 + 0 + 0 + + + 1201288 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1201261 + 46 + 9 + CULVER 2 + 5.69 + S + 405 + 0 + 0 + + + 1201263 + QUEUE + 1 + 0 + 0 + 0 + + + 1201264 + DEMAND + 2 + 0 + 0 + 0 + + + 1201265 + PASSAGE + 3 + 0 + 0 + 0 + + + 1201267 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201269 + SD_1 + 1 + 0 + 0 + 0 + + + 1201271 + ML_1 + 1 + 0 + 0 + 0 + + + 1201272 + ML_2 + 2 + 0 + 0 + 0 + + + 1201273 + ML_3 + 3 + 0 + 0 + 0 + + + 1201274 + ML_4 + 4 + 0 + 0 + 0 + + + 1210827 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1201231 + 46 + 10 + CULVER 1 + 5.5 + S + 405 + 0 + 0 + + + 1201233 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201234 + QUEUE + 2 + 0 + 0 + 0 + + + 1201235 + DEMAND + 3 + 0 + 0 + 0 + + + 1201236 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201237 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201239 + SD_1 + 1 + 0 + 0 + 0 + + + 1201241 + ML_1 + 1 + 0 + 0 + 0 + + + 1201242 + ML_2 + 2 + 0 + 0 + 0 + + + 1201243 + ML_3 + 3 + 0 + 0 + 0 + + + 1201244 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1201356 + 46 + 11 + JAMBOREE2 + 7.07 + N + 405 + 0 + 0 + + + 1201358 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201359 + QUEUE + 2 + 0 + 0 + 0 + + + 1201360 + DEMAND + 3 + 0 + 0 + 0 + + + 1201361 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201362 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201364 + SD_1 + 1 + 0 + 0 + 0 + + + 1201366 + ML_1 + 1 + 0 + 0 + 0 + + + 1201367 + ML_2 + 2 + 0 + 0 + 0 + + + 1201368 + ML_3 + 3 + 0 + 0 + 0 + + + 1201369 + ML_4 + 4 + 0 + 0 + 0 + + + 1201370 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1201339 + 46 + 12 + JAMBOREE2 + 7.01 + S + 405 + 0 + 0 + + + 1201341 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201342 + QUEUE + 2 + 0 + 0 + 0 + + + 1201343 + DEMAND + 3 + 0 + 0 + 0 + + + 1201344 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201346 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201347 + SD_2 + 2 + 0 + 0 + 0 + + + 1201349 + SD_1 + 1 + 0 + 0 + 0 + + + 1201351 + ML_1 + 1 + 0 + 0 + 0 + + + 1201352 + ML_2 + 2 + 0 + 0 + 0 + + + 1201353 + ML_3 + 3 + 0 + 0 + 0 + + + 1201354 + ML_4 + 4 + 0 + 0 + 0 + + + 1201355 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1201306 + 46 + 13 + JAMBOREE1 + 6.8 + S + 405 + 0 + 0 + + + 1201308 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201309 + QUEUE + 2 + 0 + 0 + 0 + + + 1201310 + DEMAND + 3 + 0 + 0 + 0 + + + 1201311 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201312 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201314 + SD_1 + 1 + 0 + 0 + 0 + + + 1201316 + ML_1 + 1 + 0 + 0 + 0 + + + 1201317 + ML_2 + 2 + 0 + 0 + 0 + + + 1201318 + ML_3 + 3 + 0 + 0 + 0 + + + 1201319 + ML_4 + 4 + 0 + 0 + 0 + + + 1201320 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1201371 + 46 + 14 + MACARTHUR1 + 7.69 + S + 405 + 0 + 0 + + + 1201373 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201374 + QUEUE + 2 + 0 + 0 + 0 + + + 1201375 + DEMAND + 3 + 0 + 0 + 0 + + + 1201376 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201378 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201379 + SD_2 + 2 + 0 + 0 + 0 + + + 1201381 + SD_1 + 1 + 0 + 0 + 0 + + + 1201383 + ML_1 + 1 + 0 + 0 + 0 + + + 1201384 + ML_2 + 2 + 0 + 0 + 0 + + + 1201385 + ML_3 + 3 + 0 + 0 + 0 + + + 1201386 + ML_4 + 4 + 0 + 0 + 0 + + + 1201387 + ML_5 + 5 + 0 + 0 + 0 + + + 1211110 + RAMP_HOV + 5 + 0 + 0 + 0 + + + + + 1201289 + 46 + 15 + HARVARD + 6.1 + S + 405 + 0 + 0 + + + 1201291 + SD_1 + 1 + 0 + 0 + 0 + + + 1201293 + ML_1 + 1 + 0 + 0 + 0 + + + 1201294 + ML_2 + 2 + 0 + 0 + 0 + + + 1201295 + ML_3 + 3 + 0 + 0 + 0 + + + 1201296 + ML_4 + 4 + 0 + 0 + 0 + + + 1201297 + ML_5 + 5 + 0 + 0 + 0 + + + 1201299 + OS_1 + 1 + 0 + 0 + 0 + + + 1201300 + OS_2 + 2 + 0 + 0 + 0 + + + 1201301 + OS_3 + 3 + 0 + 0 + 0 + + + 1201302 + OS_4 + 4 + 0 + 0 + 0 + + + 1201303 + OS_5 + 5 + 0 + 0 + 0 + + + 1201305 + SD_2 + 1 + 0 + 0 + 0 + + + + + 1201216 + 46 + 16 + YALE + 5.01 + S + 405 + 0 + 0 + + + 1201218 + ML_1 + 1 + 0 + 0 + 0 + + + 1201219 + ML_2 + 2 + 0 + 0 + 0 + + + 1201220 + ML_3 + 3 + 0 + 0 + 0 + + + 1201221 + ML_4 + 4 + 0 + 0 + 0 + + + 1201223 + OS_1 + 1 + 0 + 0 + 0 + + + 1201224 + OS_2 + 2 + 0 + 0 + 0 + + + 1201225 + OS_3 + 3 + 0 + 0 + 0 + + + 1201226 + OS_4 + 4 + 0 + 0 + 0 + + + 1201228 + SD_1 + 1 + 0 + 0 + 0 + + + 1201230 + SD_2 + 1 + 0 + 0 + 0 + + + + + 1201043 + 46 + 17 + BARRANCA2 + 9.0 + S + 133 + 0 + 0 + + + 1201045 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201046 + QUEUE + 2 + 0 + 0 + 0 + + + 1201047 + DEMAND + 3 + 0 + 0 + 0 + + + 1201048 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201049 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201051 + ML_3 + 3 + 0 + 0 + 0 + + + 1201053 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201055 + ML_1 + 1 + 0 + 0 + 0 + + + 1201056 + ML_2 + 2 + 0 + 0 + 0 + + + + + 1201411 + 46 + 18 + RED HILL + 8.4 + S + 405 + 0 + 0 + + + 1201413 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1201414 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + 1201416 + COLL_DIST_ON + 1 + 0 + 0 + 0 + + + 1201418 + SD_1 + 1 + 0 + 0 + 0 + + + 1201420 + ML_1 + 1 + 0 + 0 + 0 + + + 1201421 + ML_2 + 2 + 0 + 0 + 0 + + + 1201422 + ML_3 + 3 + 0 + 0 + 0 + + + 1201423 + ML_4 + 4 + 0 + 0 + 0 + + + 1201424 + ML_5 + 5 + 0 + 0 + 0 + + + 1201426 + SD_2 + 1 + 0 + 0 + 0 + + + 1201427 + SD_3 + 2 + 0 + 0 + 0 + + + 1201428 + SD_4 + 3 + 0 + 0 + 0 + + + 1201429 + SD_5 + 4 + 0 + 0 + 0 + + + 1201431 + OS_1 + 1 + 0 + 0 + 0 + + + 1201432 + OS_2 + 2 + 0 + 0 + 0 + + + 1201433 + OS_3 + 3 + 0 + 0 + 0 + + + 1201434 + OS_4 + 4 + 0 + 0 + 0 + + + 1201436 + SD_6 + 1 + 0 + 0 + 0 + + + + + 1201057 + 46 + 19 + BARRANCA1 + 9.0 + N + 133 + 0 + 0 + + + 1201059 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201060 + QUEUE + 2 + 0 + 0 + 0 + + + 1201061 + DEMAND + 3 + 0 + 0 + 0 + + + 1201062 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201063 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201065 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201067 + ML_1 + 1 + 0 + 0 + 0 + + + 1201068 + ML_2 + 2 + 0 + 0 + 0 + + + + + 1201069 + 46 + 20 + BARRANCA2 + 9.1 + N + 133 + 0 + 0 + + + 1201071 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201072 + QUEUE + 2 + 0 + 0 + 0 + + + 1201073 + DEMAND + 3 + 0 + 0 + 0 + + + 1201074 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201075 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201077 + ML_1 + 1 + 0 + 0 + 0 + + + 1201078 + ML_2 + 2 + 0 + 0 + 0 + + + 1201079 + ML_3 + 3 + 0 + 0 + 0 + + + + + + + 50 + 19 + 13 + 13 + 1123005873 + 1357650 + 24148 + + + 1205111 + 50 + 1 + RED HILL + 29.02 + S + 5 + 0 + 0 + + + 1205113 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205114 + QUEUE + 2 + 0 + 0 + 0 + + + 1205115 + DEMAND + 3 + 0 + 0 + 0 + + + 1205116 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205117 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1205119 + SD_2 + 1 + 0 + 0 + 0 + + + 1205121 + SD_1 + 1 + 0 + 0 + 0 + + + 1205123 + ML_1 + 1 + 0 + 0 + 0 + + + 1205124 + ML_2 + 2 + 0 + 0 + 0 + + + 1205125 + ML_3 + 3 + 0 + 0 + 0 + + + 1205126 + ML_4 + 4 + 0 + 0 + 0 + + + 1205127 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1205128 + 50 + 2 + RED HILL + 29.24 + N + 5 + 0 + 0 + + + 1205130 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205131 + QUEUE + 2 + 0 + 0 + 0 + + + 1205132 + DEMAND + 3 + 0 + 0 + 0 + + + 1205133 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205134 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1205136 + ML_1 + 1 + 0 + 0 + 0 + + + 1205137 + ML_2 + 2 + 0 + 0 + 0 + + + 1205138 + ML_3 + 3 + 0 + 0 + 0 + + + 1208493 + ML_5 + 5 + 0 + 0 + 0 + + + 1208495 + ML_4 + 4 + 0 + 0 + 0 + + + 1208534 + SD_1 + 1 + 0 + 0 + 0 + + + 1208539 + SD_3 + 1 + 0 + 0 + 0 + + + + + 1205146 + 50 + 3 + NEWPORT + 29.79 + N + 5 + 0 + 0 + + + 1205148 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205149 + QUEUE + 2 + 0 + 0 + 0 + + + 1205150 + DEMAND + 3 + 0 + 0 + 0 + + + 1205151 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205153 + ML_1 + 1 + 0 + 0 + 0 + + + 1205154 + ML_2 + 2 + 0 + 0 + 0 + + + 1205155 + ML_3 + 3 + 0 + 0 + 0 + + + 1208356 + ML_4 + 4 + 0 + 0 + 0 + + + 1208357 + ML_5 + 5 + 0 + 0 + 0 + + + 1208361 + SD_1 + 1 + 0 + 0 + 0 + + + 1208501 + OS_1 + 1 + 0 + 0 + 0 + + + 1208502 + OS_2 + 2 + 0 + 0 + 0 + + + 1208503 + OS_3 + 3 + 0 + 0 + 0 + + + 1208504 + OS_4 + 4 + 0 + 0 + 0 + + + 1208505 + OS_5 + 5 + 0 + 0 + 0 + + + 1208506 + OS_6 + 6 + 0 + 0 + 0 + + + 1208507 + SD_2 + 1 + 0 + 0 + 0 + + + 1208957 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1208958 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + 1208959 + SD_3 + 1 + 0 + 0 + 0 + + + 1208960 + SD_4 + 2 + 0 + 0 + 0 + + + 1208961 + SD_5 + 1 + 0 + 0 + 0 + + + + + 1203244 + 50 + 4 + MCFADDEN + 10.0 + N + 55 + 0 + 0 + + + 1203246 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203247 + QUEUE + 2 + 0 + 0 + 0 + + + 1203248 + DEMAND + 3 + 0 + 0 + 0 + + + 1203249 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203251 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1203253 + SD_1 + 1 + 0 + 0 + 0 + + + 1203255 + ML_1 + 1 + 0 + 0 + 0 + + + 1203256 + ML_2 + 2 + 0 + 0 + 0 + + + 1203257 + ML_3 + 3 + 0 + 0 + 0 + + + 1203258 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1203211 + 50 + 5 + EDINGER 2 + 9.41 + N + 55 + 0 + 0 + + + 1203213 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203214 + QUEUE + 2 + 0 + 0 + 0 + + + 1203215 + DEMAND + 3 + 0 + 0 + 0 + + + 1203216 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203218 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1203220 + SD_1 + 1 + 0 + 0 + 0 + + + 1203222 + ML_1 + 1 + 0 + 0 + 0 + + + 1203223 + ML_2 + 2 + 0 + 0 + 0 + + + 1203224 + ML_3 + 3 + 0 + 0 + 0 + + + 1203225 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1203196 + 50 + 6 + EDINGER 1 + 9.19 + S + 55 + 0 + 0 + + + 1203198 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203199 + QUEUE + 2 + 0 + 0 + 0 + + + 1203200 + DEMAND + 3 + 0 + 0 + 0 + + + 1203201 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203203 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1203205 + SD_1 + 1 + 0 + 0 + 0 + + + 1203207 + ML_1 + 1 + 0 + 0 + 0 + + + 1203208 + ML_2 + 2 + 0 + 0 + 0 + + + 1203209 + ML_3 + 3 + 0 + 0 + 0 + + + 1203210 + ML_4 + 4 + 0 + 0 + 0 + + + 1211167 + OS_1 + 1 + 0 + 0 + 0 + + + 1211168 + OS_2 + 2 + 0 + 0 + 0 + + + 1211169 + OS_3 + 3 + 0 + 0 + 0 + + + 1211170 + OS_4 + 4 + 0 + 0 + 0 + + + 1211171 + SD_2 + 1 + 0 + 0 + 0 + + + + + 1203165 + 50 + 7 + DYER 1 + 7.85 + N + 55 + 0 + 0 + + + 1203167 + QUEUE + 1 + 0 + 0 + 0 + + + 1203168 + DEMAND + 2 + 0 + 0 + 0 + + + 1203169 + PASSAGE + 3 + 0 + 0 + 0 + + + 1203171 + SD_1 + 1 + 0 + 0 + 0 + + + 1203173 + ML_1 + 1 + 0 + 0 + 0 + + + 1203174 + ML_2 + 2 + 0 + 0 + 0 + + + 1203175 + ML_3 + 3 + 0 + 0 + 0 + + + 1213048 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1203176 + 50 + 8 + DYER 2 + 8.12 + N + 55 + 0 + 0 + + + 1203178 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203179 + QUEUE + 2 + 0 + 0 + 0 + + + 1203180 + DEMAND + 3 + 0 + 0 + 0 + + + 1203181 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203183 + SD_1 + 1 + 0 + 0 + 0 + + + 1203185 + ML_1 + 1 + 0 + 0 + 0 + + + 1203186 + ML_2 + 2 + 0 + 0 + 0 + + + 1203187 + ML_3 + 3 + 0 + 0 + 0 + + + 1203189 + OS_1 + 1 + 0 + 0 + 0 + + + 1203190 + OS_2 + 2 + 0 + 0 + 0 + + + 1203191 + OS_3 + 3 + 0 + 0 + 0 + + + 1203192 + OS_4 + 4 + 0 + 0 + 0 + + + 1203194 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1203195 + SD_3 + 1 + 0 + 0 + 0 + + + + + 1203153 + 50 + 9 + DYER 1 + 7.62 + S + 55 + 0 + 0 + + + 1203155 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203156 + QUEUE + 2 + 0 + 0 + 0 + + + 1203157 + DEMAND + 3 + 0 + 0 + 0 + + + 1203158 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203160 + SD_1 + 1 + 0 + 0 + 0 + + + 1203162 + ML_1 + 1 + 0 + 0 + 0 + + + 1203163 + ML_2 + 2 + 0 + 0 + 0 + + + 1203164 + ML_3 + 3 + 0 + 0 + 0 + + + 1213047 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1203115 + 50 + 10 + MACARTHU1 + 6.94 + N + 55 + 0 + 0 + + + 1203117 + QUEUE + 2 + 0 + 0 + 0 + + + 1203118 + DEMAND + 3 + 0 + 0 + 0 + + + 1203119 + PASSAGE + 1 + 0 + 0 + 0 + + + 1203121 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1203123 + SD_1 + 1 + 0 + 0 + 0 + + + 1203125 + ML_1 + 1 + 0 + 0 + 0 + + + 1203126 + ML_2 + 2 + 0 + 0 + 0 + + + 1203127 + ML_3 + 3 + 0 + 0 + 0 + + + 1203128 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1203140 + 50 + 11 + MACARTHU2 + 7.16 + N + 55 + 0 + 0 + + + 1203142 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203143 + QUEUE + 2 + 0 + 0 + 0 + + + 1203144 + DEMAND + 3 + 0 + 0 + 0 + + + 1203145 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203147 + SD_1 + 1 + 0 + 0 + 0 + + + 1203149 + ML_1 + 1 + 0 + 0 + 0 + + + 1203150 + ML_2 + 2 + 0 + 0 + 0 + + + 1203151 + ML_3 + 3 + 0 + 0 + 0 + + + 1203152 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1203129 + 50 + 12 + MACARTHU2 + 7.03 + S + 55 + 0 + 0 + + + 1203131 + QUEUE + 1 + 0 + 0 + 0 + + + 1203132 + DEMAND + 2 + 0 + 0 + 0 + + + 1203133 + PASSAGE + 3 + 0 + 0 + 0 + + + 1203135 + SD_1 + 1 + 0 + 0 + 0 + + + 1203137 + ML_1 + 1 + 0 + 0 + 0 + + + 1203138 + ML_2 + 2 + 0 + 0 + 0 + + + 1203139 + ML_3 + 3 + 0 + 0 + 0 + + + + + 1203103 + 50 + 13 + MACARTHU1 + 6.88 + S + 55 + 0 + 0 + + + 1203105 + QUEUE + 1 + 0 + 0 + 0 + + + 1203106 + DEMAND + 2 + 0 + 0 + 0 + + + 1203107 + PASSAGE + 3 + 0 + 0 + 0 + + + 1203109 + SD_1 + 1 + 0 + 0 + 0 + + + 1203111 + ML_1 + 1 + 0 + 0 + 0 + + + 1203112 + ML_2 + 2 + 0 + 0 + 0 + + + 1203113 + ML_3 + 3 + 0 + 0 + 0 + + + 1203114 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1203226 + 50 + 14 + MCFADDEN + 10.0 + S + 55 + 0 + 0 + + + 1203228 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203229 + QUEUE + 2 + 0 + 0 + 0 + + + 1203230 + DEMAND + 3 + 0 + 0 + 0 + + + 1203231 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203233 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1203234 + SD_2 + 2 + 0 + 0 + 0 + + + 1203236 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1203238 + SD_1 + 1 + 0 + 0 + 0 + + + 1203240 + ML_1 + 1 + 0 + 0 + 0 + + + 1203241 + ML_2 + 2 + 0 + 0 + 0 + + + 1203242 + ML_3 + 3 + 0 + 0 + 0 + + + 1203243 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1203062 + 50 + 16 + FAIR 2 + 3.96 + N + 55 + 0 + 0 + + + 1203064 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203065 + QUEUE + 2 + 0 + 0 + 0 + + + 1203066 + DEMAND + 3 + 0 + 0 + 0 + + + 1203067 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203069 + SD_1 + 1 + 0 + 0 + 0 + + + 1203070 + SD_2 + 2 + 0 + 0 + 0 + + + 1203072 + ML_1 + 1 + 0 + 0 + 0 + + + 1203073 + ML_2 + 2 + 0 + 0 + 0 + + + 1203074 + ML_3 + 3 + 0 + 0 + 0 + + + 1203075 + ML_4 + 4 + 0 + 0 + 0 + + + 1203077 + OS_1 + 1 + 0 + 0 + 0 + + + 1203078 + OS_2 + 2 + 0 + 0 + 0 + + + 1203079 + OS_3 + 3 + 0 + 0 + 0 + + + 1203080 + OS_4 + 4 + 0 + 0 + 0 + + + + + 1203044 + 50 + 17 + FAIR 1 + 3.6 + S + 55 + 0 + 0 + + + 1203046 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203047 + QUEUE + 2 + 0 + 0 + 0 + + + 1203048 + DEMAND + 3 + 0 + 0 + 0 + + + 1203049 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203051 + ML_1 + 1 + 0 + 0 + 0 + + + 1203052 + ML_2 + 2 + 0 + 0 + 0 + + + 1203053 + ML_3 + 3 + 0 + 0 + 0 + + + 1203054 + ML_4 + 4 + 0 + 0 + 0 + + + 1203056 + SD_1 + 1 + 0 + 0 + 0 + + + 1203058 + OS_1 + 1 + 0 + 0 + 0 + + + 1203059 + OS_2 + 2 + 0 + 0 + 0 + + + 1203060 + OS_3 + 3 + 0 + 0 + 0 + + + 1203061 + OS_4 + 4 + 0 + 0 + 0 + + + + + 1203026 + 50 + 18 + VICTORIA2 + 3.11 + N + 55 + 0 + 0 + + + 1203028 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203029 + QUEUE + 2 + 0 + 0 + 0 + + + 1203030 + DEMAND + 3 + 0 + 0 + 0 + + + 1203031 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203033 + SD_1 + 1 + 0 + 0 + 0 + + + 1203034 + SD_2 + 2 + 0 + 0 + 0 + + + 1203036 + ML_1 + 1 + 0 + 0 + 0 + + + 1203037 + ML_2 + 2 + 0 + 0 + 0 + + + 1203038 + ML_3 + 3 + 0 + 0 + 0 + + + 1203039 + ML_4 + 4 + 0 + 0 + 0 + + + 1203041 + OS_1 + 1 + 0 + 0 + 0 + + + 1203042 + OS_2 + 2 + 0 + 0 + 0 + + + 1203043 + OS_3 + 3 + 0 + 0 + 0 + + + + + 1203085 + 50 + 20 + PAULARINO 2 + 5.8 + N + 55 + 0 + 0 + + + 1203087 + DEMAND + 1 + 0 + 0 + 0 + + + 1203091 + ML_1 + 1 + 0 + 0 + 0 + + + 1203092 + ML_2 + 2 + 0 + 0 + 0 + + + 1203093 + ML_3 + 3 + 0 + 0 + 0 + + + 1203096 + OS_1 + 1 + 0 + 0 + 0 + + + 1203097 + OS_2 + 2 + 0 + 0 + 0 + + + 1203098 + OS_3 + 3 + 0 + 0 + 0 + + + 1210152 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210153 + QUEUE + 3 + 0 + 0 + 0 + + + 1210154 + SD_1 + 1 + 0 + 0 + 0 + + + 1210155 + SD_2 + 1 + 0 + 0 + 0 + + + 1210156 + SD_4 + 1 + 0 + 0 + 0 + + + 1210157 + SD_5 + 1 + 0 + 0 + 0 + + + 1210158 + SD_3 + 1 + 0 + 0 + 0 + + + + + + + 56 + 20 + 14 + 14 + 1123005892 + 1357643 + 26482 + + + 1203293 + 56 + 1 + FOURTH 2 + 11.1 + N + 55 + 0 + 0 + + + 1203295 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203296 + QUEUE + 2 + 0 + 0 + 0 + + + 1203297 + DEMAND + 3 + 0 + 0 + 0 + + + 1203298 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203300 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1203302 + SD_1 + 1 + 0 + 0 + 0 + + + 1203304 + ML_1 + 1 + 0 + 0 + 0 + + + 1203305 + ML_2 + 2 + 0 + 0 + 0 + + + 1203306 + ML_3 + 3 + 0 + 0 + 0 + + + 1211965 + SD_2 + 1 + 0 + 0 + 0 + + + 1211966 + SD_3 + 2 + 0 + 0 + 0 + + + 1212750 + ML_4 + 4 + 0 + 0 + 0 + + + 1213009 + SD_4 + 2 + 0 + 0 + 0 + + + + + 1203274 + 56 + 2 + FOURTH 1 + 10.84 + S + 55 + 0 + 0 + + + 1203276 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203277 + QUEUE + 2 + 0 + 0 + 0 + + + 1203278 + DEMAND + 3 + 0 + 0 + 0 + + + 1203279 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203281 + SD_5 + 1 + 0 + 0 + 0 + + + 1203283 + SD_1 + 1 + 0 + 0 + 0 + + + 1203285 + ML_1 + 1 + 0 + 0 + 0 + + + 1203286 + ML_2 + 2 + 0 + 0 + 0 + + + 1203287 + ML_3 + 3 + 0 + 0 + 0 + + + 1203289 + OS_1 + 1 + 0 + 0 + 0 + + + 1203290 + OS_2 + 2 + 0 + 0 + 0 + + + 1203291 + OS_3 + 3 + 0 + 0 + 0 + + + 1209048 + SD_2 + 1 + 0 + 0 + 0 + + + 1211958 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1211959 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + 1211960 + SD_3 + 1 + 0 + 0 + 0 + + + 1211961 + SD_4 + 1 + 0 + 0 + 0 + + + + + 1203321 + 56 + 3 + 17TH 1 + 11.74 + N + 55 + 0 + 0 + + + 1203323 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203324 + QUEUE + 2 + 0 + 0 + 0 + + + 1203325 + DEMAND + 3 + 0 + 0 + 0 + + + 1203326 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203328 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1203330 + SD_1 + 1 + 0 + 0 + 0 + + + 1203332 + ML_1 + 1 + 0 + 0 + 0 + + + 1203333 + ML_2 + 2 + 0 + 0 + 0 + + + 1203334 + ML_3 + 3 + 0 + 0 + 0 + + + 1212757 + ML_4 + 4 + 0 + 0 + 0 + + + 1212758 + SD_3 + 2 + 0 + 0 + 0 + + + + + 1203335 + 56 + 4 + 17TH 2 + 12.0 + N + 55 + 0 + 0 + + + 1203337 + QUEUE + 1 + 0 + 0 + 0 + + + 1203338 + DEMAND + 2 + 0 + 0 + 0 + + + 1203339 + PASSAGE + 3 + 0 + 0 + 0 + + + 1203341 + SD_1 + 1 + 0 + 0 + 0 + + + 1203343 + ML_1 + 1 + 0 + 0 + 0 + + + 1203344 + ML_2 + 2 + 0 + 0 + 0 + + + 1203345 + ML_3 + 3 + 0 + 0 + 0 + + + 1203347 + SD_2 + 1 + 0 + 0 + 0 + + + 1212999 + ML_4 + 4 + 0 + 0 + 0 + + + 1213000 + RAMP_ON + 4 + 0 + 0 + 0 + + + + + 1203307 + 56 + 5 + 17TH 1 + 11.62 + S + 55 + 0 + 0 + + + 1203309 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1203310 + QUEUE + 2 + 0 + 0 + 0 + + + 1203311 + DEMAND + 3 + 0 + 0 + 0 + + + 1203312 + PASSAGE + 4 + 0 + 0 + 0 + + + 1203314 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1203316 + SD_1 + 1 + 0 + 0 + 0 + + + 1203318 + ML_1 + 1 + 0 + 0 + 0 + + + 1203319 + ML_2 + 2 + 0 + 0 + 0 + + + 1203320 + ML_3 + 3 + 0 + 0 + 0 + + + 1213049 + ML_4 + 4 + 0 + 0 + 0 + + + + + 1212485 + 56 + 15 + BEAR 2 + 27.4 + N + 73 + 0 + 0 + + + 1212486 + ML_1 + 1 + 0 + 0 + 0 + + + 1212487 + ML_2 + 2 + 0 + 0 + 0 + + + 1212488 + ML_3 + 3 + 0 + 0 + 0 + + + 1212527 + DEMAND + 1 + 0 + 0 + 0 + + + 1212528 + PASSAGE + 2 + 0 + 0 + 0 + + + 1212529 + QUEUE + 3 + 0 + 0 + 0 + + + 1212530 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1212531 + RAMP_OFF + 1 + 0 + 0 + 0 + + + + + 1208935 + 56 + 16 + BEAR 1 + 27.2 + S + 73 + 0 + 0 + + + 1212481 + ML_1 + 1 + 0 + 0 + 0 + + + 1212482 + ML_2 + 2 + 0 + 0 + 0 + + + 1212483 + ML_3 + 3 + 0 + 0 + 0 + + + 1212520 + DEMAND + 1 + 0 + 0 + 0 + + + 1212521 + PASSAGE + 2 + 0 + 0 + 0 + + + 1212522 + QUEUE + 3 + 0 + 0 + 0 + + + 1212523 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1212524 + RAMP_OFF + 1 + 0 + 0 + 0 + + + + + 1208931 + 56 + 17 + ORCHID + 25.25 + S + 73 + 0 + 0 + + + 1212446 + ML_1 + 1 + 0 + 0 + 0 + + + 1212447 + ML_2 + 2 + 0 + 0 + 0 + + + 1212448 + ML_3 + 3 + 0 + 0 + 0 + + + 1212449 + OS_1 + 1 + 0 + 0 + 0 + + + 1212450 + OS_2 + 2 + 0 + 0 + 0 + + + 1212451 + OS_3 + 3 + 0 + 0 + 0 + + + 1212452 + OS_4 + 4 + 0 + 0 + 0 + + + 1212501 + SD_4 + 1 + 0 + 0 + 0 + + + 1212502 + SD_5 + 2 + 0 + 0 + 0 + + + 1212503 + RAMP_OFF + 1 + 0 + 0 + 0 + + + + + 1208932 + 56 + 18 + CAMPUS + 25.7 + N + 73 + 0 + 0 + + + 1212456 + ML_1 + 1 + 0 + 0 + 0 + + + 1212457 + ML_2 + 2 + 0 + 0 + 0 + + + 1212458 + ML_3 + 3 + 0 + 0 + 0 + + + 1212460 + OS_1 + 2 + 0 + 0 + 0 + + + 1212461 + OS_2 + 3 + 0 + 0 + 0 + + + 1212462 + OS_3 + 4 + 0 + 0 + 0 + + + 1212507 + SD_4 + 1 + 0 + 0 + 0 + + + 1212508 + SD_5 + 2 + 0 + 0 + 0 + + + 1212509 + DEMAND + 1 + 0 + 0 + 0 + + + 1212510 + PASSAGE + 2 + 0 + 0 + 0 + + + 1212511 + QUEUE + 3 + 0 + 0 + 0 + + + 1212512 + RAMP_ON + 4 + 0 + 0 + 0 + + + + + 1208934 + 56 + 19 + N OF 55 + 26.7 + N + 73 + 0 + 0 + + + 1212474 + ML_1 + 1 + 0 + 0 + 0 + + + 1212475 + ML_2 + 2 + 0 + 0 + 0 + + + 1212477 + OS_1 + 2 + 0 + 0 + 0 + + + 1212478 + OS_2 + 3 + 0 + 0 + 0 + + + 1212540 + SD_1 + 1 + 0 + 0 + 0 + + + 1212541 + SD_2 + 2 + 0 + 0 + 0 + + + 1212542 + SD_4 + 1 + 0 + 0 + 0 + + + 1212543 + SD_5 + 2 + 0 + 0 + 0 + + + + + + + 73 + 16 + 18 + 18 + 1123005950 + 1357636 + 26481 + + + 1201119 + 73 + 1 + IRVINE C2 + 1.11 + N + 405 + 0 + 0 + + + 1201121 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201122 + QUEUE + 2 + 0 + 0 + 0 + + + 1201123 + DEMAND + 3 + 0 + 0 + 0 + + + 1201124 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201126 + ML_1 + 1 + 0 + 0 + 0 + + + 1201127 + ML_2 + 2 + 0 + 0 + 0 + + + 1201128 + ML_3 + 3 + 0 + 0 + 0 + + + 1201129 + ML_4 + 4 + 0 + 0 + 0 + + + 1209042 + SD_1 + 1 + 0 + 0 + 0 + + + + + 1201130 + 73 + 2 + S OF 133 + 1.57 + S + 405 + 0 + 0 + + + 1201132 + SD_1 + 1 + 0 + 0 + 0 + + + 1209079 + ML_1 + 1 + 0 + 0 + 0 + + + 1209080 + ML_2 + 2 + 0 + 0 + 0 + + + 1209081 + ML_3 + 3 + 0 + 0 + 0 + + + 1209082 + ML_4 + 4 + 0 + 0 + 0 + + + 1209083 + OS_1 + 1 + 0 + 0 + 0 + + + 1209084 + OS_2 + 2 + 0 + 0 + 0 + + + 1209085 + OS_3 + 3 + 0 + 0 + 0 + + + 1209086 + OS_4 + 4 + 0 + 0 + 0 + + + 1209087 + OS_5 + 5 + 0 + 0 + 0 + + + 1209089 + SD_2 + 1 + 0 + 0 + 0 + + + 1210930 + SD_4 + 1 + 0 + 0 + 0 + + + 1210931 + COLL_DIST_ON + 1 + 0 + 0 + 0 + + + 1210934 + SD_5 + 1 + 0 + 0 + 0 + + + + + 1201133 + 73 + 3 + N OF 133 + 1.93 + S + 405 + 0 + 0 + + + 1201135 + SD_1 + 1 + 0 + 0 + 0 + + + 1209149 + ML_1 + 1 + 0 + 0 + 0 + + + 1209150 + ML_2 + 2 + 0 + 0 + 0 + + + 1209151 + ML_3 + 3 + 0 + 0 + 0 + + + 1209153 + ML_4 + 4 + 0 + 0 + 0 + + + 1209154 + OS_1 + 1 + 0 + 0 + 0 + + + 1209155 + OS_2 + 2 + 0 + 0 + 0 + + + 1209156 + OS_3 + 3 + 0 + 0 + 0 + + + 1209157 + OS_4 + 4 + 0 + 0 + 0 + + + 1209160 + SD_2 + 1 + 0 + 0 + 0 + + + 1209473 + COLL_DIST_OFF + 1 + 0 + 0 + 0 + + + 1209474 + SD_4 + 1 + 0 + 0 + 0 + + + 1209475 + SD_5 + 2 + 0 + 0 + 0 + + + 1210928 + COLL_DIST_ON + 1 + 0 + 0 + 0 + + + + + 1201092 + 73 + 4 + IRVINE C1 + 0.93 + N + 405 + 0 + 0 + + + 1201094 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201095 + QUEUE + 2 + 0 + 0 + 0 + + + 1201096 + DEMAND + 3 + 0 + 0 + 0 + + + 1201097 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201099 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1201101 + ML_1 + 1 + 0 + 0 + 0 + + + 1201102 + ML_2 + 2 + 0 + 0 + 0 + + + 1201103 + ML_3 + 3 + 0 + 0 + 0 + + + 1201104 + ML_4 + 4 + 0 + 0 + 0 + + + 1208953 + SD_1 + 1 + 0 + 0 + 0 + + + 1210822 + SD_2 + 2 + 0 + 0 + 0 + + + 1210823 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1210824 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + + + 1201150 + 73 + 5 + SAND CANYON + 2.99 + N + 405 + 0 + 0 + + + 1201152 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201153 + QUEUE + 2 + 0 + 0 + 0 + + + 1201154 + DEMAND + 3 + 0 + 0 + 0 + + + 1201155 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201156 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201158 + SD_1 + 1 + 0 + 0 + 0 + + + 1201160 + ML_1 + 1 + 0 + 0 + 0 + + + 1201161 + ML_2 + 2 + 0 + 0 + 0 + + + 1201162 + ML_3 + 3 + 0 + 0 + 0 + + + 1201163 + ML_4 + 4 + 0 + 0 + 0 + + + 1210056 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1211041 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1201105 + 73 + 6 + IRVINE C2 + 0.96 + S + 405 + 0 + 0 + + + 1201107 + QUEUE + 1 + 0 + 0 + 0 + + + 1201108 + DEMAND + 2 + 0 + 0 + 0 + + + 1201109 + PASSAGE + 3 + 0 + 0 + 0 + + + 1201111 + SD_1 + 1 + 0 + 0 + 0 + + + 1201113 + ML_1 + 1 + 0 + 0 + 0 + + + 1201114 + ML_2 + 2 + 0 + 0 + 0 + + + 1201115 + ML_3 + 3 + 0 + 0 + 0 + + + 1201116 + ML_4 + 4 + 0 + 0 + 0 + + + 1211052 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1211053 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1209051 + 73 + 7 + N OF SAND CANYON + 3.31 + N + 405 + 0 + 0 + + + 1209056 + ML_1 + 1 + 0 + 0 + 0 + + + 1209057 + ML_2 + 2 + 0 + 0 + 0 + + + 1209058 + ML_3 + 3 + 0 + 0 + 0 + + + 1209180 + ML_4 + 4 + 0 + 0 + 0 + + + 1209181 + OS_1 + 1 + 0 + 0 + 0 + + + 1209182 + OS_2 + 2 + 0 + 0 + 0 + + + 1209183 + OS_3 + 3 + 0 + 0 + 0 + + + 1209184 + OS_4 + 4 + 0 + 0 + 0 + + + 1209185 + SD_1 + 1 + 0 + 0 + 0 + + + 1209186 + SD_2 + 1 + 0 + 0 + 0 + + + + + 1209054 + 73 + 11 + AT 133 + 1.73 + S + 405 + 0 + 0 + + + 1209118 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + 1209119 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1209121 + SD_4 + 1 + 0 + 0 + 0 + + + 1209122 + SD_5 + 1 + 0 + 0 + 0 + + + + + 1201136 + 73 + 12 + SAND CANYON + 2.88 + S + 405 + 0 + 0 + + + 1201138 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1201139 + QUEUE + 2 + 0 + 0 + 0 + + + 1201140 + DEMAND + 3 + 0 + 0 + 0 + + + 1201141 + PASSAGE + 4 + 0 + 0 + 0 + + + 1201142 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1201144 + SD_1 + 1 + 0 + 0 + 0 + + + 1201146 + ML_1 + 1 + 0 + 0 + 0 + + + 1201147 + ML_2 + 2 + 0 + 0 + 0 + + + 1201148 + ML_3 + 3 + 0 + 0 + 0 + + + 1201149 + ML_4 + 4 + 0 + 0 + 0 + + + 1211048 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1211049 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1201080 + 73 + 13 + IRVINE C1 + 0.77 + S + 405 + 0 + 0 + + + 1201082 + QUEUE + 1 + 0 + 0 + 0 + + + 1201083 + DEMAND + 2 + 0 + 0 + 0 + + + 1201084 + PASSAGE + 3 + 0 + 0 + 0 + + + 1201086 + SD_1 + 1 + 0 + 0 + 0 + + + 1201088 + ML_1 + 1 + 0 + 0 + 0 + + + 1201089 + ML_2 + 2 + 0 + 0 + 0 + + + 1201090 + ML_3 + 3 + 0 + 0 + 0 + + + 1201091 + ML_4 + 4 + 0 + 0 + 0 + + + 1211045 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1211046 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1204941 + 73 + 15 + YALE + 25.8 + S + 5 + 0 + 0 + + + 1204943 + SD_1 + 1 + 0 + 0 + 0 + + + 1204945 + ML_1 + 1 + 0 + 0 + 0 + + + 1204946 + ML_2 + 2 + 0 + 0 + 0 + + + 1204947 + ML_3 + 3 + 0 + 0 + 0 + + + 1204948 + ML_4 + 4 + 0 + 0 + 0 + + + 1204949 + ML_5 + 5 + 0 + 0 + 0 + + + 1204951 + OS_1 + 1 + 0 + 0 + 0 + + + 1204952 + OS_2 + 2 + 0 + 0 + 0 + + + 1204953 + OS_3 + 3 + 0 + 0 + 0 + + + 1204954 + OS_4 + 4 + 0 + 0 + 0 + + + 1204955 + OS_5 + 5 + 0 + 0 + 0 + + + 1204957 + SD_2 + 1 + 0 + 0 + 0 + + + + + 1205068 + 73 + 16 + JAMBOREE 2 + 27.7 + N + 5 + 0 + 0 + + + 1205075 + ML_4 + 4 + 0 + 0 + 0 + + + 1205076 + ML_5 + 5 + 0 + 0 + 0 + + + 1210807 + DEMAND + 1 + 0 + 0 + 0 + + + 1210808 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210809 + QUEUE + 3 + 0 + 0 + 0 + + + 1210810 + ML_6 + 6 + 0 + 0 + 0 + + + 1210811 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210813 + RAMP_HOV + 5 + 0 + 0 + 0 + + + + + 1205019 + 73 + 17 + JAMBOREE 1 + 27.43 + S + 5 + 0 + 0 + + + 1205021 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205022 + QUEUE + 2 + 0 + 0 + 0 + + + 1205023 + DEMAND + 3 + 0 + 0 + 0 + + + 1205024 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205025 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1205027 + SD_1 + 1 + 0 + 0 + 0 + + + 1205029 + ML_1 + 1 + 0 + 0 + 0 + + + 1205030 + ML_2 + 2 + 0 + 0 + 0 + + + 1205031 + ML_3 + 3 + 0 + 0 + 0 + + + 1205032 + ML_4 + 4 + 0 + 0 + 0 + + + 1205033 + ML_5 + 5 + 0 + 0 + 0 + + + 1212847 + ML_6 + 6 + 0 + 0 + 0 + + + + + 1205034 + 73 + 18 + JAMBOREE 1 + 27.55 + N + 5 + 0 + 0 + + + 1205036 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205037 + QUEUE + 2 + 0 + 0 + 0 + + + 1205038 + DEMAND + 3 + 0 + 0 + 0 + + + 1205039 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205040 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1205042 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1205048 + ML_3 + 3 + 0 + 0 + 0 + + + 1205049 + ML_4 + 4 + 0 + 0 + 0 + + + 1205050 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1205051 + 73 + 19 + JAMBOREE 2 + 27.7 + S + 5 + 0 + 0 + + + 1205053 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1205054 + QUEUE + 2 + 0 + 0 + 0 + + + 1205055 + DEMAND + 3 + 0 + 0 + 0 + + + 1205056 + PASSAGE + 4 + 0 + 0 + 0 + + + 1205057 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1205059 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1205066 + ML_4 + 4 + 0 + 0 + 0 + + + 1205067 + ML_5 + 5 + 0 + 0 + 0 + + + + + 1209050 + 73 + 20 + LAGUNA CANYON RD + 2.35 + N + 405 + 0 + 0 + + + 1209165 + ML_1 + 1 + 0 + 0 + 0 + + + 1209166 + ML_2 + 2 + 0 + 0 + 0 + + + 1209167 + ML_3 + 3 + 0 + 0 + 0 + + + 1209168 + ML_4 + 4 + 0 + 0 + 0 + + + 1209169 + ML_5 + 5 + 0 + 0 + 0 + + + 1209170 + OS_1 + 1 + 0 + 0 + 0 + + + 1209171 + OS_2 + 2 + 0 + 0 + 0 + + + 1209172 + OS_3 + 3 + 0 + 0 + 0 + + + 1209173 + SD_1 + 1 + 0 + 0 + 0 + + + 1209175 + SD_2 + 1 + 0 + 0 + 0 + + + 1211050 + OS_4 + 4 + 0 + 0 + 0 + + + 1211051 + OS_5 + 5 + 0 + 0 + 0 + + + + + + + 74 + 18 + 19 + 19 + 1123005967 + 1357638 + 26480 + + + 1204649 + 74 + 1 + LAKE FOREST 1 + 19.8 + S + 5 + 0 + 0 + + + 1210292 + ML_1 + 1 + 0 + 0 + 0 + + + 1210293 + ML_2 + 2 + 0 + 0 + 0 + + + 1210294 + ML_3 + 3 + 0 + 0 + 0 + + + 1210295 + ML_4 + 4 + 0 + 0 + 0 + + + 1210296 + ML_5 + 5 + 0 + 0 + 0 + + + 1210297 + ML_6 + 6 + 0 + 0 + 0 + + + 1210298 + DEMAND + 1 + 0 + 0 + 0 + + + 1210299 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210300 + QUEUE + 3 + 0 + 0 + 0 + + + 1210301 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210302 + SD_1 + 1 + 0 + 0 + 0 + + + 1210303 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1204664 + 74 + 4 + LAKE FOREST 2 + 19.9 + S + 5 + 0 + 0 + + + 1210273 + ML_1 + 1 + 0 + 0 + 0 + + + 1210274 + ML_2 + 2 + 0 + 0 + 0 + + + 1210275 + ML_3 + 3 + 0 + 0 + 0 + + + 1210276 + ML_4 + 4 + 0 + 0 + 0 + + + 1210277 + ML_5 + 5 + 0 + 0 + 0 + + + 1210278 + ML_6 + 6 + 0 + 0 + 0 + + + 1210279 + SD_1 + 1 + 0 + 0 + 0 + + + 1210280 + SD_2 + 2 + 0 + 0 + 0 + + + 1210281 + DEMAND + 1 + 0 + 0 + 0 + + + 1210282 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210283 + QUEUE + 3 + 0 + 0 + 0 + + + 1210284 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210285 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1210287 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1210288 + SD_3 + 2 + 0 + 0 + 0 + + + 1210289 + SD_4 + 3 + 0 + 0 + 0 + + + 1210290 + SD_5 + 1 + 0 + 0 + 0 + + + + + 1204696 + 74 + 5 + BAKE 1 + 20.59 + N + 5 + 0 + 0 + + + 1208301 + ML_1 + 1 + 0 + 0 + 0 + + + 1208302 + ML_2 + 2 + 0 + 0 + 0 + + + 1208303 + ML_3 + 3 + 0 + 0 + 0 + + + 1208304 + ML_4 + 4 + 0 + 0 + 0 + + + 1211119 + ML_5 + 5 + 0 + 0 + 0 + + + 1211120 + ML_6 + 6 + 0 + 0 + 0 + + + 1211121 + SD_1 + 1 + 0 + 0 + 0 + + + 1211122 + SD_2 + 2 + 0 + 0 + 0 + + + 1211123 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1211124 + PASSAGE + 2 + 0 + 0 + 0 + + + 1211125 + DEMAND + 3 + 0 + 0 + 0 + + + 1211126 + QUEUE + 4 + 0 + 0 + 0 + + + 1211128 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1211129 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + 1211131 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1211132 + SD_3 + 3 + 0 + 0 + 0 + + + + + 1204698 + 74 + 6 + BAKE 2 + 20.94 + N + 5 + 0 + 0 + + + 1208310 + ML_1 + 1 + 0 + 0 + 0 + + + 1208311 + ML_2 + 2 + 0 + 0 + 0 + + + 1208312 + ML_3 + 3 + 0 + 0 + 0 + + + 1208313 + SD_2 + 1 + 0 + 0 + 0 + + + 1211137 + DEMAND + 4 + 0 + 0 + 0 + + + 1211138 + PASSAGE + 3 + 0 + 0 + 0 + + + 1211139 + RAMP_ON + 1 + 0 + 0 + 0 + + + 1211140 + RAMP_HOV + 2 + 0 + 0 + 0 + + + 1211141 + QUEUE + 5 + 0 + 0 + 0 + + + 1211142 + SD_3 + 2 + 0 + 0 + 0 + + + 1211143 + SD_4 + 3 + 0 + 0 + 0 + + + 1211144 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1211145 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + + + 1204694 + 74 + 7 + BAKE 1 + 20.59 + S + 5 + 0 + 0 + + + 1208305 + ML_1 + 1 + 0 + 0 + 0 + + + 1208306 + ML_2 + 2 + 0 + 0 + 0 + + + 1208307 + ML_3 + 3 + 0 + 0 + 0 + + + 1208308 + ML_4 + 4 + 0 + 0 + 0 + + + 1208309 + ML_5 + 5 + 0 + 0 + 0 + + + 1210243 + ML_6 + 6 + 0 + 0 + 0 + + + 1210244 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1210245 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + 1210246 + SD_3 + 3 + 0 + 0 + 0 + + + 1210247 + DEMAND + 1 + 0 + 0 + 0 + + + 1210248 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210249 + QUEUE + 3 + 0 + 0 + 0 + + + 1210251 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210252 + SD_1 + 1 + 0 + 0 + 0 + + + 1210253 + SD_2 + 2 + 0 + 0 + 0 + + + + + 1204700 + 74 + 8 + BAKE 2 + 20.95 + S + 5 + 0 + 0 + + + 1208314 + ML_1 + 1 + 0 + 0 + 0 + + + 1208315 + ML_2 + 2 + 0 + 0 + 0 + + + 1208316 + ML_3 + 3 + 0 + 0 + 0 + + + 1208317 + ML_4 + 4 + 0 + 0 + 0 + + + 1210225 + ML_5 + 5 + 0 + 0 + 0 + + + 1210226 + ML_6 + 6 + 0 + 0 + 0 + + + 1210227 + DEMAND + 1 + 0 + 0 + 0 + + + 1210228 + PASSAGE + 2 + 0 + 0 + 0 + + + 1210229 + QUEUE + 3 + 0 + 0 + 0 + + + 1210230 + RAMP_ON + 4 + 0 + 0 + 0 + + + 1210231 + RAMP_OFF + 1 + 0 + 0 + 0 + + + 1210233 + RAMP_HOV + 5 + 0 + 0 + 0 + + + 1210234 + SD_3 + 2 + 0 + 0 + 0 + + + 1210235 + SD_4 + 3 + 0 + 0 + 0 + + + 1210237 + SD_2 + 1 + 0 + 0 + 0 + + + 1210238 + SD_1 + 2 + 0 + 0 + 0 + + + 1210239 + SD_6 + 1 + 0 + 0 + 0 + + + 1210240 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1210241 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + 1210242 + SD_5 + 3 + 0 + 0 + 0 + + + + + 1204681 + 74 + 15 + OLDFIELD + 20.23 + N + 5 + 0 + 0 + + + 1204683 + ML_1 + 1 + 0 + 0 + 0 + + + 1204684 + ML_2 + 2 + 0 + 0 + 0 + + + 1204685 + ML_3 + 3 + 0 + 0 + 0 + + + 1204686 + ML_4 + 4 + 0 + 0 + 0 + + + 1204687 + ML_5 + 5 + 0 + 0 + 0 + + + 1204689 + OS_1 + 1 + 0 + 0 + 0 + + + 1204690 + OS_2 + 2 + 0 + 0 + 0 + + + 1204692 + OS_4 + 4 + 0 + 0 + 0 + + + 1204693 + OS_5 + 5 + 0 + 0 + 0 + + + 1210262 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1210263 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + 1210264 + SD_5 + 3 + 0 + 0 + 0 + + + 1210265 + SD_6 + 4 + 0 + 0 + 0 + + + 1210266 + SD_1 + 1 + 0 + 0 + 0 + + + 1210267 + SD_2 + 2 + 0 + 0 + 0 + + + 1210268 + SD_3 + 1 + 0 + 0 + 0 + + + 1210269 + SD_4 + 2 + 0 + 0 + 0 + + + 1204691 + OS_3 + 3 + 0 + 0 + 0 + + + + + 1204702 + 74 + 17 + At 405 + 21.25 + S + 5 + 0 + 0 + + + 1211154 + ML_1 + 1 + 0 + 0 + 0 + + + 1211155 + ML_2 + 2 + 0 + 0 + 0 + + + 1211156 + ML_3 + 3 + 0 + 0 + 0 + + + 1211157 + OS_1 + 1 + 0 + 0 + 0 + + + 1211158 + OS_2 + 2 + 0 + 0 + 0 + + + 1211159 + OS_3 + 3 + 0 + 0 + 0 + + + 1211160 + SD_2 + 1 + 0 + 0 + 0 + + + 1211161 + SD_1 + 1 + 0 + 0 + 0 + + + 1211162 + SD_3 + 1 + 0 + 0 + 0 + + + 1211163 + SD_4 + 2 + 0 + 0 + 0 + + + 1211164 + SD_5 + 3 + 0 + 0 + 0 + + + 1211165 + COLL_DIST_1 + 1 + 0 + 0 + 0 + + + 1211166 + COLL_DIST_2 + 2 + 0 + 0 + 0 + + + + + 1201117 + 74 + 18 + N OF 5 + 0.6 + S + 405 + 0 + 0 + + + 1211055 + ML_1 + 1 + 0 + 0 + 0 + + + 1211056 + ML_2 + 2 + 0 + 0 + 0 + + + 1211057 + ML_3 + 3 + 0 + 0 + 0 + + + 1211058 + ML_4 + 4 + 0 + 0 + 0 + + + 1211059 + ML_5 + 5 + 0 + 0 + 0 + + + 1211060 + OS_1 + 1 + 0 + 0 + 0 + + + 1211061 + OS_2 + 2 + 0 + 0 + 0 + + + 1211062 + OS_3 + 3 + 0 + 0 + 0 + + + 1211063 + SD_1 + 1 + 0 + 0 + 0 + + + 1211064 + SD_2 + 1 + 0 + 0 + 0 + + + + + + Index: /trunk/src/tmcsim/application.properties =================================================================== --- /trunk/src/tmcsim/application.properties (revision 66) +++ /trunk/src/tmcsim/application.properties (revision 79) @@ -1,5 +1,5 @@ -#Thu, 16 Mar 2017 12:41:52 -0700 +#Thu, 05 Oct 2017 10:44:21 -0700 -Application.revision=65 +Application.revision=67 Application.buildnumber=46 Index: /trunk/src/atmsdriver/ATMSDriver.java =================================================================== --- /trunk/src/atmsdriver/ATMSDriver.java (revision 79) +++ /trunk/src/atmsdriver/ATMSDriver.java (revision 79) @@ -0,0 +1,124 @@ +package atmsdriver; + +import atmsdriver.model.Network; +import java.io.File; +import java.io.FileInputStream; +import java.util.Properties; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author John A. Torres + * @version 09/10/2017 + */ +public class ATMSDriver implements Runnable { + + /** ATMSDriver Error logger. */ + private static Logger ATMSDriverLogger = Logger.getLogger("atmsdriver"); + + private static final String CONFIG_FILE_NAME = "atms_driver_config.properties"; + + /** Properties object for the CADClient class. */ + private Properties ATMSDriverProperties; + + /** + * Enumeration containing properties name values. See ATMSDriver class + * description for more information. + * + * @author John Torres + * @see ATMSDriver + */ + private static enum PROPERTIES { + + LDS_FILE_NAME("LDSFileName"), + LOOP_FILE_NAME("LoopFileName"), + NETWORK_FILE_NAME("NetworkFileName"), + EXCHANGE_FILE_NAME("ExchangeFileName"); + + public String name; + + private PROPERTIES(String n) { + name = n; + } + } + + /** Network model. */ + final private Network network; + + /** Sleep Time (10 seconds). **/ + private static final int SLEEP_TIME = 10000; + + /** Exchange Reader */ + private ExchangeReader exchangeReader; + + @Override + public void run() { + // Check for packets and update the simulator + for (;;) { + // Flush the input file + ExchangeInfo exInfo = exchangeReader.parse(ATMSDriverProperties + .getProperty(PROPERTIES.EXCHANGE_FILE_NAME.name)); + network.toXML(); + // Update if packet is recieved + if (exInfo != null) { + System.out.println("Grabbed"); + } + + // Sleep + try { + Thread.sleep(SLEEP_TIME); + } catch (InterruptedException ie) { + + } + } + } + + public ATMSDriver(String propertiesFile) { + + if (!verifyProperties(propertiesFile)) { + System.exit(0); + } + + network = new Network( + new File(ATMSDriverProperties.getProperty( + PROPERTIES.LDS_FILE_NAME.name)), + new File(ATMSDriverProperties.getProperty( + PROPERTIES.LOOP_FILE_NAME.name)), + new File(ATMSDriverProperties.getProperty( + PROPERTIES.NETWORK_FILE_NAME.name))); + network.toXML(); + exchangeReader = new ExchangeReader(); + } + + private boolean verifyProperties(String propertiesFile) { + // Load the properties file. + try { + ATMSDriverProperties = new Properties(); + ATMSDriverProperties.load(new FileInputStream(propertiesFile)); + } catch (Exception e) { + ATMSDriverLogger.logp(Level.SEVERE, "ATMSDriver", + "Constructor", "Exception in reading properties file.", e); + } + + return true; + } + + /** + * Runs the Paramics simulator. + */ + public static void main(String[] args) { + try { + if (System.getProperty("ATMSDRIVER_PROPERTIES") != null) { + new Thread(new ATMSDriver(System.getProperty( + "ATMSDRIVER_PROPERTIES"))).start(); + } else { + throw new Exception("ATMSDRIVER_PROPERTIES system property not defined."); + } + } catch (Exception e) { + ATMSDriverLogger.logp(Level.SEVERE, "ATMSDriver", "Main", + "Error occured initializing application", e); + System.exit(-1); + } + } +} Index: /trunk/src/atmsdriver/NetworkLoader.java =================================================================== --- /trunk/src/atmsdriver/NetworkLoader.java (revision 79) +++ /trunk/src/atmsdriver/NetworkLoader.java (revision 79) @@ -0,0 +1,277 @@ +package atmsdriver; + +import atmsdriver.model.FEPLine; +import atmsdriver.model.LoopDetectorStation; +import atmsdriver.model.LoopDetector; +import atmsdriver.model.LoopDetectorStation.DIRECTION; +import java.io.File; +import java.io.FileNotFoundException; +import java.util.ArrayList; +import java.util.List; +import java.util.Scanner; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** The NetworkReader loads all static data for the traffic network through + * network lookup files. + * + * The public method getFEPLines() method can be used to get all the FEPLines + * within a network. All other methods are private and are used to construct + * the FEPLines. + * + * The "LDSFile" contains LoopDetectorStation and FEPLine information. + * ex. + * < Insert file here > + * The "loopFile" contains individual LoopDetector information. + * ex. + * < Insert file here > + * + * @author John A. Torres + * @version 09/10/2017 + */ +public class NetworkLoader { + // Two network config files + private final File LDSFile; + private final File loopFile; + + // The list of FEPLines + private List lines; + + /** + * Constructor + * @param LDSFile contains FEPLine and Station static data + * @param loopFile contains individual LoopDetector static data + */ + public NetworkLoader(File LDSFile, File loopFile) + { + this.LDSFile = LDSFile; + this.loopFile = loopFile; + this.lines = new ArrayList<>(); + constructFEPLines(); + } + + /** + * Returns the list of FEPLines in the configured network + */ + public List getFEPLines() + { + return lines; + } + + // returns a list of the line numbers found in LDSFile + private ArrayList getLineNums(Scanner sc) + { + ArrayList lineNums = new ArrayList<>(); + + sc.nextLine(); // skip first line + + while(sc.hasNext()) + { + sc.nextInt(); // skip to line no + Integer lineNum = sc.nextInt(); // get the line number + + /* If the line is new, and has not been added, add it to lineNums */ + if(!lineNums.contains(lineNum)) + { + lineNums.add(lineNum); + } + + sc.nextLine(); // skip to next line + } + + sc.close(); + + return lineNums; + } + + // returns a list of station numbers for a given line + private ArrayList getStationNums(Integer lineNum, Scanner sc) + { + ArrayList stnNums = new ArrayList<>(); + + sc.nextLine(); // skip first line + + while(sc.hasNext()) + { + Integer stnNum = sc.nextInt(); + Integer theLine = sc.nextInt(); + if(theLine.equals(lineNum)) + { + stnNums.add(stnNum); + } + + sc.nextLine(); + } + + sc.close(); + + return stnNums; + } + + // returns a list of loop detectors for a given station + private ArrayList getLoops(Integer stnNum, Scanner sc) + { + ArrayList loops = new ArrayList<>(); + + sc.nextLine(); // skip first line + + while(sc.hasNext()) + { + sc.next(); // skip FWY + sc.next(); // skip dir + sc.next(); // skip postmile + Integer ldsID = sc.nextInt(); // lds id + sc.next(); // skip vdsID + Integer loopID = sc.nextInt(); // loop id + sc.next(); // skip LOC + Integer laneNum = sc.nextInt(); // lane number + String loopLoc = sc.next(); + if(stnNum.equals(ldsID)) + { + LoopDetector loop = new LoopDetector(loopID, loopLoc, laneNum); + loops.add(loop); + } + sc.nextLine(); + } + + sc.close(); + + return loops; + } + + // method called to actually build the network from config files + private void constructFEPLines() + { + try { + System.out.println("Building network..."); + + // Get FEPLine IDs + ArrayList lineNums = getLineNums(new Scanner(LDSFile)); + + // Create each FEPLine in the network + for(Integer lineNum : lineNums) + { + // Get Station IDs for the current FEPLine + ArrayList stnNums = getStationNums(lineNum, + new Scanner(LDSFile)); + + // Create each Station for the current FEPLine + ArrayList stns = new ArrayList<>(); + for(Integer stnNum : stnNums) + { + // Get Loops for the current Station + ArrayList loops = + getLoops(stnNum, new Scanner(loopFile)); + + // Create the Station and add to list for curr FEPLine + LoopDetectorStation stn = + createStation(stnNum, new Scanner(LDSFile), loops); + stns.add(stn); + } + + // Now that stations are created, create the actual FEPLine and + // and to FEPLines list + FEPLine line = createLine(lineNum, new Scanner(LDSFile), stns); + lines.add(line); + } + } catch (FileNotFoundException ex) { + Logger.getLogger(NetworkLoader.class.getName()).log(Level.SEVERE, null, ex); + } + } + + // Creates line + private FEPLine createLine(int lineNum, Scanner scLine, ArrayList stns) + { + FEPLine line = null; + + scLine.nextLine(); + + while(scLine.hasNext()) + { + scLine.nextInt(); // skip ldsID + int currLineNum = scLine.nextInt(); // linenum + if(currLineNum == lineNum) + { + scLine.nextInt(); // skip drop + int sch = scLine.nextInt(); // schedule + int lineinfo = scLine.nextInt(); // lineinfo + int sysKey = scLine.nextInt(); // sysKey + int schSeq = scLine.nextInt(); // schSeq + int globSeq = scLine.nextInt(); // globSeq + int count = scLine.nextInt(); // count + + line = new FEPLine(lineNum, stns, count, sch, lineinfo, sysKey, globSeq, schSeq); + + break; + } + + scLine.nextLine(); + } + + scLine.close(); + + return line; + } + + // Returns the loction given the whole line from the lookup file + private String getLocation(String line) + { + Scanner sc = new Scanner(line); + sc.nextInt(); // skip lds num + sc.nextInt(); // skip line num + int drop = sc.nextInt(); // drop num + sc.nextInt(); // skip schedule + sc.nextInt(); // skip lineinfo + sc.nextInt(); // skp systemkey + sc.nextInt(); // skip sch_seq + sc.nextInt(); // skip glob_seq + sc.nextInt(); // skip count + sc.nextInt(); // fwy + DIRECTION dir = DIRECTION.getEnum(sc.next()); // direction + sc.nextDouble(); + + /** GRABS FROM CURRENT TO END OF LINE */ + sc.useDelimiter("\\z"); + String loc = sc.next().trim(); + sc.close(); + return loc; + } + + // creates a Station + private LoopDetectorStation createStation(int stnNum, Scanner sc, ArrayList detectors) + { + LoopDetectorStation LDS = null; + + sc.nextLine(); + + while(sc.hasNext()) + { + String strLine = sc.nextLine(); + Scanner scLine = new Scanner(strLine); + int ldsID = scLine.nextInt(); // get curr lds id + if(ldsID == stnNum) // if we are on correct stn + { + int lineNum = scLine.nextInt(); // skip line num + int drop = scLine.nextInt(); // drop num + scLine.nextInt(); // skip schedule + scLine.nextInt(); // skip lineinfo + scLine.nextInt(); // skp systemkey + scLine.nextInt(); // skip sch_seq + scLine.nextInt(); // skip glob_seq + scLine.nextInt(); // skip count + int fwy = scLine.nextInt(); // fwy + DIRECTION dir = DIRECTION.getEnum(scLine.next()); // direction + double postmile = scLine.nextDouble(); + String ldsName = getLocation(strLine); /************* DOESNT GRAB WHOLE???? *///// + LDS = new LoopDetectorStation(lineNum, ldsID, drop, ldsName, detectors, fwy, dir, postmile); + + break; + } + scLine.close(); + } + + sc.close(); + + return LDS; + } +} Index: /trunk/src/atmsdriver/model/Network.java =================================================================== --- /trunk/src/atmsdriver/model/Network.java (revision 79) +++ /trunk/src/atmsdriver/model/Network.java (revision 79) @@ -0,0 +1,87 @@ +package atmsdriver.model; + +import atmsdriver.NetworkLoader; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.StringWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.transform.OutputKeys; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerConfigurationException; +import javax.xml.transform.TransformerException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.stream.StreamResult; +import org.w3c.dom.Document; +import org.w3c.dom.Element; + +/** + * + * @author andrew + */ +public class Network { + final private ArrayList lines; + final private File networkFile; + + public Network(File LDSFile, File loopFile, File networkFile) + { + lines = (ArrayList) + new NetworkLoader(LDSFile, loopFile).getFEPLines(); + this.networkFile = networkFile; + } + + public void toXML() + { + try { + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + DocumentBuilder builder = factory.newDocumentBuilder(); + Document theDoc = builder.newDocument(); + + Element networkElement = theDoc.createElement(XML_TAGS.NETWORK.tag); + theDoc.appendChild(networkElement); + + for(FEPLine line : lines) + { + line.toXML(networkElement); + } + + Transformer tf = TransformerFactory.newInstance().newTransformer(); + + tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); + tf.setOutputProperty(OutputKeys.INDENT, "yes"); + tf.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2"); + + Writer out = new StringWriter(); + tf.transform(new DOMSource(theDoc), new StreamResult(out)); + String xml = out.toString(); + out.close(); + + Writer fileWr = new FileWriter(networkFile); + fileWr.write(xml); + fileWr.close(); + + + } catch (Exception ex) { + Logger.getLogger(Network.class.getName()).log(Level.SEVERE, null, ex); + } + } + + private static enum XML_TAGS + { + NETWORK("Network"); + + String tag; + + private XML_TAGS(String n) + { + tag = n; + } + } +} Index: /trunk/src/atmsdriver/model/FEPLine.java =================================================================== --- /trunk/src/atmsdriver/model/FEPLine.java (revision 79) +++ /trunk/src/atmsdriver/model/FEPLine.java (revision 79) @@ -0,0 +1,106 @@ +package atmsdriver.model; + +import java.util.List; +import org.w3c.dom.Document; +import org.w3c.dom.Element; + + + +/** An FEPLine is a simulated line of communication from the FEP to + * LoopDetectorStations in the traffic network. + * + * An FEPLine contains static meta data and a list of LoopDetectorStations. + * A single FEPLine contains multiple LoopDetectorStations. + * + * @author John A. Torres + * @version 09/10/2017 + */ +public class FEPLine { + /* Static FEPLine meta data */ + final private int lineNum; + final private List stations; + final private int count; + // NOT SURE IF NEXT IS FINAL + final private int schedule; + final private int lineInfo; + final private long systemKey; + final private long globalSeq; + final private long scheduleSeq; + + public FEPLine(int lineNum, List stations, int count, + int schedule, int lineInfo, long systemKey, long globalSeq, + long scheduleSeq) + { + this.lineNum = lineNum; + this.stations = stations; + this.count = count; + this.schedule = schedule; + this.lineInfo = lineInfo; + this.systemKey = systemKey; + this.globalSeq = globalSeq; + this.scheduleSeq = scheduleSeq; + } + + public void toXML(Element currElem) + { + Document theDoc = currElem.getOwnerDocument(); + + Element lineElement = theDoc.createElement(XML_TAGS.LINE.tag); + currElem.appendChild(lineElement); + + Element lineNumElement = theDoc.createElement(XML_TAGS.LINE_NUM.tag); + lineNumElement.appendChild(theDoc.createTextNode(String.valueOf(this.lineNum))); + lineElement.appendChild(lineNumElement); + + Element countElement = theDoc.createElement(XML_TAGS.COUNT.tag); + countElement.appendChild(theDoc.createTextNode(String.valueOf(this.count))); + lineElement.appendChild(countElement); + + Element scheduleElement = theDoc.createElement(XML_TAGS.SCHEDULE.tag); + scheduleElement.appendChild(theDoc.createTextNode(String.valueOf(this.schedule))); + lineElement.appendChild(scheduleElement); + + Element lineInfoElement = theDoc.createElement(XML_TAGS.LINE_INFO.tag); + lineInfoElement.appendChild(theDoc.createTextNode(String.valueOf(this.lineInfo))); + lineElement.appendChild(lineInfoElement); + + Element systemKeyElement = theDoc.createElement(XML_TAGS.SYSTEM_KEY.tag); + systemKeyElement.appendChild(theDoc.createTextNode(String.valueOf(this.systemKey))); + lineElement.appendChild(systemKeyElement); + + Element globalSeqElement = theDoc.createElement(XML_TAGS.GLOBAL_SEQ.tag); + globalSeqElement.appendChild(theDoc.createTextNode(String.valueOf(this.globalSeq))); + lineElement.appendChild(globalSeqElement); + + Element scheduleSeqElement = theDoc.createElement(XML_TAGS.SCHEDULE_SEQ.tag); + scheduleSeqElement.appendChild(theDoc.createTextNode(String.valueOf(this.scheduleSeq))); + lineElement.appendChild(scheduleSeqElement); + + Element stationsElement = theDoc.createElement(XML_TAGS.STATIONS.tag); + lineElement.appendChild(stationsElement); + for(LoopDetectorStation station : stations) + { + station.toXML(stationsElement); + } + } + + private static enum XML_TAGS + { + LINE("Line"), + LINE_NUM("Line_Num"), + STATIONS("Stations"), + COUNT("Count"), + SCHEDULE("Schedule"), + LINE_INFO("Line_Info"), + SYSTEM_KEY("System_Key"), + GLOBAL_SEQ("Global_Seq"), + SCHEDULE_SEQ("Schedule_Seq"); + + String tag; + + private XML_TAGS(String n) + { + tag = n; + } + } +} Index: /trunk/src/atmsdriver/model/LoopDetector.java =================================================================== --- /trunk/src/atmsdriver/model/LoopDetector.java (revision 79) +++ /trunk/src/atmsdriver/model/LoopDetector.java (revision 79) @@ -0,0 +1,103 @@ +package atmsdriver.model; + +import java.util.ArrayList; +import java.util.List; +import org.w3c.dom.Document; +import org.w3c.dom.Element; + +/** A LoopDetector represents a single detector for a single lane in a network. + * + * A LoopDetector contains static meta data, and three dynamic attributes: vol, + * occ, and spd. + * + * @author John A. Torres + * @version 09/10/2017 + */ +public class LoopDetector +{ + /* static data */ + final private int loopID; + final private String loopLocation; + final private int laneNum; + + /* dynamic data */ + private int vol; + private int occ; + private int spd; + + public LoopDetector(int loopID, String loopLocation, int laneNum) + { + /* Set static data */ + this.loopID = loopID; + this.loopLocation = loopLocation; + this.laneNum = laneNum; + + /* Init dynamic data */ + this.vol = 0; + this.spd = 0; + this.occ = 0; + } + + private static enum XML_TAGS + { + LOOP_ID("Loop_ID"), + LOOP_LOCATION("Loop_Location"), + LANE_NUM("Lane_Num"), + VOL("Vol"), + SPD("Spd"), + OCC("Occ"), + LOOP("Loop"); + + String tag; + + private XML_TAGS(String n) + { + tag = n; + } + } + + /** + * Updates loop detector dynamic attributes. + * @param vol volume + * @param occ occupancy + * @param spd speed + */ + public void updateLoop(int vol, int occ, int spd) + { + this.vol = vol; + this.occ = occ; + this.spd = spd; + } + + public void toXML(Element currElem) + { + Document theDoc = currElem.getOwnerDocument(); + + Element loopElement = theDoc.createElement(XML_TAGS.LOOP.tag); + currElem.appendChild(loopElement); + + Element loopIDElement = theDoc.createElement(XML_TAGS.LOOP_ID.tag); + loopIDElement.appendChild(theDoc.createTextNode(String.valueOf(this.loopID))); + loopElement.appendChild(loopIDElement); + + Element loopLocElement = theDoc.createElement(XML_TAGS.LOOP_LOCATION.tag); + loopLocElement.appendChild(theDoc.createTextNode(this.loopLocation)); + loopElement.appendChild(loopLocElement); + + Element laneNumElement = theDoc.createElement(XML_TAGS.LANE_NUM.tag); + laneNumElement.appendChild(theDoc.createTextNode(String.valueOf(this.laneNum))); + loopElement.appendChild(laneNumElement); + + Element volElement = theDoc.createElement(XML_TAGS.VOL.tag); + volElement.appendChild(theDoc.createTextNode(String.valueOf(this.vol))); + loopElement.appendChild(volElement); + + Element occElement = theDoc.createElement(XML_TAGS.OCC.tag); + occElement.appendChild(theDoc.createTextNode(String.valueOf(this.occ))); + loopElement.appendChild(occElement); + + Element spdElement = theDoc.createElement(XML_TAGS.SPD.tag); + spdElement.appendChild(theDoc.createTextNode(String.valueOf(this.spd))); + loopElement.appendChild(spdElement); + } +} Index: /trunk/src/atmsdriver/model/LoopDetectorStation.java =================================================================== --- /trunk/src/atmsdriver/model/LoopDetectorStation.java (revision 79) +++ /trunk/src/atmsdriver/model/LoopDetectorStation.java (revision 79) @@ -0,0 +1,168 @@ +package atmsdriver.model; + +import java.util.List; +import org.w3c.dom.Document; +import org.w3c.dom.Element; + +/** A LoopDetectorStation is a simulation of a station in a traffic network. + * + * A LoopDetectorStation (LDS) contains static meta data about the station, and + * two dynamic attributes, MLTotVol and OppTotVol. + * + * A single LDS contains multiple LoopDetectors, which + * contain data for a single lane on one direction of the freeway. A LDS + * is specific to a single freeway, direction, and postmile. + * + * @author John A. Torres + * @version 9/10/2017 + */ +public class LoopDetectorStation { + /* Static LoopDetectorStation meta data */ + final private int lineNum; + final private int ldsID; // double check + final private int drop; + final private String location; + final private List loops; + final private int freeway; + final private double postmile; + final private DIRECTION direction; + + /* Dynamic LoopDetectorStation data */ + private int MLTotVol; + private int OppTotVol; + + /* Constructor */ + public LoopDetectorStation(int lineNum, int ldsID, int drop, + String location, List loops, int fwy, + DIRECTION direction, double postmile) + { + this.lineNum = lineNum; + this.ldsID = ldsID; + this.drop = drop; + this.loops = loops; + this.location = location; + this.postmile = postmile; + this.direction = direction; + this.freeway = fwy; + + this.MLTotVol = 0; + this.OppTotVol = 0; + } + + private static enum XML_TAGS + { + STATION("Station"), + LDS_ID("LDS_ID"), + LINE_NUM("Line_Num"), + DROP("Drop"), + LOOPS("Loops"), + LOCATION("Location"), + POST_MILE("Post_Mile"), + DIRECTION("Direction"), + FREEWAY("Freeway"), + ML_TOT_VOL("ML_Tot_Vol"), + OPP_TOT_VOL("Opp_Tot_Vol"); + + String tag; + + private XML_TAGS(String n) + { + tag = n; + } + } + + public void toXML(Element currElem) + { + Document theDoc = currElem.getOwnerDocument(); + + Element stationElement = theDoc.createElement(XML_TAGS.STATION.tag); + currElem.appendChild(stationElement); + + Element ldsIDElement = theDoc.createElement(XML_TAGS.LDS_ID.tag); + ldsIDElement.appendChild(theDoc.createTextNode(String.valueOf(this.ldsID))); + stationElement.appendChild(ldsIDElement); + + Element lineNumElement = theDoc.createElement(XML_TAGS.LINE_NUM.tag); + lineNumElement.appendChild(theDoc.createTextNode(String.valueOf(this.lineNum))); + stationElement.appendChild(lineNumElement); + + Element dropElement = theDoc.createElement(XML_TAGS.DROP.tag); + dropElement.appendChild(theDoc.createTextNode(String.valueOf(this.drop))); + stationElement.appendChild(dropElement); + + Element locationElement = theDoc.createElement(XML_TAGS.LOCATION.tag); + locationElement.appendChild(theDoc.createTextNode(this.location)); + stationElement.appendChild(locationElement); + + Element postMileElement = theDoc.createElement(XML_TAGS.POST_MILE.tag); + postMileElement.appendChild(theDoc.createTextNode(String.valueOf(this.postmile))); + stationElement.appendChild(postMileElement); + + Element directionElement = theDoc.createElement(XML_TAGS.DIRECTION.tag); + directionElement.appendChild(theDoc.createTextNode(this.direction.name)); + stationElement.appendChild(directionElement); + + Element freewayElement = theDoc.createElement(XML_TAGS.FREEWAY.tag); + freewayElement.appendChild(theDoc.createTextNode(String.valueOf(this.freeway))); + stationElement.appendChild(freewayElement); + + Element mlElement = theDoc.createElement(XML_TAGS.ML_TOT_VOL.tag); + mlElement.appendChild(theDoc.createTextNode(String.valueOf(this.MLTotVol))); + stationElement.appendChild(mlElement); + + Element oppElement = theDoc.createElement(XML_TAGS.OPP_TOT_VOL.tag); + oppElement.appendChild(theDoc.createTextNode(String.valueOf(this.OppTotVol))); + stationElement.appendChild(oppElement); + + Element loopsElement = theDoc.createElement(XML_TAGS.LOOPS.tag); + stationElement.appendChild(loopsElement); + + for(LoopDetector loop : loops) + { + loop.toXML(loopsElement); + } + } + + /** + * Enum for freeway direction. + * + * @author John A. Torres + * @version 9/10/2017 + */ + public static enum DIRECTION + { + NORTH("N"), + SOUTH("S"), + EAST("E"), + WEST("W"); + + String name; + + DIRECTION(String name) + { + this.name = name; + } + + /** + * Returns the direction enum, given a string value. + * @param name str value for enum + * @return enum for given str value + */ + public static DIRECTION getEnum(String name) + { + switch(name) + { + case "S": + return SOUTH; + case "N": + return NORTH; + case "E": + return EAST; + case "W": + return WEST; + default: + return null; + } + } + } +} Index: /trunk/src/atmsdriver/ExchangeReader.java =================================================================== --- /trunk/src/atmsdriver/ExchangeReader.java (revision 79) +++ /trunk/src/atmsdriver/ExchangeReader.java (revision 79) @@ -0,0 +1,280 @@ +package atmsdriver; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.StringReader; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.parsers.SAXParserFactory; +import org.xml.sax.Attributes; +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; +import org.xml.sax.SAXParseException; +import org.xml.sax.helpers.DefaultHandler; + +/** + * + * @author John A Torres + */ +public class ExchangeReader { + /** Error Log **/ + private static Logger ATMSDriverLogger = Logger.getLogger("atmsdriver"); + + /** A SAX Handler that is used to parse received Incident Status Node. **/ + private IncidentStatusHandler ish = null; + + /** The current networkId **/ + private int networkId = 1; + + /** The Paramics Simulation Info for the most recent incident read **/ + private ExchangeInfo exInfo = null; + + /** Value (seconds since 1/1/1970) of input file's last modification time. */ + private long lastModified = 0; + + /** + * Constructor. + */ + public ExchangeReader() + { + ish = new IncidentStatusHandler(); + } + + /** + * This method parses the received XML node with the local CameraStatusHandler. + * All updated camera information is sent to the ParamicsSimulationManager. + * + * If a successful read of the file occurs, the file is written with an empty string + * and the date of the last modification is stored. + * + * @param filename The file to check for message in. + * @return A ParamicsSimulationInfo object containing the file's information + * A null pointer on: + * - The file does not exist + * - No new modification + * - An error opening file + * - An empty file + * - An error parsing the file + * + * The caller is able to call this function to check if there are any new messages + * in the file. If there are, a PSI object is returned. If there aren't any new + * messages, a null pointer is returned. + */ + public ExchangeInfo parse(String filename) + { + ExchangeInfo exInfo = null; + + File f = new File(filename); + BufferedReader r = null; + + // File does not exist: No information + if (!(f.exists())) + { + return null; + } + + // File not modified: No new information + if (f.lastModified() <= lastModified) + { + return null; + } + + try + { + // Try to open the file + r = new BufferedReader(new FileReader(f)); + + // Read the file to the end + StringBuilder xml = new StringBuilder(""); + String line = r.readLine(); + while (line != null) + { + xml.append(line + "\n"); + line = r.readLine(); + } + + // If the file has contents in it, read them and returned a PSI describing the contents + if(xml.length() > 0) + { + // Parse the file + SAXParserFactory.newInstance().newSAXParser().parse(new InputSource(new StringReader(xml.toString())), ish); + exInfo = new ExchangeInfo(networkId, xml.toString()); + } + else if (xml.length() == 0) + { + lastModified = modifyFile(f); + r.close(); + } + } + catch (FileNotFoundException fnfe) + { + ATMSDriverLogger.logp(Level.SEVERE, "ParamicsIncidentReader", "parse", + filename + " dissapeared before reading.", fnfe); + exInfo = null; + } + catch (IOException ioe) + { + ATMSDriverLogger.logp(Level.SEVERE, "ParamicsIncidentReader", "parse", + "Error while reading file " + filename + ".", ioe); + exInfo = null; + } + catch (SAXException saxe) + { + ATMSDriverLogger.logp(Level.SEVERE, "ParamicsIncidentReader", "parse", + "Error while parsing file " + filename + ".", saxe); + exInfo = null; + } + catch (ParserConfigurationException pce) + { + ATMSDriverLogger.logp(Level.SEVERE, "ParamicsIncidentReader", "parse", + "Error while configuring parser.", pce); + } + + // If a incident was read + if (exInfo != null) + { + lastModified = modifyFile(f); + try + { + r.close(); + } + catch (IOException e) + { + ATMSDriverLogger.logp(Level.SEVERE, "ParamicsIncidentReader", "parse", + "Error while closing file" + filename + ".", e); + } + } + + // Return no object if there was an error while reading, or the psi created from + // parsing the file if the operation was successful. + return exInfo; + } + + private long modifyFile(File f) + { + FileWriter w = null; + + // Write to the file to show that it was read. + try + { + w = new FileWriter(f); + w.write(""); + w.close(); + } + catch (IOException e) + { + ATMSDriverLogger.logp(Level.SEVERE, "ParamicsIncidentReader", "parse", + "Error while writing to file " + f.getName() + " to show that file was read.", e); + } + + // Save the last modified time + return f.lastModified(); + } + + /** + * Internal SAX Handler used to parse the Incident Status Document read by + * the remote Status Reader. The schema for this document is:
+ * + *
+ *
+ *
+ *
+ *
+ *
+ * + * + * + *
+ *
+ *
+ *
+ *
+ *
+ *
+ * + * + * + *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * ... + *
+ *
+ * ... + * + * + * + * + * + * + * + * + * ... + * + * ... + * + * + * + */ + protected class IncidentStatusHandler extends DefaultHandler + { + private final String NETWORK_ID = "Network_ID"; + + /** A buffer for reading characters **/ + private StringBuffer parsedValue = new StringBuffer(); + + public void startDocument() + { + } + + /** Appends characters to the xmlMessage and parsedValue buffers **/ + public void characters(char[] ch, int start, int length) + { + parsedValue.append(new String(ch, start, length).trim()); + } + + public void startElement (String uri, String localName, String qName, Attributes attributes) + throws SAXException + { + } + + public void endElement(String uri, String localName, String qName) + { + if(qName.equals(NETWORK_ID)) { networkId = Integer.parseInt(parsedValue.toString()); } + + parsedValue.setLength(0); + } + + public void error(SAXParseException e) + { + ATMSDriverLogger.logp(Level.SEVERE, "ParamicsIncidentReader", "error", + "Error in parsing received incident status.", e); + } + + public void fatalError(SAXParseException e) + { + ATMSDriverLogger.logp(Level.SEVERE, "ParamicsIncidentReader", "fatalError", + "Fatal error in parsing received incident status.", e); + } + + public void warning(SAXParseException e) + { + ATMSDriverLogger.logp(Level.WARNING, "ParamicsIncidentReader", "warning", + "Warning in parsing received incident status.", e); + } + } +} Index: /trunk/src/atmsdriver/ExchangeInfo.java =================================================================== --- /trunk/src/atmsdriver/ExchangeInfo.java (revision 79) +++ /trunk/src/atmsdriver/ExchangeInfo.java (revision 79) @@ -0,0 +1,20 @@ +package atmsdriver; + +/** + * + * @author John A Torres + */ +public class ExchangeInfo { + /** The network ID **/ + public int networkId; + + /** The XML message **/ + public String xmlMessage; + + /** Constructor **/ + public ExchangeInfo(int networkId, String xmlMessage) + { + this.networkId = networkId; + this.xmlMessage = xmlMessage; + } +} Index: /trunk/camera_status.log =================================================================== --- /trunk/camera_status.log (revision 79) +++ /trunk/camera_status.log (revision 79) @@ -0,0 +1,1290 @@ + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + + + + 24 + 55 + SB + 6.11 + 10.0 + 10.0 + + + 97 + 5 + NB + 19.5 + 10.0 + 10.0 + + + 28 + 405 + SB + 3.95 + 10.0 + 10.0 + + + 16 + 5 + SB + 31.76 + 10.0 + 10.0 + + + 171 + 405 + SB + 1.97 + 10.0 + 10.0 + + + Index: /trunk/paramics_communicator.log =================================================================== --- /trunk/paramics_communicator.log (revision 79) +++ /trunk/paramics_communicator.log (revision 79) @@ -0,0 +1,12 @@ + + + + + + 30 + 1 + FALSE + FALSE + + + Index: /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/project.properties =================================================================== --- /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/project.properties (revision 59) +++ /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/project.properties (revision 79) @@ -72,5 +72,5 @@ meta.inf.dir=${src.dir}/META-INF mkdist.disabled=false -platform.active=JDK_1.7 +platform.active=default_platform run.classpath=\ ${javac.classpath}:\ Index: /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/project.xml =================================================================== --- /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/project.xml (revision 12) +++ /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/project.xml (revision 79) @@ -5,5 +5,4 @@ TMCSim -

Index: /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/genfiles.properties =================================================================== --- /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/genfiles.properties (revision 12) +++ /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/genfiles.properties (revision 79) @@ -4,5 +4,5 @@ # This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml. # Do not edit this file. You may delete it but then the IDE will never regenerate such files for you. -nbproject/build-impl.xml.data.CRC32=e14f63c1 -nbproject/build-impl.xml.script.CRC32=53f7f34a -nbproject/build-impl.xml.stylesheet.CRC32=c6d2a60f@1.56.1.46 +nbproject/build-impl.xml.data.CRC32=6c7221c6 +nbproject/build-impl.xml.script.CRC32=5cb245d6 +nbproject/build-impl.xml.stylesheet.CRC32=876e7a8f@1.75.2.48 Index: /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/configs/ATMSDriver.properties =================================================================== --- /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/configs/ATMSDriver.properties (revision 79) +++ /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/configs/ATMSDriver.properties (revision 79) @@ -0,0 +1,2 @@ +main.class=atmsdriver.ATMSDriver +run.jvmargs=-DATMSDRIVER_PROPERTIES=config/atms_driver_config.properties Index: /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/build-impl.xml =================================================================== --- /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/build-impl.xml (revision 12) +++ /trunk/IDE_metadata/NetBeans/TMCSim/nbproject/build-impl.xml (revision 79) @@ -55,41 +55,5 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - Must set platform.home - Must set platform.bootcp - Must set platform.java - Must set platform.javac - - The J2SE Platform is not correctly set up. - Your active platform is: ${platform.active}, but the corresponding property "platforms.${platform.active}.home" is not found in the project's properties files. - Either open the project in the IDE and setup the Platform with the same name or add it manually. - For example like this: - ant -Duser.properties.file=<path_to_property_file> jar (where you put the property "platforms.${platform.active}.home" in a .properties file) - or ant -Dplatforms.${platform.active}.home=<path_to_JDK_home> jar (where no properties file is used) - + @@ -109,14 +73,18 @@ - - - - + + + + + - - - + + + + + + @@ -129,10 +97,4 @@ - - - - - - @@ -153,21 +115,9 @@ - - - + + + - - - - - - - - - - - - @@ -224,6 +174,23 @@ - - + + + + + + + + + + + + + + + + + + + @@ -294,5 +261,5 @@ - + @@ -304,4 +271,5 @@ + @@ -333,5 +301,5 @@ - + @@ -343,4 +311,5 @@ + @@ -413,5 +382,5 @@ - + @@ -436,5 +405,5 @@ - + @@ -475,5 +444,5 @@ - + @@ -555,5 +524,5 @@ - + @@ -580,5 +549,5 @@ - + @@ -760,7 +729,4 @@ - - - @@ -778,7 +744,5 @@ - - - + @@ -805,5 +769,5 @@ - + @@ -832,5 +796,5 @@ - + @@ -871,6 +835,6 @@ - - + + @@ -884,5 +848,5 @@ - + @@ -1000,17 +964,38 @@ - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + To run this application from the command line without Ant, try: + + java -jar "${dist.jar.resolved}" + + + @@ -1019,44 +1004,25 @@ - ${platform.java} -cp "${run.classpath.with.dist.jar}" ${main.class} - - - - - - - - - - - - - - - - - - - - - - - - - To run this application from the command line without Ant, try: - - ${platform.java} -jar "${dist.jar.resolved}" - - + + + + + + + + + - + + - + + " + "\n" + "\n" + " Go to the Toy store!" + " Do bills " + " Look for Evil Dinosaurs! " + ""; + + { + + #ifdef TIXML_USE_STL + // What the todo list should look like after processing. + // In stream (no formatting) representation. + const char* demoEnd = + "" + "" + "" + "" + "Go to the" + "Toy store!" + "" + "" + "Talk to:" + "" + "" + "" + "" + "" + "" + "Do bills" + "" + ""; + #endif + + // The example parses from the character string (above): + #if defined( WIN32 ) && defined( TUNE ) + _CrtMemCheckpoint( &startMemState ); + #endif + + { + // Write to a file and read it back, to check file I/O. + + TiXmlDocument doc( "demotest.xml" ); + doc.Parse( demoStart ); + + if ( doc.Error() ) + { + printf( "Error in %s: %s\n", doc.Value(), doc.ErrorDesc() ); + exit( 1 ); + } + doc.SaveFile(); + } + + TiXmlDocument doc( "demotest.xml" ); + bool loadOkay = doc.LoadFile(); + + if ( !loadOkay ) + { + printf( "Could not load test file 'demotest.xml'. Error='%s'. Exiting.\n", doc.ErrorDesc() ); + exit( 1 ); + } + + printf( "** Demo doc read from disk: ** \n\n" ); + printf( "** Printing via doc.Print **\n" ); + doc.Print( stdout ); + + { + printf( "** Printing via TiXmlPrinter **\n" ); + TiXmlPrinter printer; + doc.Accept( &printer ); + fprintf( stdout, "%s", printer.CStr() ); + } + #ifdef TIXML_USE_STL + { + printf( "** Printing via operator<< **\n" ); + std::cout << doc; + } + #endif + TiXmlNode* node = 0; + TiXmlElement* todoElement = 0; + TiXmlElement* itemElement = 0; + + + // -------------------------------------------------------- + // An example of changing existing attributes, and removing + // an element from the document. + // -------------------------------------------------------- + + // Get the "ToDo" element. + // It is a child of the document, and can be selected by name. + node = doc.FirstChild( "ToDo" ); + assert( node ); + todoElement = node->ToElement(); + assert( todoElement ); + + // Going to the toy store is now our second priority... + // So set the "priority" attribute of the first item in the list. + node = todoElement->FirstChildElement(); // This skips the "PDA" comment. + assert( node ); + itemElement = node->ToElement(); + assert( itemElement ); + itemElement->SetAttribute( "priority", 2 ); + + // Change the distance to "doing bills" from + // "none" to "here". It's the next sibling element. + itemElement = itemElement->NextSiblingElement(); + assert( itemElement ); + itemElement->SetAttribute( "distance", "here" ); + + // Remove the "Look for Evil Dinosaurs!" item. + // It is 1 more sibling away. We ask the parent to remove + // a particular child. + itemElement = itemElement->NextSiblingElement(); + todoElement->RemoveChild( itemElement ); + + itemElement = 0; + + // -------------------------------------------------------- + // What follows is an example of created elements and text + // nodes and adding them to the document. + // -------------------------------------------------------- + + // Add some meetings. + TiXmlElement item( "Item" ); + item.SetAttribute( "priority", "1" ); + item.SetAttribute( "distance", "far" ); + + TiXmlText text( "Talk to:" ); + + TiXmlElement meeting1( "Meeting" ); + meeting1.SetAttribute( "where", "School" ); + + TiXmlElement meeting2( "Meeting" ); + meeting2.SetAttribute( "where", "Lunch" ); + + TiXmlElement attendee1( "Attendee" ); + attendee1.SetAttribute( "name", "Marple" ); + attendee1.SetAttribute( "position", "teacher" ); + + TiXmlElement attendee2( "Attendee" ); + attendee2.SetAttribute( "name", "Voel" ); + attendee2.SetAttribute( "position", "counselor" ); + + // Assemble the nodes we've created: + meeting1.InsertEndChild( attendee1 ); + meeting1.InsertEndChild( attendee2 ); + + item.InsertEndChild( text ); + item.InsertEndChild( meeting1 ); + item.InsertEndChild( meeting2 ); + + // And add the node to the existing list after the first child. + node = todoElement->FirstChild( "Item" ); + assert( node ); + itemElement = node->ToElement(); + assert( itemElement ); + + todoElement->InsertAfterChild( itemElement, item ); + + printf( "\n** Demo doc processed: ** \n\n" ); + doc.Print( stdout ); + + + #ifdef TIXML_USE_STL + printf( "** Demo doc processed to stream: ** \n\n" ); + cout << doc << endl << endl; + #endif + + // -------------------------------------------------------- + // Different tests...do we have what we expect? + // -------------------------------------------------------- + + int count = 0; + TiXmlElement* element; + + ////////////////////////////////////////////////////// + + #ifdef TIXML_USE_STL + cout << "** Basic structure. **\n"; + ostringstream outputStream( ostringstream::out ); + outputStream << doc; + XmlTest( "Output stream correct.", string( demoEnd ).c_str(), + outputStream.str().c_str(), true ); + #endif + + node = doc.RootElement(); + assert( node ); + XmlTest( "Root element exists.", true, ( node != 0 && node->ToElement() ) ); + XmlTest ( "Root element value is 'ToDo'.", "ToDo", node->Value()); + + node = node->FirstChild(); + XmlTest( "First child exists & is a comment.", true, ( node != 0 && node->ToComment() ) ); + node = node->NextSibling(); + XmlTest( "Sibling element exists & is an element.", true, ( node != 0 && node->ToElement() ) ); + XmlTest ( "Value is 'Item'.", "Item", node->Value() ); + + node = node->FirstChild(); + XmlTest ( "First child exists.", true, ( node != 0 && node->ToText() ) ); + XmlTest ( "Value is 'Go to the'.", "Go to the", node->Value() ); + + + ////////////////////////////////////////////////////// + printf ("\n** Iterators. **\n"); + + // Walk all the top level nodes of the document. + count = 0; + for( node = doc.FirstChild(); + node; + node = node->NextSibling() ) + { + count++; + } + XmlTest( "Top level nodes, using First / Next.", 3, count ); + + count = 0; + for( node = doc.LastChild(); + node; + node = node->PreviousSibling() ) + { + count++; + } + XmlTest( "Top level nodes, using Last / Previous.", 3, count ); + + // Walk all the top level nodes of the document, + // using a different syntax. + count = 0; + for( node = doc.IterateChildren( 0 ); + node; + node = doc.IterateChildren( node ) ) + { + count++; + } + XmlTest( "Top level nodes, using IterateChildren.", 3, count ); + + // Walk all the elements in a node. + count = 0; + for( element = todoElement->FirstChildElement(); + element; + element = element->NextSiblingElement() ) + { + count++; + } + XmlTest( "Children of the 'ToDo' element, using First / Next.", + 3, count ); + + // Walk all the elements in a node by value. + count = 0; + for( node = todoElement->FirstChild( "Item" ); + node; + node = node->NextSibling( "Item" ) ) + { + count++; + } + XmlTest( "'Item' children of the 'ToDo' element, using First/Next.", 3, count ); + + count = 0; + for( node = todoElement->LastChild( "Item" ); + node; + node = node->PreviousSibling( "Item" ) ) + { + count++; + } + XmlTest( "'Item' children of the 'ToDo' element, using Last/Previous.", 3, count ); + + #ifdef TIXML_USE_STL + { + cout << "\n** Parsing. **\n"; + istringstream parse0( "" ); + TiXmlElement element0( "default" ); + parse0 >> element0; + + XmlTest ( "Element parsed, value is 'Element0'.", "Element0", element0.Value() ); + XmlTest ( "Reads attribute 'attribute0=\"foo0\"'.", "foo0", element0.Attribute( "attribute0" )); + XmlTest ( "Reads incorrectly formatted 'attribute1=noquotes'.", "noquotes", element0.Attribute( "attribute1" ) ); + XmlTest ( "Read attribute with entity value '>'.", ">", element0.Attribute( "attribute2" ) ); + } + #endif + + { + const char* error = "\n" + "\n" + " \n" + ""; + + TiXmlDocument docTest; + docTest.Parse( error ); + XmlTest( "Error row", docTest.ErrorRow(), 3 ); + XmlTest( "Error column", docTest.ErrorCol(), 17 ); + //printf( "error=%d id='%s' row %d col%d\n", (int) doc.Error(), doc.ErrorDesc(), doc.ErrorRow()+1, doc.ErrorCol() + 1 ); + + } + + #ifdef TIXML_USE_STL + { + ////////////////////////////////////////////////////// + cout << "\n** Streaming. **\n"; + + // Round trip check: stream in, then stream back out to verify. The stream + // out has already been checked, above. We use the output + + istringstream inputStringStream( outputStream.str() ); + TiXmlDocument document0; + + inputStringStream >> document0; + + ostringstream outputStream0( ostringstream::out ); + outputStream0 << document0; + + XmlTest( "Stream round trip correct.", string( demoEnd ).c_str(), + outputStream0.str().c_str(), true ); + + std::string str; + str << document0; + + XmlTest( "String printing correct.", string( demoEnd ).c_str(), + str.c_str(), true ); + } + #endif + } + + { + const char* str = ""; + + TiXmlDocument doc; + doc.Parse( str ); + + TiXmlElement* ele = doc.FirstChildElement(); + + int iVal, result; + double dVal; + + result = ele->QueryDoubleAttribute( "attr0", &dVal ); + XmlTest( "Query attribute: int as double", result, TIXML_SUCCESS ); + XmlTest( "Query attribute: int as double", (int)dVal, 1 ); + result = ele->QueryDoubleAttribute( "attr1", &dVal ); + XmlTest( "Query attribute: double as double", (int)dVal, 2 ); + result = ele->QueryIntAttribute( "attr1", &iVal ); + XmlTest( "Query attribute: double as int", result, TIXML_SUCCESS ); + XmlTest( "Query attribute: double as int", iVal, 2 ); + result = ele->QueryIntAttribute( "attr2", &iVal ); + XmlTest( "Query attribute: not a number", result, TIXML_WRONG_TYPE ); + result = ele->QueryIntAttribute( "bar", &iVal ); + XmlTest( "Query attribute: does not exist", result, TIXML_NO_ATTRIBUTE ); + } + + { + const char* str = ""; + + TiXmlDocument doc; + doc.Parse( str ); + + TiXmlElement* ele = doc.FirstChildElement(); + + int iVal; + double dVal; + + ele->SetAttribute( "str", "strValue" ); + ele->SetAttribute( "int", 1 ); + ele->SetDoubleAttribute( "double", -1.0 ); + + const char* cStr = ele->Attribute( "str" ); + ele->QueryIntAttribute( "int", &iVal ); + ele->QueryDoubleAttribute( "double", &dVal ); + + XmlTest( "Attribute round trip. c-string.", "strValue", cStr ); + XmlTest( "Attribute round trip. int.", 1, iVal ); + XmlTest( "Attribute round trip. double.", -1, (int)dVal ); + } + + { + const char* str = "\t\t\n" + ""; + + TiXmlDocument doc; + doc.SetTabSize( 8 ); + doc.Parse( str ); + + TiXmlHandle docHandle( &doc ); + TiXmlHandle roomHandle = docHandle.FirstChildElement( "room" ); + + assert( docHandle.Node() ); + assert( roomHandle.Element() ); + + TiXmlElement* room = roomHandle.Element(); + assert( room ); + TiXmlAttribute* doors = room->FirstAttribute(); + assert( doors ); + + XmlTest( "Location tracking: Tab 8: room row", room->Row(), 1 ); + XmlTest( "Location tracking: Tab 8: room col", room->Column(), 49 ); + XmlTest( "Location tracking: Tab 8: doors row", doors->Row(), 1 ); + XmlTest( "Location tracking: Tab 8: doors col", doors->Column(), 55 ); + } + + { + const char* str = "\t\t\n" + " \n" + " A great door!\n" + "\t" + ""; + + TiXmlDocument doc; + doc.Parse( str ); + + TiXmlHandle docHandle( &doc ); + TiXmlHandle roomHandle = docHandle.FirstChildElement( "room" ); + TiXmlHandle commentHandle = docHandle.FirstChildElement( "room" ).FirstChild(); + TiXmlHandle textHandle = docHandle.FirstChildElement( "room" ).ChildElement( "door", 0 ).FirstChild(); + TiXmlHandle door0Handle = docHandle.FirstChildElement( "room" ).ChildElement( 0 ); + TiXmlHandle door1Handle = docHandle.FirstChildElement( "room" ).ChildElement( 1 ); + + assert( docHandle.Node() ); + assert( roomHandle.Element() ); + assert( commentHandle.Node() ); + assert( textHandle.Text() ); + assert( door0Handle.Element() ); + assert( door1Handle.Element() ); + + TiXmlDeclaration* declaration = doc.FirstChild()->ToDeclaration(); + assert( declaration ); + TiXmlElement* room = roomHandle.Element(); + assert( room ); + TiXmlAttribute* doors = room->FirstAttribute(); + assert( doors ); + TiXmlText* text = textHandle.Text(); + TiXmlComment* comment = commentHandle.Node()->ToComment(); + assert( comment ); + TiXmlElement* door0 = door0Handle.Element(); + TiXmlElement* door1 = door1Handle.Element(); + + XmlTest( "Location tracking: Declaration row", declaration->Row(), 1 ); + XmlTest( "Location tracking: Declaration col", declaration->Column(), 5 ); + XmlTest( "Location tracking: room row", room->Row(), 1 ); + XmlTest( "Location tracking: room col", room->Column(), 45 ); + XmlTest( "Location tracking: doors row", doors->Row(), 1 ); + XmlTest( "Location tracking: doors col", doors->Column(), 51 ); + XmlTest( "Location tracking: Comment row", comment->Row(), 2 ); + XmlTest( "Location tracking: Comment col", comment->Column(), 3 ); + XmlTest( "Location tracking: text row", text->Row(), 3 ); + XmlTest( "Location tracking: text col", text->Column(), 24 ); + XmlTest( "Location tracking: door0 row", door0->Row(), 3 ); + XmlTest( "Location tracking: door0 col", door0->Column(), 5 ); + XmlTest( "Location tracking: door1 row", door1->Row(), 4 ); + XmlTest( "Location tracking: door1 col", door1->Column(), 5 ); + } + + + // -------------------------------------------------------- + // UTF-8 testing. It is important to test: + // 1. Making sure name, value, and text read correctly + // 2. Row, Col functionality + // 3. Correct output + // -------------------------------------------------------- + printf ("\n** UTF-8 **\n"); + { + TiXmlDocument doc( "utf8test.xml" ); + doc.LoadFile(); + if ( doc.Error() && doc.ErrorId() == TiXmlBase::TIXML_ERROR_OPENING_FILE ) { + printf( "WARNING: File 'utf8test.xml' not found.\n" + "(Are you running the test from the wrong directory?)\n" + "Could not test UTF-8 functionality.\n" ); + } + else + { + TiXmlHandle docH( &doc ); + // Get the attribute "value" from the "Russian" element and check it. + TiXmlElement* element = docH.FirstChildElement( "document" ).FirstChildElement( "Russian" ).Element(); + const unsigned char correctValue[] = { 0xd1U, 0x86U, 0xd0U, 0xb5U, 0xd0U, 0xbdU, 0xd0U, 0xbdU, + 0xd0U, 0xbeU, 0xd1U, 0x81U, 0xd1U, 0x82U, 0xd1U, 0x8cU, 0 }; + + XmlTest( "UTF-8: Russian value.", (const char*)correctValue, element->Attribute( "value" ), true ); + XmlTest( "UTF-8: Russian value row.", 4, element->Row() ); + XmlTest( "UTF-8: Russian value column.", 5, element->Column() ); + + const unsigned char russianElementName[] = { 0xd0U, 0xa0U, 0xd1U, 0x83U, + 0xd1U, 0x81U, 0xd1U, 0x81U, + 0xd0U, 0xbaU, 0xd0U, 0xb8U, + 0xd0U, 0xb9U, 0 }; + const char russianText[] = "<\xD0\xB8\xD0\xBC\xD0\xB5\xD0\xB5\xD1\x82>"; + + TiXmlText* text = docH.FirstChildElement( "document" ).FirstChildElement( (const char*) russianElementName ).Child( 0 ).Text(); + XmlTest( "UTF-8: Browsing russian element name.", + russianText, + text->Value(), + true ); + XmlTest( "UTF-8: Russian element name row.", 7, text->Row() ); + XmlTest( "UTF-8: Russian element name column.", 47, text->Column() ); + + TiXmlDeclaration* dec = docH.Child( 0 ).Node()->ToDeclaration(); + XmlTest( "UTF-8: Declaration column.", 1, dec->Column() ); + XmlTest( "UTF-8: Document column.", 1, doc.Column() ); + + // Now try for a round trip. + doc.SaveFile( "utf8testout.xml" ); + + // Check the round trip. + char savedBuf[256]; + char verifyBuf[256]; + int okay = 1; + + FILE* saved = fopen( "utf8testout.xml", "r" ); + FILE* verify = fopen( "utf8testverify.xml", "r" ); + + //bool firstLineBOM=true; + if ( saved && verify ) + { + while ( fgets( verifyBuf, 256, verify ) ) + { + fgets( savedBuf, 256, saved ); + NullLineEndings( verifyBuf ); + NullLineEndings( savedBuf ); + + if ( /*!firstLineBOM && */ strcmp( verifyBuf, savedBuf ) ) + { + printf( "verify:%s<\n", verifyBuf ); + printf( "saved :%s<\n", savedBuf ); + okay = 0; + break; + } + //firstLineBOM = false; + } + } + if ( saved ) + fclose( saved ); + if ( verify ) + fclose( verify ); + XmlTest( "UTF-8: Verified multi-language round trip.", 1, okay ); + + // On most Western machines, this is an element that contains + // the word "resume" with the correct accents, in a latin encoding. + // It will be something else completely on non-wester machines, + // which is why TinyXml is switching to UTF-8. + const char latin[] = "r\x82sum\x82"; + + TiXmlDocument latinDoc; + latinDoc.Parse( latin, 0, TIXML_ENCODING_LEGACY ); + + text = latinDoc.FirstChildElement()->FirstChild()->ToText(); + XmlTest( "Legacy encoding: Verify text element.", "r\x82sum\x82", text->Value() ); + } + } + + ////////////////////// + // Copy and assignment + ////////////////////// + printf ("\n** Copy and Assignment **\n"); + { + TiXmlElement element( "foo" ); + element.Parse( "", 0, TIXML_ENCODING_UNKNOWN ); + + TiXmlElement elementCopy( element ); + TiXmlElement elementAssign( "foo" ); + elementAssign.Parse( "", 0, TIXML_ENCODING_UNKNOWN ); + elementAssign = element; + + XmlTest( "Copy/Assign: element copy #1.", "element", elementCopy.Value() ); + XmlTest( "Copy/Assign: element copy #2.", "value", elementCopy.Attribute( "name" ) ); + XmlTest( "Copy/Assign: element assign #1.", "element", elementAssign.Value() ); + XmlTest( "Copy/Assign: element assign #2.", "value", elementAssign.Attribute( "name" ) ); + XmlTest( "Copy/Assign: element assign #3.", true, ( 0 == elementAssign.Attribute( "foo" )) ); + + TiXmlComment comment; + comment.Parse( "", 0, TIXML_ENCODING_UNKNOWN ); + TiXmlComment commentCopy( comment ); + TiXmlComment commentAssign; + commentAssign = commentCopy; + XmlTest( "Copy/Assign: comment copy.", "comment", commentCopy.Value() ); + XmlTest( "Copy/Assign: comment assign.", "comment", commentAssign.Value() ); + + TiXmlUnknown unknown; + unknown.Parse( "<[unknown]>", 0, TIXML_ENCODING_UNKNOWN ); + TiXmlUnknown unknownCopy( unknown ); + TiXmlUnknown unknownAssign; + unknownAssign.Parse( "incorrect", 0, TIXML_ENCODING_UNKNOWN ); + unknownAssign = unknownCopy; + XmlTest( "Copy/Assign: unknown copy.", "[unknown]", unknownCopy.Value() ); + XmlTest( "Copy/Assign: unknown assign.", "[unknown]", unknownAssign.Value() ); + + TiXmlText text( "TextNode" ); + TiXmlText textCopy( text ); + TiXmlText textAssign( "incorrect" ); + textAssign = text; + XmlTest( "Copy/Assign: text copy.", "TextNode", textCopy.Value() ); + XmlTest( "Copy/Assign: text assign.", "TextNode", textAssign.Value() ); + + TiXmlDeclaration dec; + dec.Parse( "", 0, TIXML_ENCODING_UNKNOWN ); + TiXmlDeclaration decCopy( dec ); + TiXmlDeclaration decAssign; + decAssign = dec; + + XmlTest( "Copy/Assign: declaration copy.", "UTF-8", decCopy.Encoding() ); + XmlTest( "Copy/Assign: text assign.", "UTF-8", decAssign.Encoding() ); + + TiXmlDocument doc; + elementCopy.InsertEndChild( textCopy ); + doc.InsertEndChild( decAssign ); + doc.InsertEndChild( elementCopy ); + doc.InsertEndChild( unknownAssign ); + + TiXmlDocument docCopy( doc ); + TiXmlDocument docAssign; + docAssign = docCopy; + + #ifdef TIXML_USE_STL + std::string original, copy, assign; + original << doc; + copy << docCopy; + assign << docAssign; + XmlTest( "Copy/Assign: document copy.", original.c_str(), copy.c_str(), true ); + XmlTest( "Copy/Assign: document assign.", original.c_str(), assign.c_str(), true ); + + #endif + } + + ////////////////////////////////////////////////////// +#ifdef TIXML_USE_STL + printf ("\n** Parsing, no Condense Whitespace **\n"); + TiXmlBase::SetCondenseWhiteSpace( false ); + { + istringstream parse1( "This is \ntext" ); + TiXmlElement text1( "text" ); + parse1 >> text1; + + XmlTest ( "Condense white space OFF.", "This is \ntext", + text1.FirstChild()->Value(), + true ); + } + TiXmlBase::SetCondenseWhiteSpace( true ); +#endif + + ////////////////////////////////////////////////////// + // GetText(); + { + const char* str = "This is text"; + TiXmlDocument doc; + doc.Parse( str ); + const TiXmlElement* element = doc.RootElement(); + + XmlTest( "GetText() normal use.", "This is text", element->GetText() ); + + str = "This is text"; + doc.Clear(); + doc.Parse( str ); + element = doc.RootElement(); + + XmlTest( "GetText() contained element.", element->GetText() == 0, true ); + + str = "This is text"; + doc.Clear(); + TiXmlBase::SetCondenseWhiteSpace( false ); + doc.Parse( str ); + TiXmlBase::SetCondenseWhiteSpace( true ); + element = doc.RootElement(); + + XmlTest( "GetText() partial.", "This is ", element->GetText() ); + } + + + ////////////////////////////////////////////////////// + // CDATA + { + const char* str = "" + " the rules!\n" + "...since I make symbolic puns" + "]]>" + ""; + TiXmlDocument doc; + doc.Parse( str ); + doc.Print(); + + XmlTest( "CDATA parse.", doc.FirstChildElement()->FirstChild()->Value(), + "I am > the rules!\n...since I make symbolic puns", + true ); + + #ifdef TIXML_USE_STL + //cout << doc << '\n'; + + doc.Clear(); + + istringstream parse0( str ); + parse0 >> doc; + //cout << doc << '\n'; + + XmlTest( "CDATA stream.", doc.FirstChildElement()->FirstChild()->Value(), + "I am > the rules!\n...since I make symbolic puns", + true ); + #endif + + TiXmlDocument doc1 = doc; + //doc.Print(); + + XmlTest( "CDATA copy.", doc1.FirstChildElement()->FirstChild()->Value(), + "I am > the rules!\n...since I make symbolic puns", + true ); + } + { + // [ 1482728 ] Wrong wide char parsing + char buf[256]; + buf[255] = 0; + for( int i=0; i<255; ++i ) { + buf[i] = (char)((i>=32) ? i : 32); + } + TIXML_STRING str( ""; + + TiXmlDocument doc; + doc.Parse( str.c_str() ); + + TiXmlPrinter printer; + printer.SetStreamPrinting(); + doc.Accept( &printer ); + + XmlTest( "CDATA with all bytes #1.", str.c_str(), printer.CStr(), true ); + + #ifdef TIXML_USE_STL + doc.Clear(); + istringstream iss( printer.Str() ); + iss >> doc; + std::string out; + out << doc; + XmlTest( "CDATA with all bytes #2.", out.c_str(), printer.CStr(), true ); + #endif + } + { + // [ 1480107 ] Bug-fix for STL-streaming of CDATA that contains tags + // CDATA streaming had a couple of bugs, that this tests for. + const char* str = "" + "I am > the rules!\n" + "...since I make symbolic puns" + "]]>" + ""; + TiXmlDocument doc; + doc.Parse( str ); + doc.Print(); + + XmlTest( "CDATA parse. [ 1480107 ]", doc.FirstChildElement()->FirstChild()->Value(), + "I am > the rules!\n...since I make symbolic puns", + true ); + + #ifdef TIXML_USE_STL + + doc.Clear(); + + istringstream parse0( str ); + parse0 >> doc; + + XmlTest( "CDATA stream. [ 1480107 ]", doc.FirstChildElement()->FirstChild()->Value(), + "I am > the rules!\n...since I make symbolic puns", + true ); + #endif + + TiXmlDocument doc1 = doc; + //doc.Print(); + + XmlTest( "CDATA copy. [ 1480107 ]", doc1.FirstChildElement()->FirstChild()->Value(), + "I am > the rules!\n...since I make symbolic puns", + true ); + } + ////////////////////////////////////////////////////// + // Visit() + + + + ////////////////////////////////////////////////////// + printf( "\n** Fuzzing... **\n" ); + + const int FUZZ_ITERATION = 300; + + // The only goal is not to crash on bad input. + int len = (int) strlen( demoStart ); + for( int i=0; i" + "" + " " + ""; + + TiXmlDocument doc( "passages.xml" ); + doc.Parse( passages ); + TiXmlElement* psg = doc.RootElement()->FirstChildElement(); + const char* context = psg->Attribute( "context" ); + const char* expected = "Line 5 has \"quotation marks\" and 'apostrophe marks'. It also has <, >, and &, as well as a fake copyright \xC2\xA9."; + + XmlTest( "Entity transformation: read. ", expected, context, true ); + + FILE* textfile = fopen( "textfile.txt", "w" ); + if ( textfile ) + { + psg->Print( textfile, 0 ); + fclose( textfile ); + } + textfile = fopen( "textfile.txt", "r" ); + assert( textfile ); + if ( textfile ) + { + char buf[ 1024 ]; + fgets( buf, 1024, textfile ); + XmlTest( "Entity transformation: write. ", + "", + buf, + true ); + } + fclose( textfile ); + } + + { + FILE* textfile = fopen( "test5.xml", "w" ); + if ( textfile ) + { + fputs("", textfile); + fclose(textfile); + + TiXmlDocument doc; + doc.LoadFile( "test5.xml" ); + XmlTest( "dot in element attributes and names", doc.Error(), 0); + } + } + + { + FILE* textfile = fopen( "test6.xml", "w" ); + if ( textfile ) + { + fputs("1.1 Start easy ignore fin thickness ", textfile ); + fclose(textfile); + + TiXmlDocument doc; + bool result = doc.LoadFile( "test6.xml" ); + XmlTest( "Entity with one digit.", result, true ); + + TiXmlText* text = doc.FirstChildElement()->FirstChildElement()->FirstChild()->ToText(); + XmlTest( "Entity with one digit.", + text->Value(), "1.1 Start easy ignore fin thickness\n" ); + } + } + + { + // DOCTYPE not preserved (950171) + // + const char* doctype = + "" + "" + "" + "" + ""; + + TiXmlDocument doc; + doc.Parse( doctype ); + doc.SaveFile( "test7.xml" ); + doc.Clear(); + doc.LoadFile( "test7.xml" ); + + TiXmlHandle docH( &doc ); + TiXmlUnknown* unknown = docH.Child( 1 ).Unknown(); + XmlTest( "Correct value of unknown.", "!DOCTYPE PLAY SYSTEM 'play.dtd'", unknown->Value() ); + #ifdef TIXML_USE_STL + TiXmlNode* node = docH.Child( 2 ).Node(); + std::string str; + str << (*node); + XmlTest( "Correct streaming of unknown.", "", str.c_str() ); + #endif + } + + { + // [ 791411 ] Formatting bug + // Comments do not stream out correctly. + const char* doctype = + ""; + TiXmlDocument doc; + doc.Parse( doctype ); + + TiXmlHandle docH( &doc ); + TiXmlComment* comment = docH.Child( 0 ).Node()->ToComment(); + + XmlTest( "Comment formatting.", " Somewhat ", comment->Value() ); + #ifdef TIXML_USE_STL + std::string str; + str << (*comment); + XmlTest( "Comment streaming.", "", str.c_str() ); + #endif + } + + { + // [ 870502 ] White space issues + TiXmlDocument doc; + TiXmlText* text; + TiXmlHandle docH( &doc ); + + const char* doctype0 = " This has leading and trailing space "; + const char* doctype1 = "This has internal space"; + const char* doctype2 = " This has leading, trailing, and internal space "; + + TiXmlBase::SetCondenseWhiteSpace( false ); + doc.Clear(); + doc.Parse( doctype0 ); + text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); + XmlTest( "White space kept.", " This has leading and trailing space ", text->Value() ); + + doc.Clear(); + doc.Parse( doctype1 ); + text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); + XmlTest( "White space kept.", "This has internal space", text->Value() ); + + doc.Clear(); + doc.Parse( doctype2 ); + text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); + XmlTest( "White space kept.", " This has leading, trailing, and internal space ", text->Value() ); + + TiXmlBase::SetCondenseWhiteSpace( true ); + doc.Clear(); + doc.Parse( doctype0 ); + text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); + XmlTest( "White space condensed.", "This has leading and trailing space", text->Value() ); + + doc.Clear(); + doc.Parse( doctype1 ); + text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); + XmlTest( "White space condensed.", "This has internal space", text->Value() ); + + doc.Clear(); + doc.Parse( doctype2 ); + text = docH.FirstChildElement( "element" ).Child( 0 ).Text(); + XmlTest( "White space condensed.", "This has leading, trailing, and internal space", text->Value() ); + } + + { + // Double attributes + const char* doctype = ""; + + TiXmlDocument doc; + doc.Parse( doctype ); + + XmlTest( "Parsing repeated attributes.", true, doc.Error() ); // is an error to tinyxml (didn't use to be, but caused issues) + //XmlTest( "Parsing repeated attributes.", "blue", doc.FirstChildElement( "element" )->Attribute( "attr" ) ); + } + + { + // Embedded null in stream. + const char* doctype = ""; + + TiXmlDocument doc; + doc.Parse( doctype ); + XmlTest( "Embedded null throws error.", true, doc.Error() ); + + #ifdef TIXML_USE_STL + istringstream strm( doctype ); + doc.Clear(); + doc.ClearError(); + strm >> doc; + XmlTest( "Embedded null throws error.", true, doc.Error() ); + #endif + } + + { + // Legacy mode test. (This test may only pass on a western system) + const char* str = + "" + "<ä>" + "CöntäntßäöüÄÖÜ" + ""; + + TiXmlDocument doc; + doc.Parse( str ); + + TiXmlHandle docHandle( &doc ); + TiXmlHandle aHandle = docHandle.FirstChildElement( "ä" ); + TiXmlHandle tHandle = aHandle.Child( 0 ); + assert( aHandle.Element() ); + assert( tHandle.Text() ); + XmlTest( "ISO-8859-1 Parsing.", "CöntäntßäöüÄÖÜ", tHandle.Text()->Value() ); + } + + { + // Empty documents should return TIXML_ERROR_PARSING_EMPTY, bug 1070717 + const char* str = " "; + TiXmlDocument doc; + doc.Parse( str ); + XmlTest( "Empty document error TIXML_ERROR_DOCUMENT_EMPTY", TiXmlBase::TIXML_ERROR_DOCUMENT_EMPTY, doc.ErrorId() ); + } + #ifndef TIXML_USE_STL + { + // String equality. [ 1006409 ] string operator==/!= no worky in all cases + TiXmlString temp; + XmlTest( "Empty tinyxml string compare equal", ( temp == "" ), true ); + + TiXmlString foo; + TiXmlString bar( "" ); + XmlTest( "Empty tinyxml string compare equal", ( foo == bar ), true ); + } + + #endif + { + // Bug [ 1195696 ] from marlonism + TiXmlBase::SetCondenseWhiteSpace(false); + TiXmlDocument xml; + xml.Parse("This hangs"); + XmlTest( "Test safe error return.", xml.Error(), false ); + } + + { + // Bug [ 1243992 ] - another infinite loop + TiXmlDocument doc; + doc.SetCondenseWhiteSpace(false); + doc.Parse("

test

"); + } + { + // Low entities + TiXmlDocument xml; + xml.Parse( "" ); + const char result[] = { 0x0e, 0 }; + XmlTest( "Low entities.", xml.FirstChildElement()->GetText(), result ); + xml.Print(); + } + { + // Bug [ 1451649 ] Attribute values with trailing quotes not handled correctly + TiXmlDocument xml; + xml.Parse( "" ); + XmlTest( "Throw error with bad end quotes.", xml.Error(), true ); + } + #ifdef TIXML_USE_STL + { + // Bug [ 1449463 ] Consider generic query + TiXmlDocument xml; + xml.Parse( "" ); + + TiXmlElement* ele = xml.FirstChildElement(); + double d; + int i; + float f; + bool b; + std::string str; + + XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &d ), TIXML_SUCCESS ); + XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &i ), TIXML_SUCCESS ); + XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &f ), TIXML_SUCCESS ); + XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "bar", &b ), TIXML_WRONG_TYPE ); + XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "nobar", &b ), TIXML_NO_ATTRIBUTE ); + XmlTest( "QueryValueAttribute", ele->QueryValueAttribute( "barStr", &str ), TIXML_SUCCESS ); + + XmlTest( "QueryValueAttribute", (d==3.0), true ); + XmlTest( "QueryValueAttribute", (i==3), true ); + XmlTest( "QueryValueAttribute", (f==3.0f), true ); + XmlTest( "QueryValueAttribute", (str==std::string( "a string" )), true ); + } + #endif + + #ifdef TIXML_USE_STL + { + // [ 1505267 ] redundant malloc in TiXmlElement::Attribute + TiXmlDocument xml; + xml.Parse( "" ); + TiXmlElement* ele = xml.FirstChildElement(); + double d; + int i; + + std::string bar = "bar"; + + const std::string* atrrib = ele->Attribute( bar ); + ele->Attribute( bar, &d ); + ele->Attribute( bar, &i ); + + XmlTest( "Attribute", atrrib->empty(), false ); + XmlTest( "Attribute", (d==3.0), true ); + XmlTest( "Attribute", (i==3), true ); + } + #endif + + { + // [ 1356059 ] Allow TiXMLDocument to only be at the top level + TiXmlDocument xml, xml2; + xml.InsertEndChild( xml2 ); + XmlTest( "Document only at top level.", xml.Error(), true ); + XmlTest( "Document only at top level.", xml.ErrorId(), TiXmlBase::TIXML_ERROR_DOCUMENT_TOP_ONLY ); + } + + { + // [ 1663758 ] Failure to report error on bad XML + TiXmlDocument xml; + xml.Parse(""); + XmlTest("Missing end tag at end of input", xml.Error(), true); + xml.Parse(" "); + XmlTest("Missing end tag with trailing whitespace", xml.Error(), true); + } + + { + // [ 1635701 ] fail to parse files with a tag separated into two lines + // I'm not sure this is a bug. Marked 'pending' for feedback. + TiXmlDocument xml; + xml.Parse( "<p>text</p\n><title>" ); + //xml.Print(); + //XmlTest( "Tag split by newline", xml.Error(), false ); + } + + #ifdef TIXML_USE_STL + { + // [ 1475201 ] TinyXML parses entities in comments + TiXmlDocument xml; + istringstream parse1( "" + "" ); + parse1 >> xml; + + TiXmlNode* e0 = xml.FirstChild(); + TiXmlNode* e1 = e0->NextSibling(); + TiXmlComment* c0 = e0->ToComment(); + TiXmlComment* c1 = e1->ToComment(); + + XmlTest( "Comments ignore entities.", " declarations for <head> & <body> ", c0->Value(), true ); + XmlTest( "Comments ignore entities.", " far & away ", c1->Value(), true ); + } + #endif + + { + // [ 1475201 ] TinyXML parses entities in comments + TiXmlDocument xml; + xml.Parse("" + "" ); + + TiXmlNode* e0 = xml.FirstChild(); + TiXmlNode* e1 = e0->NextSibling(); + TiXmlComment* c0 = e0->ToComment(); + TiXmlComment* c1 = e1->ToComment(); + + XmlTest( "Comments ignore entities.", " declarations for <head> & <body> ", c0->Value(), true ); + XmlTest( "Comments ignore entities.", " far & away ", c1->Value(), true ); + } + + { + TiXmlDocument xml; + xml.Parse( "<Parent>" + "<child1 att=''/>" + "" + "<child2 att=''/>" + "</Parent>" ); + int count = 0; + + TiXmlNode* ele = 0; + while ( (ele = xml.FirstChildElement( "Parent" )->IterateChildren( ele ) ) != 0 ) { + ++count; + } + XmlTest( "Comments iterate correctly.", 3, count ); + } + + { + // trying to repro ]1874301]. If it doesn't go into an infinite loop, all is well. + unsigned char buf[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?><feed><![CDATA[Test XMLblablablalblbl"; + buf[60] = 239; + buf[61] = 0; + + TiXmlDocument doc; + doc.Parse( (const char*)buf); + } + + + { + // bug 1827248 Error while parsing a little bit malformed file + // Actually not malformed - should work. + TiXmlDocument xml; + xml.Parse( "<attributelist> </attributelist >" ); + XmlTest( "Handle end tag whitespace", false, xml.Error() ); + } + + { + // This one must not result in an infinite loop + TiXmlDocument xml; + xml.Parse( "<infinite>loop" ); + XmlTest( "Infinite loop test.", true, true ); + } + + { + // 1709904 - can not repro the crash + { + TiXmlDocument xml; + xml.Parse( "<tag>/</tag>" ); + XmlTest( "Odd XML parsing.", xml.FirstChild()->Value(), "tag" ); + } + /* Could not repro. { + TiXmlDocument xml; + xml.LoadFile( "EQUI_Inventory.xml" ); + //XmlTest( "Odd XML parsing.", xml.FirstChildElement()->Value(), "XML" ); + TiXmlPrinter printer; + xml.Accept( &printer ); + fprintf( stdout, "%s", printer.CStr() ); + }*/ + } + + /* 1417717 experiment + { + TiXmlDocument xml; + xml.Parse("<text>Dan & Tracie</text>"); + xml.Print(stdout); + } + { + TiXmlDocument xml; + xml.Parse("<text>Dan &foo; Tracie</text>"); + xml.Print(stdout); + } + */ + + #if defined( WIN32 ) && defined( TUNE ) + _CrtMemCheckpoint( &endMemState ); + //_CrtMemDumpStatistics( &endMemState ); + + _CrtMemState diffMemState; + _CrtMemDifference( &diffMemState, &startMemState, &endMemState ); + _CrtMemDumpStatistics( &diffMemState ); + #endif + + printf ("\nPass %d, Fail %d\n", gPass, gFail); + return gFail; +} Index: /branches/fep_rpc_client/tinyxml/tinyxmlparser.cpp =================================================================== --- /branches/fep_rpc_client/tinyxml/tinyxmlparser.cpp (revision 79) +++ /branches/fep_rpc_client/tinyxml/tinyxmlparser.cpp (revision 79) @@ -0,0 +1,1638 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code by Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + +#include <ctype.h> +#include <stddef.h> + +#include "tinyxml.h" + +//#define DEBUG_PARSER +#if defined( DEBUG_PARSER ) +# if defined( DEBUG ) && defined( _MSC_VER ) +# include <windows.h> +# define TIXML_LOG OutputDebugString +# else +# define TIXML_LOG printf +# endif +#endif + +// Note tha "PutString" hardcodes the same list. This +// is less flexible than it appears. Changing the entries +// or order will break putstring. +TiXmlBase::Entity TiXmlBase::entity[ TiXmlBase::NUM_ENTITY ] = +{ + { "&", 5, '&' }, + { "<", 4, '<' }, + { ">", 4, '>' }, + { """, 6, '\"' }, + { "'", 6, '\'' } +}; + +// Bunch of unicode info at: +// http://www.unicode.org/faq/utf_bom.html +// Including the basic of this table, which determines the #bytes in the +// sequence from the lead byte. 1 placed for invalid sequences -- +// although the result will be junk, pass it through as much as possible. +// Beware of the non-characters in UTF-8: +// ef bb bf (Microsoft "lead bytes") +// ef bf be +// ef bf bf + +const unsigned char TIXML_UTF_LEAD_0 = 0xefU; +const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; +const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; + +const int TiXmlBase::utf8ByteTable[256] = +{ + // 0 1 2 3 4 5 6 7 8 9 a b c d e f + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x00 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x10 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x30 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x50 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x70 End of ASCII range + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x80 0x80 to 0xc1 invalid + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x90 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xa0 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xb0 + 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xc0 0xc2 to 0xdf 2 byte + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xd0 + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xe0 0xe0 to 0xef 3 byte + 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid +}; + + +void TiXmlBase::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length ) +{ + const unsigned long BYTE_MASK = 0xBF; + const unsigned long BYTE_MARK = 0x80; + const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; + + if (input < 0x80) + *length = 1; + else if ( input < 0x800 ) + *length = 2; + else if ( input < 0x10000 ) + *length = 3; + else if ( input < 0x200000 ) + *length = 4; + else + { *length = 0; return; } // This code won't covert this correctly anyway. + + output += *length; + + // Scary scary fall throughs. + switch (*length) + { + case 4: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 3: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 2: + --output; + *output = (char)((input | BYTE_MARK) & BYTE_MASK); + input >>= 6; + case 1: + --output; + *output = (char)(input | FIRST_BYTE_MARK[*length]); + } +} + + +/*static*/ int TiXmlBase::IsAlpha( unsigned char anyByte, TiXmlEncoding /*encoding*/ ) +{ + // This will only work for low-ascii, everything else is assumed to be a valid + // letter. I'm not sure this is the best approach, but it is quite tricky trying + // to figure out alhabetical vs. not across encoding. So take a very + // conservative approach. + +// if ( encoding == TIXML_ENCODING_UTF8 ) +// { + if ( anyByte < 127 ) + return isalpha( anyByte ); + else + return 1; // What else to do? The unicode set is huge...get the english ones right. +// } +// else +// { +// return isalpha( anyByte ); +// } +} + + +/*static*/ int TiXmlBase::IsAlphaNum( unsigned char anyByte, TiXmlEncoding /*encoding*/ ) +{ + // This will only work for low-ascii, everything else is assumed to be a valid + // letter. I'm not sure this is the best approach, but it is quite tricky trying + // to figure out alhabetical vs. not across encoding. So take a very + // conservative approach. + +// if ( encoding == TIXML_ENCODING_UTF8 ) +// { + if ( anyByte < 127 ) + return isalnum( anyByte ); + else + return 1; // What else to do? The unicode set is huge...get the english ones right. +// } +// else +// { +// return isalnum( anyByte ); +// } +} + + +class TiXmlParsingData +{ + friend class TiXmlDocument; + public: + void Stamp( const char* now, TiXmlEncoding encoding ); + + const TiXmlCursor& Cursor() const { return cursor; } + + private: + // Only used by the document! + TiXmlParsingData( const char* start, int _tabsize, int row, int col ) + { + assert( start ); + stamp = start; + tabsize = _tabsize; + cursor.row = row; + cursor.col = col; + } + + TiXmlCursor cursor; + const char* stamp; + int tabsize; +}; + + +void TiXmlParsingData::Stamp( const char* now, TiXmlEncoding encoding ) +{ + assert( now ); + + // Do nothing if the tabsize is 0. + if ( tabsize < 1 ) + { + return; + } + + // Get the current row, column. + int row = cursor.row; + int col = cursor.col; + const char* p = stamp; + assert( p ); + + while ( p < now ) + { + // Treat p as unsigned, so we have a happy compiler. + const unsigned char* pU = (const unsigned char*)p; + + // Code contributed by Fletcher Dunn: (modified by lee) + switch (*pU) { + case 0: + // We *should* never get here, but in case we do, don't + // advance past the terminating null character, ever + return; + + case '\r': + // bump down to the next line + ++row; + col = 0; + // Eat the character + ++p; + + // Check for \r\n sequence, and treat this as a single character + if (*p == '\n') { + ++p; + } + break; + + case '\n': + // bump down to the next line + ++row; + col = 0; + + // Eat the character + ++p; + + // Check for \n\r sequence, and treat this as a single + // character. (Yes, this bizarre thing does occur still + // on some arcane platforms...) + if (*p == '\r') { + ++p; + } + break; + + case '\t': + // Eat the character + ++p; + + // Skip to next tab stop + col = (col / tabsize + 1) * tabsize; + break; + + case TIXML_UTF_LEAD_0: + if ( encoding == TIXML_ENCODING_UTF8 ) + { + if ( *(p+1) && *(p+2) ) + { + // In these cases, don't advance the column. These are + // 0-width spaces. + if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 ) + p += 3; + else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU ) + p += 3; + else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU ) + p += 3; + else + { p +=3; ++col; } // A normal character. + } + } + else + { + ++p; + ++col; + } + break; + + default: + if ( encoding == TIXML_ENCODING_UTF8 ) + { + // Eat the 1 to 4 byte utf8 character. + int step = TiXmlBase::utf8ByteTable[*((const unsigned char*)p)]; + if ( step == 0 ) + step = 1; // Error case from bad encoding, but handle gracefully. + p += step; + + // Just advance one column, of course. + ++col; + } + else + { + ++p; + ++col; + } + break; + } + } + cursor.row = row; + cursor.col = col; + assert( cursor.row >= -1 ); + assert( cursor.col >= -1 ); + stamp = p; + assert( stamp ); +} + + +const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding ) +{ + if ( !p || !*p ) + { + return 0; + } + if ( encoding == TIXML_ENCODING_UTF8 ) + { + while ( *p ) + { + const unsigned char* pU = (const unsigned char*)p; + + // Skip the stupid Microsoft UTF-8 Byte order marks + if ( *(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==TIXML_UTF_LEAD_1 + && *(pU+2)==TIXML_UTF_LEAD_2 ) + { + p += 3; + continue; + } + else if(*(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==0xbfU + && *(pU+2)==0xbeU ) + { + p += 3; + continue; + } + else if(*(pU+0)==TIXML_UTF_LEAD_0 + && *(pU+1)==0xbfU + && *(pU+2)==0xbfU ) + { + p += 3; + continue; + } + + if ( IsWhiteSpace( *p ) ) // Still using old rules for white space. + ++p; + else + break; + } + } + else + { + while ( *p && IsWhiteSpace( *p ) ) + ++p; + } + + return p; +} + +#ifdef TIXML_USE_STL +/*static*/ bool TiXmlBase::StreamWhiteSpace( std::istream * in, TIXML_STRING * tag ) +{ + for( ;; ) + { + if ( !in->good() ) return false; + + int c = in->peek(); + // At this scope, we can't get to a document. So fail silently. + if ( !IsWhiteSpace( c ) || c <= 0 ) + return true; + + *tag += (char) in->get(); + } +} + +/*static*/ bool TiXmlBase::StreamTo( std::istream * in, int character, TIXML_STRING * tag ) +{ + //assert( character > 0 && character < 128 ); // else it won't work in utf-8 + while ( in->good() ) + { + int c = in->peek(); + if ( c == character ) + return true; + if ( c <= 0 ) // Silent failure: can't get document at this scope + return false; + + in->get(); + *tag += (char) c; + } + return false; +} +#endif + +// One of TinyXML's more performance demanding functions. Try to keep the memory overhead down. The +// "assign" optimization removes over 10% of the execution time. +// +const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding ) +{ + // Oddly, not supported on some comilers, + //name->clear(); + // So use this: + *name = ""; + assert( p ); + + // Names start with letters or underscores. + // Of course, in unicode, tinyxml has no idea what a letter *is*. The + // algorithm is generous. + // + // After that, they can be letters, underscores, numbers, + // hyphens, or colons. (Colons are valid ony for namespaces, + // but tinyxml can't tell namespaces from names.) + if ( p && *p + && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) ) + { + const char* start = p; + while( p && *p + && ( IsAlphaNum( (unsigned char ) *p, encoding ) + || *p == '_' + || *p == '-' + || *p == '.' + || *p == ':' ) ) + { + //(*name) += *p; // expensive + ++p; + } + if ( p-start > 0 ) { + name->assign( start, p-start ); + } + return p; + } + return 0; +} + +const char* TiXmlBase::GetEntity( const char* p, char* value, int* length, TiXmlEncoding encoding ) +{ + // Presume an entity, and pull it out. + TIXML_STRING ent; + int i; + *length = 0; + + if ( *(p+1) && *(p+1) == '#' && *(p+2) ) + { + unsigned long ucs = 0; + ptrdiff_t delta = 0; + unsigned mult = 1; + + if ( *(p+2) == 'x' ) + { + // Hexadecimal. + if ( !*(p+3) ) return 0; + + const char* q = p+3; + q = strchr( q, ';' ); + + if ( !q || !*q ) return 0; + + delta = q-p; + --q; + + while ( *q != 'x' ) + { + if ( *q >= '0' && *q <= '9' ) + ucs += mult * (*q - '0'); + else if ( *q >= 'a' && *q <= 'f' ) + ucs += mult * (*q - 'a' + 10); + else if ( *q >= 'A' && *q <= 'F' ) + ucs += mult * (*q - 'A' + 10 ); + else + return 0; + mult *= 16; + --q; + } + } + else + { + // Decimal. + if ( !*(p+2) ) return 0; + + const char* q = p+2; + q = strchr( q, ';' ); + + if ( !q || !*q ) return 0; + + delta = q-p; + --q; + + while ( *q != '#' ) + { + if ( *q >= '0' && *q <= '9' ) + ucs += mult * (*q - '0'); + else + return 0; + mult *= 10; + --q; + } + } + if ( encoding == TIXML_ENCODING_UTF8 ) + { + // convert the UCS to UTF-8 + ConvertUTF32ToUTF8( ucs, value, length ); + } + else + { + *value = (char)ucs; + *length = 1; + } + return p + delta + 1; + } + + // Now try to match it. + for( i=0; i<NUM_ENTITY; ++i ) + { + if ( strncmp( entity[i].str, p, entity[i].strLength ) == 0 ) + { + assert( strlen( entity[i].str ) == entity[i].strLength ); + *value = entity[i].chr; + *length = 1; + return ( p + entity[i].strLength ); + } + } + + // So it wasn't an entity, its unrecognized, or something like that. + *value = *p; // Don't put back the last one, since we return it! + //*length = 1; // Leave unrecognized entities - this doesn't really work. + // Just writes strange XML. + return p+1; +} + + +bool TiXmlBase::StringEqual( const char* p, + const char* tag, + bool ignoreCase, + TiXmlEncoding encoding ) +{ + assert( p ); + assert( tag ); + if ( !p || !*p ) + { + assert( 0 ); + return false; + } + + const char* q = p; + + if ( ignoreCase ) + { + while ( *q && *tag && ToLower( *q, encoding ) == ToLower( *tag, encoding ) ) + { + ++q; + ++tag; + } + + if ( *tag == 0 ) + return true; + } + else + { + while ( *q && *tag && *q == *tag ) + { + ++q; + ++tag; + } + + if ( *tag == 0 ) // Have we found the end of the tag, and everything equal? + return true; + } + return false; +} + +const char* TiXmlBase::ReadText( const char* p, + TIXML_STRING * text, + bool trimWhiteSpace, + const char* endTag, + bool caseInsensitive, + TiXmlEncoding encoding ) +{ + *text = ""; + if ( !trimWhiteSpace // certain tags always keep whitespace + || !condenseWhiteSpace ) // if true, whitespace is always kept + { + // Keep all the white space. + while ( p && *p + && !StringEqual( p, endTag, caseInsensitive, encoding ) + ) + { + int len; + char cArr[4] = { 0, 0, 0, 0 }; + p = GetChar( p, cArr, &len, encoding ); + text->append( cArr, len ); + } + } + else + { + bool whitespace = false; + + // Remove leading white space: + p = SkipWhiteSpace( p, encoding ); + while ( p && *p + && !StringEqual( p, endTag, caseInsensitive, encoding ) ) + { + if ( *p == '\r' || *p == '\n' ) + { + whitespace = true; + ++p; + } + else if ( IsWhiteSpace( *p ) ) + { + whitespace = true; + ++p; + } + else + { + // If we've found whitespace, add it before the + // new character. Any whitespace just becomes a space. + if ( whitespace ) + { + (*text) += ' '; + whitespace = false; + } + int len; + char cArr[4] = { 0, 0, 0, 0 }; + p = GetChar( p, cArr, &len, encoding ); + if ( len == 1 ) + (*text) += cArr[0]; // more efficient + else + text->append( cArr, len ); + } + } + } + if ( p && *p ) + p += strlen( endTag ); + return ( p && *p ) ? p : 0; +} + +#ifdef TIXML_USE_STL + +void TiXmlDocument::StreamIn( std::istream * in, TIXML_STRING * tag ) +{ + // The basic issue with a document is that we don't know what we're + // streaming. Read something presumed to be a tag (and hope), then + // identify it, and call the appropriate stream method on the tag. + // + // This "pre-streaming" will never read the closing ">" so the + // sub-tag can orient itself. + + if ( !StreamTo( in, '<', tag ) ) + { + SetError( TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + + while ( in->good() ) + { + int tagIndex = (int) tag->length(); + while ( in->good() && in->peek() != '>' ) + { + int c = in->get(); + if ( c <= 0 ) + { + SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); + break; + } + (*tag) += (char) c; + } + + if ( in->good() ) + { + // We now have something we presume to be a node of + // some sort. Identify it, and call the node to + // continue streaming. + TiXmlNode* node = Identify( tag->c_str() + tagIndex, TIXML_DEFAULT_ENCODING ); + + if ( node ) + { + node->StreamIn( in, tag ); + bool isElement = node->ToElement() != 0; + delete node; + node = 0; + + // If this is the root element, we're done. Parsing will be + // done by the >> operator. + if ( isElement ) + { + return; + } + } + else + { + SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + } + } + // We should have returned sooner. + SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN ); +} + +#endif + +const char* TiXmlDocument::Parse( const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding ) +{ + ClearError(); + + // Parse away, at the document level. Since a document + // contains nothing but other tags, most of what happens + // here is skipping white space. + if ( !p || !*p ) + { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + // Note that, for a document, this needs to come + // before the while space skip, so that parsing + // starts from the pointer we are given. + location.Clear(); + if ( prevData ) + { + location.row = prevData->cursor.row; + location.col = prevData->cursor.col; + } + else + { + location.row = 0; + location.col = 0; + } + TiXmlParsingData data( p, TabSize(), location.row, location.col ); + location = data.Cursor(); + + if ( encoding == TIXML_ENCODING_UNKNOWN ) + { + // Check for the Microsoft UTF-8 lead bytes. + const unsigned char* pU = (const unsigned char*)p; + if ( *(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0 + && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1 + && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 ) + { + encoding = TIXML_ENCODING_UTF8; + useMicrosoftBOM = true; + } + } + + p = SkipWhiteSpace( p, encoding ); + if ( !p ) + { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + while ( p && *p ) + { + TiXmlNode* node = Identify( p, encoding ); + if ( node ) + { + p = node->Parse( p, &data, encoding ); + LinkEndChild( node ); + } + else + { + break; + } + + // Did we get encoding info? + if ( encoding == TIXML_ENCODING_UNKNOWN + && node->ToDeclaration() ) + { + TiXmlDeclaration* dec = node->ToDeclaration(); + const char* enc = dec->Encoding(); + assert( enc ); + + if ( *enc == 0 ) + encoding = TIXML_ENCODING_UTF8; + else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) ) + encoding = TIXML_ENCODING_UTF8; + else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) ) + encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice + else + encoding = TIXML_ENCODING_LEGACY; + } + + p = SkipWhiteSpace( p, encoding ); + } + + // Was this empty? + if ( !firstChild ) { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding ); + return 0; + } + + // All is well. + return p; +} + +void TiXmlDocument::SetError( int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding ) +{ + // The first error in a chain is more accurate - don't set again! + if ( error ) + return; + + assert( err > 0 && err < TIXML_ERROR_STRING_COUNT ); + error = true; + errorId = err; + errorDesc = errorString[ errorId ]; + + errorLocation.Clear(); + if ( pError && data ) + { + data->Stamp( pError, encoding ); + errorLocation = data->Cursor(); + } +} + + +TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding ) +{ + TiXmlNode* returnNode = 0; + + p = SkipWhiteSpace( p, encoding ); + if( !p || !*p || *p != '<' ) + { + return 0; + } + + p = SkipWhiteSpace( p, encoding ); + + if ( !p || !*p ) + { + return 0; + } + + // What is this thing? + // - Elements start with a letter or underscore, but xml is reserved. + // - Comments: "; + + if ( !StringEqual( p, startTag, false, encoding ) ) + { + if ( document ) + document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding ); + return 0; + } + p += strlen( startTag ); + + // [ 1475201 ] TinyXML parses entities in comments + // Oops - ReadText doesn't work, because we don't want to parse the entities. + // p = ReadText( p, &value, false, endTag, false, encoding ); + // + // from the XML spec: + /* + [Definition: Comments may appear anywhere in a document outside other markup; in addition, + they may appear within the document type declaration at places allowed by the grammar. + They are not part of the document's character data; an XML processor MAY, but need not, + make it possible for an application to retrieve the text of comments. For compatibility, + the string "--" (double-hyphen) MUST NOT occur within comments.] Parameter entity + references MUST NOT be recognized within comments. + + An example of a comment: + +  + */ + + value = ""; + // Keep all the white space. + while ( p && *p && !StringEqual( p, endTag, false, encoding ) ) + { + value.append( p, 1 ); + ++p; + } + if ( p && *p ) + p += strlen( endTag ); + + return p; +} + + +const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) +{ + p = SkipWhiteSpace( p, encoding ); + if ( !p || !*p ) return 0; + + if ( data ) + { + data->Stamp( p, encoding ); + location = data->Cursor(); + } + // Read the name, the '=' and the value. + const char* pErr = p; + p = ReadName( p, &name, encoding ); + if ( !p || !*p ) + { + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding ); + return 0; + } + p = SkipWhiteSpace( p, encoding ); + if ( !p || !*p || *p != '=' ) + { + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); + return 0; + } + + ++p; // skip '=' + p = SkipWhiteSpace( p, encoding ); + if ( !p || !*p ) + { + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); + return 0; + } + + const char* end; + const char SINGLE_QUOTE = '\''; + const char DOUBLE_QUOTE = '\"'; + + if ( *p == SINGLE_QUOTE ) + { + ++p; + end = "\'"; // single quote in string + p = ReadText( p, &value, false, end, false, encoding ); + } + else if ( *p == DOUBLE_QUOTE ) + { + ++p; + end = "\""; // double quote in string + p = ReadText( p, &value, false, end, false, encoding ); + } + else + { + // All attribute values should be in single or double quotes. + // But this is such a common error that the parser will try + // its best, even without them. + value = ""; + while ( p && *p // existence + && !IsWhiteSpace( *p ) // whitespace + && *p != '/' && *p != '>' ) // tag end + { + if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) { + // [ 1451649 ] Attribute values with trailing quotes not handled correctly + // We did not have an opening quote but seem to have a + // closing one. Give up and throw an error. + if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); + return 0; + } + value += *p; + ++p; + } + } + return p; +} + +#ifdef TIXML_USE_STL +void TiXmlText::StreamIn( std::istream * in, TIXML_STRING * tag ) +{ + while ( in->good() ) + { + int c = in->peek(); + if ( !cdata && (c == '<' ) ) + { + return; + } + if ( c <= 0 ) + { + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + + (*tag) += (char) c; + in->get(); // "commits" the peek made above + + if ( cdata && c == '>' && tag->size() >= 3 ) { + size_t len = tag->size(); + if ( (*tag)[len-2] == ']' && (*tag)[len-3] == ']' ) { + // terminator of cdata. + return; + } + } + } +} +#endif + +const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) +{ + value = ""; + TiXmlDocument* document = GetDocument(); + + if ( data ) + { + data->Stamp( p, encoding ); + location = data->Cursor(); + } + + const char* const startTag = "<![CDATA["; + const char* const endTag = "]]>"; + + if ( cdata || StringEqual( p, startTag, false, encoding ) ) + { + cdata = true; + + if ( !StringEqual( p, startTag, false, encoding ) ) + { + if ( document ) + document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding ); + return 0; + } + p += strlen( startTag ); + + // Keep all the white space, ignore the encoding, etc. + while ( p && *p + && !StringEqual( p, endTag, false, encoding ) + ) + { + value += *p; + ++p; + } + + TIXML_STRING dummy; + p = ReadText( p, &dummy, false, endTag, false, encoding ); + return p; + } + else + { + bool ignoreWhite = true; + + const char* end = "<"; + p = ReadText( p, &value, ignoreWhite, end, false, encoding ); + if ( p && *p ) + return p-1; // don't truncate the '<' + return 0; + } +} + +#ifdef TIXML_USE_STL +void TiXmlDeclaration::StreamIn( std::istream * in, TIXML_STRING * tag ) +{ + while ( in->good() ) + { + int c = in->get(); + if ( c <= 0 ) + { + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); + return; + } + (*tag) += (char) c; + + if ( c == '>' ) + { + // All is well. + return; + } + } +} +#endif + +const char* TiXmlDeclaration::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding _encoding ) +{ + p = SkipWhiteSpace( p, _encoding ); + // Find the beginning, find the end, and look for + // the stuff in-between. + TiXmlDocument* document = GetDocument(); + if ( !p || !*p || !StringEqual( p, "<?xml", true, _encoding ) ) + { + if ( document ) document->SetError( TIXML_ERROR_PARSING_DECLARATION, 0, 0, _encoding ); + return 0; + } + if ( data ) + { + data->Stamp( p, _encoding ); + location = data->Cursor(); + } + p += 5; + + version = ""; + encoding = ""; + standalone = ""; + + while ( p && *p ) + { + if ( *p == '>' ) + { + ++p; + return p; + } + + p = SkipWhiteSpace( p, _encoding ); + if ( StringEqual( p, "version", true, _encoding ) ) + { + TiXmlAttribute attrib; + p = attrib.Parse( p, data, _encoding ); + version = attrib.Value(); + } + else if ( StringEqual( p, "encoding", true, _encoding ) ) + { + TiXmlAttribute attrib; + p = attrib.Parse( p, data, _encoding ); + encoding = attrib.Value(); + } + else if ( StringEqual( p, "standalone", true, _encoding ) ) + { + TiXmlAttribute attrib; + p = attrib.Parse( p, data, _encoding ); + standalone = attrib.Value(); + } + else + { + // Read over whatever it is. + while( p && *p && *p != '>' && !IsWhiteSpace( *p ) ) + ++p; + } + } + return 0; +} + +bool TiXmlText::Blank() const +{ + for ( unsigned i=0; i<value.length(); i++ ) + if ( !IsWhiteSpace( value[i] ) ) + return false; + return true; +} + Index: /branches/fep_rpc_client/tinyxml/tinyxml.cpp =================================================================== --- /branches/fep_rpc_client/tinyxml/tinyxml.cpp (revision 79) +++ /branches/fep_rpc_client/tinyxml/tinyxml.cpp (revision 79) @@ -0,0 +1,1886 @@ +/* +www.sourceforge.net/projects/tinyxml +Original code by Lee Thomason (www.grinninglizard.com) + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + +#include <ctype.h> + +#ifdef TIXML_USE_STL +#include <sstream> +#include <iostream> +#endif + +#include "tinyxml.h" + +FILE* TiXmlFOpen( const char* filename, const char* mode ); + +bool TiXmlBase::condenseWhiteSpace = true; + +// Microsoft compiler security +FILE* TiXmlFOpen( const char* filename, const char* mode ) +{ + #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) + FILE* fp = 0; + errno_t err = fopen_s( &fp, filename, mode ); + if ( !err && fp ) + return fp; + return 0; + #else + return fopen( filename, mode ); + #endif +} + +void TiXmlBase::EncodeString( const TIXML_STRING& str, TIXML_STRING* outString ) +{ + int i=0; + + while( i<(int)str.length() ) + { + unsigned char c = (unsigned char) str[i]; + + if ( c == '&' + && i < ( (int)str.length() - 2 ) + && str[i+1] == '#' + && str[i+2] == 'x' ) + { + // Hexadecimal character reference. + // Pass through unchanged. + // © -- copyright symbol, for example. + // + // The -1 is a bug fix from Rob Laveaux. It keeps + // an overflow from happening if there is no ';'. + // There are actually 2 ways to exit this loop - + // while fails (error case) and break (semicolon found). + // However, there is no mechanism (currently) for + // this function to return an error. + while ( i<(int)str.length()-1 ) + { + outString->append( str.c_str() + i, 1 ); + ++i; + if ( str[i] == ';' ) + break; + } + } + else if ( c == '&' ) + { + outString->append( entity[0].str, entity[0].strLength ); + ++i; + } + else if ( c == '<' ) + { + outString->append( entity[1].str, entity[1].strLength ); + ++i; + } + else if ( c == '>' ) + { + outString->append( entity[2].str, entity[2].strLength ); + ++i; + } + else if ( c == '\"' ) + { + outString->append( entity[3].str, entity[3].strLength ); + ++i; + } + else if ( c == '\'' ) + { + outString->append( entity[4].str, entity[4].strLength ); + ++i; + } + else if ( c < 32 ) + { + // Easy pass at non-alpha/numeric/symbol + // Below 32 is symbolic. + char buf[ 32 ]; + + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF( buf, sizeof(buf), "&#x%02X;", (unsigned) ( c & 0xff ) ); + #else + sprintf( buf, "&#x%02X;", (unsigned) ( c & 0xff ) ); + #endif + + //*ME: warning C4267: convert 'size_t' to 'int' + //*ME: Int-Cast to make compiler happy ... + outString->append( buf, (int)strlen( buf ) ); + ++i; + } + else + { + //char realc = (char) c; + //outString->append( &realc, 1 ); + *outString += (char) c; // somewhat more efficient function call. + ++i; + } + } +} + + +TiXmlNode::TiXmlNode( NodeType _type ) : TiXmlBase() +{ + parent = 0; + type = _type; + firstChild = 0; + lastChild = 0; + prev = 0; + next = 0; +} + + +TiXmlNode::~TiXmlNode() +{ + TiXmlNode* node = firstChild; + TiXmlNode* temp = 0; + + while ( node ) + { + temp = node; + node = node->next; + delete temp; + } +} + + +void TiXmlNode::CopyTo( TiXmlNode* target ) const +{ + target->SetValue (value.c_str() ); + target->userData = userData; + target->location = location; +} + + +void TiXmlNode::Clear() +{ + TiXmlNode* node = firstChild; + TiXmlNode* temp = 0; + + while ( node ) + { + temp = node; + node = node->next; + delete temp; + } + + firstChild = 0; + lastChild = 0; +} + + +TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node ) +{ + assert( node->parent == 0 || node->parent == this ); + assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() ); + + if ( node->Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + delete node; + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + node->parent = this; + + node->prev = lastChild; + node->next = 0; + + if ( lastChild ) + lastChild->next = node; + else + firstChild = node; // it was an empty list. + + lastChild = node; + return node; +} + + +TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis ) +{ + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + TiXmlNode* node = addThis.Clone(); + if ( !node ) + return 0; + + return LinkEndChild( node ); +} + + +TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis ) +{ + if ( !beforeThis || beforeThis->parent != this ) { + return 0; + } + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + TiXmlNode* node = addThis.Clone(); + if ( !node ) + return 0; + node->parent = this; + + node->next = beforeThis; + node->prev = beforeThis->prev; + if ( beforeThis->prev ) + { + beforeThis->prev->next = node; + } + else + { + assert( firstChild == beforeThis ); + firstChild = node; + } + beforeThis->prev = node; + return node; +} + + +TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis ) +{ + if ( !afterThis || afterThis->parent != this ) { + return 0; + } + if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT ) + { + if ( GetDocument() ) + GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + TiXmlNode* node = addThis.Clone(); + if ( !node ) + return 0; + node->parent = this; + + node->prev = afterThis; + node->next = afterThis->next; + if ( afterThis->next ) + { + afterThis->next->prev = node; + } + else + { + assert( lastChild == afterThis ); + lastChild = node; + } + afterThis->next = node; + return node; +} + + +TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis ) +{ + if ( !replaceThis ) + return 0; + + if ( replaceThis->parent != this ) + return 0; + + if ( withThis.ToDocument() ) { + // A document can never be a child. Thanks to Noam. + TiXmlDocument* document = GetDocument(); + if ( document ) + document->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return 0; + } + + TiXmlNode* node = withThis.Clone(); + if ( !node ) + return 0; + + node->next = replaceThis->next; + node->prev = replaceThis->prev; + + if ( replaceThis->next ) + replaceThis->next->prev = node; + else + lastChild = node; + + if ( replaceThis->prev ) + replaceThis->prev->next = node; + else + firstChild = node; + + delete replaceThis; + node->parent = this; + return node; +} + + +bool TiXmlNode::RemoveChild( TiXmlNode* removeThis ) +{ + if ( !removeThis ) { + return false; + } + + if ( removeThis->parent != this ) + { + assert( 0 ); + return false; + } + + if ( removeThis->next ) + removeThis->next->prev = removeThis->prev; + else + lastChild = removeThis->prev; + + if ( removeThis->prev ) + removeThis->prev->next = removeThis->next; + else + firstChild = removeThis->next; + + delete removeThis; + return true; +} + +const TiXmlNode* TiXmlNode::FirstChild( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = firstChild; node; node = node->next ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::LastChild( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = lastChild; node; node = node->prev ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const +{ + if ( !previous ) + { + return FirstChild(); + } + else + { + assert( previous->parent == this ); + return previous->NextSibling(); + } +} + + +const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const +{ + if ( !previous ) + { + return FirstChild( val ); + } + else + { + assert( previous->parent == this ); + return previous->NextSibling( val ); + } +} + + +const TiXmlNode* TiXmlNode::NextSibling( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = next; node; node = node->next ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +const TiXmlNode* TiXmlNode::PreviousSibling( const char * _value ) const +{ + const TiXmlNode* node; + for ( node = prev; node; node = node->prev ) + { + if ( strcmp( node->Value(), _value ) == 0 ) + return node; + } + return 0; +} + + +void TiXmlElement::RemoveAttribute( const char * name ) +{ + #ifdef TIXML_USE_STL + TIXML_STRING str( name ); + TiXmlAttribute* node = attributeSet.Find( str ); + #else + TiXmlAttribute* node = attributeSet.Find( name ); + #endif + if ( node ) + { + attributeSet.Remove( node ); + delete node; + } +} + +const TiXmlElement* TiXmlNode::FirstChildElement() const +{ + const TiXmlNode* node; + + for ( node = FirstChild(); + node; + node = node->NextSibling() ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const +{ + const TiXmlNode* node; + + for ( node = FirstChild( _value ); + node; + node = node->NextSibling( _value ) ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlElement* TiXmlNode::NextSiblingElement() const +{ + const TiXmlNode* node; + + for ( node = NextSibling(); + node; + node = node->NextSibling() ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const +{ + const TiXmlNode* node; + + for ( node = NextSibling( _value ); + node; + node = node->NextSibling( _value ) ) + { + if ( node->ToElement() ) + return node->ToElement(); + } + return 0; +} + + +const TiXmlDocument* TiXmlNode::GetDocument() const +{ + const TiXmlNode* node; + + for( node = this; node; node = node->parent ) + { + if ( node->ToDocument() ) + return node->ToDocument(); + } + return 0; +} + + +TiXmlElement::TiXmlElement (const char * _value) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) +{ + firstChild = lastChild = 0; + value = _value; +} + + +#ifdef TIXML_USE_STL +TiXmlElement::TiXmlElement( const std::string& _value ) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) +{ + firstChild = lastChild = 0; + value = _value; +} +#endif + + +TiXmlElement::TiXmlElement( const TiXmlElement& copy) + : TiXmlNode( TiXmlNode::TINYXML_ELEMENT ) +{ + firstChild = lastChild = 0; + copy.CopyTo( this ); +} + + +TiXmlElement& TiXmlElement::operator=( const TiXmlElement& base ) +{ + ClearThis(); + base.CopyTo( this ); + return *this; +} + + +TiXmlElement::~TiXmlElement() +{ + ClearThis(); +} + + +void TiXmlElement::ClearThis() +{ + Clear(); + while( attributeSet.First() ) + { + TiXmlAttribute* node = attributeSet.First(); + attributeSet.Remove( node ); + delete node; + } +} + + +const char* TiXmlElement::Attribute( const char* name ) const +{ + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( node ) + return node->Value(); + return 0; +} + + +#ifdef TIXML_USE_STL +const std::string* TiXmlElement::Attribute( const std::string& name ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( attrib ) + return &attrib->ValueStr(); + return 0; +} +#endif + + +const char* TiXmlElement::Attribute( const char* name, int* i ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const char* result = 0; + + if ( attrib ) { + result = attrib->Value(); + if ( i ) { + attrib->QueryIntValue( i ); + } + } + return result; +} + + +#ifdef TIXML_USE_STL +const std::string* TiXmlElement::Attribute( const std::string& name, int* i ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const std::string* result = 0; + + if ( attrib ) { + result = &attrib->ValueStr(); + if ( i ) { + attrib->QueryIntValue( i ); + } + } + return result; +} +#endif + + +const char* TiXmlElement::Attribute( const char* name, double* d ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const char* result = 0; + + if ( attrib ) { + result = attrib->Value(); + if ( d ) { + attrib->QueryDoubleValue( d ); + } + } + return result; +} + + +#ifdef TIXML_USE_STL +const std::string* TiXmlElement::Attribute( const std::string& name, double* d ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + const std::string* result = 0; + + if ( attrib ) { + result = &attrib->ValueStr(); + if ( d ) { + attrib->QueryDoubleValue( d ); + } + } + return result; +} +#endif + + +int TiXmlElement::QueryIntAttribute( const char* name, int* ival ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryIntValue( ival ); +} + + +int TiXmlElement::QueryUnsignedAttribute( const char* name, unsigned* value ) const +{ + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( !node ) + return TIXML_NO_ATTRIBUTE; + + int ival = 0; + int result = node->QueryIntValue( &ival ); + *value = (unsigned)ival; + return result; +} + + +int TiXmlElement::QueryBoolAttribute( const char* name, bool* bval ) const +{ + const TiXmlAttribute* node = attributeSet.Find( name ); + if ( !node ) + return TIXML_NO_ATTRIBUTE; + + int result = TIXML_WRONG_TYPE; + if ( StringEqual( node->Value(), "true", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "yes", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "1", true, TIXML_ENCODING_UNKNOWN ) ) + { + *bval = true; + result = TIXML_SUCCESS; + } + else if ( StringEqual( node->Value(), "false", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "no", true, TIXML_ENCODING_UNKNOWN ) + || StringEqual( node->Value(), "0", true, TIXML_ENCODING_UNKNOWN ) ) + { + *bval = false; + result = TIXML_SUCCESS; + } + return result; +} + + + +#ifdef TIXML_USE_STL +int TiXmlElement::QueryIntAttribute( const std::string& name, int* ival ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryIntValue( ival ); +} +#endif + + +int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryDoubleValue( dval ); +} + + +#ifdef TIXML_USE_STL +int TiXmlElement::QueryDoubleAttribute( const std::string& name, double* dval ) const +{ + const TiXmlAttribute* attrib = attributeSet.Find( name ); + if ( !attrib ) + return TIXML_NO_ATTRIBUTE; + return attrib->QueryDoubleValue( dval ); +} +#endif + + +void TiXmlElement::SetAttribute( const char * name, int val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetIntValue( val ); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetAttribute( const std::string& name, int val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetIntValue( val ); + } +} +#endif + + +void TiXmlElement::SetDoubleAttribute( const char * name, double val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetDoubleValue( val ); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetDoubleAttribute( const std::string& name, double val ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( name ); + if ( attrib ) { + attrib->SetDoubleValue( val ); + } +} +#endif + + +void TiXmlElement::SetAttribute( const char * cname, const char * cvalue ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( cname ); + if ( attrib ) { + attrib->SetValue( cvalue ); + } +} + + +#ifdef TIXML_USE_STL +void TiXmlElement::SetAttribute( const std::string& _name, const std::string& _value ) +{ + TiXmlAttribute* attrib = attributeSet.FindOrCreate( _name ); + if ( attrib ) { + attrib->SetValue( _value ); + } +} +#endif + + +void TiXmlElement::Print( FILE* cfile, int depth ) const +{ + int i; + assert( cfile ); + for ( i=0; i<depth; i++ ) { + fprintf( cfile, " " ); + } + + fprintf( cfile, "<%s", value.c_str() ); + + const TiXmlAttribute* attrib; + for ( attrib = attributeSet.First(); attrib; attrib = attrib->Next() ) + { + fprintf( cfile, " " ); + attrib->Print( cfile, depth ); + } + + // There are 3 different formatting approaches: + // 1) An element without children is printed as a <foo /> node + // 2) An element with only a text child is printed as <foo> text </foo> + // 3) An element with children is printed on multiple lines. + TiXmlNode* node; + if ( !firstChild ) + { + fprintf( cfile, " />" ); + } + else if ( firstChild == lastChild && firstChild->ToText() ) + { + fprintf( cfile, ">" ); + firstChild->Print( cfile, depth + 1 ); + fprintf( cfile, "</%s>", value.c_str() ); + } + else + { + fprintf( cfile, ">" ); + + for ( node = firstChild; node; node=node->NextSibling() ) + { + if ( !node->ToText() ) + { + fprintf( cfile, "\n" ); + } + node->Print( cfile, depth+1 ); + } + fprintf( cfile, "\n" ); + for( i=0; i<depth; ++i ) { + fprintf( cfile, " " ); + } + fprintf( cfile, "</%s>", value.c_str() ); + } +} + + +void TiXmlElement::CopyTo( TiXmlElement* target ) const +{ + // superclass: + TiXmlNode::CopyTo( target ); + + // Element class: + // Clone the attributes, then clone the children. + const TiXmlAttribute* attribute = 0; + for( attribute = attributeSet.First(); + attribute; + attribute = attribute->Next() ) + { + target->SetAttribute( attribute->Name(), attribute->Value() ); + } + + TiXmlNode* node = 0; + for ( node = firstChild; node; node = node->NextSibling() ) + { + target->LinkEndChild( node->Clone() ); + } +} + +bool TiXmlElement::Accept( TiXmlVisitor* visitor ) const +{ + if ( visitor->VisitEnter( *this, attributeSet.First() ) ) + { + for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() ) + { + if ( !node->Accept( visitor ) ) + break; + } + } + return visitor->VisitExit( *this ); +} + + +TiXmlNode* TiXmlElement::Clone() const +{ + TiXmlElement* clone = new TiXmlElement( Value() ); + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +const char* TiXmlElement::GetText() const +{ + const TiXmlNode* child = this->FirstChild(); + if ( child ) { + const TiXmlText* childText = child->ToText(); + if ( childText ) { + return childText->Value(); + } + } + return 0; +} + + +TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + tabsize = 4; + useMicrosoftBOM = false; + ClearError(); +} + +TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + tabsize = 4; + useMicrosoftBOM = false; + value = documentName; + ClearError(); +} + + +#ifdef TIXML_USE_STL +TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + tabsize = 4; + useMicrosoftBOM = false; + value = documentName; + ClearError(); +} +#endif + + +TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT ) +{ + copy.CopyTo( this ); +} + + +TiXmlDocument& TiXmlDocument::operator=( const TiXmlDocument& copy ) +{ + Clear(); + copy.CopyTo( this ); + return *this; +} + + +bool TiXmlDocument::LoadFile( TiXmlEncoding encoding ) +{ + return LoadFile( Value(), encoding ); +} + + +bool TiXmlDocument::SaveFile() const +{ + return SaveFile( Value() ); +} + +bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding ) +{ + TIXML_STRING filename( _filename ); + value = filename; + + // reading in binary mode so that tinyxml can normalize the EOL + FILE* file = TiXmlFOpen( value.c_str (), "rb" ); + + if ( file ) + { + bool result = LoadFile( file, encoding ); + fclose( file ); + return result; + } + else + { + SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } +} + +bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding ) +{ + if ( !file ) + { + SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } + + // Delete the existing data: + Clear(); + location.Clear(); + + // Get the file size, so we can pre-allocate the string. HUGE speed impact. + long length = 0; + fseek( file, 0, SEEK_END ); + length = ftell( file ); + fseek( file, 0, SEEK_SET ); + + // Strange case, but good to handle up front. + if ( length <= 0 ) + { + SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } + + // Subtle bug here. TinyXml did use fgets. But from the XML spec: + // 2.11 End-of-Line Handling + // <snip> + // <quote> + // ...the XML processor MUST behave as if it normalized all line breaks in external + // parsed entities (including the document entity) on input, before parsing, by translating + // both the two-character sequence #xD #xA and any #xD that is not followed by #xA to + // a single #xA character. + // </quote> + // + // It is not clear fgets does that, and certainly isn't clear it works cross platform. + // Generally, you expect fgets to translate from the convention of the OS to the c/unix + // convention, and not work generally. + + /* + while( fgets( buf, sizeof(buf), file ) ) + { + data += buf; + } + */ + + char* buf = new char[ length+1 ]; + buf[0] = 0; + + if ( fread( buf, length, 1, file ) != 1 ) { + delete [] buf; + SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN ); + return false; + } + + // Process the buffer in place to normalize new lines. (See comment above.) + // Copies from the 'p' to 'q' pointer, where p can advance faster if + // a newline-carriage return is hit. + // + // Wikipedia: + // Systems based on ASCII or a compatible character set use either LF (Line feed, '\n', 0x0A, 10 in decimal) or + // CR (Carriage return, '\r', 0x0D, 13 in decimal) individually, or CR followed by LF (CR+LF, 0x0D 0x0A)... + // * LF: Multics, Unix and Unix-like systems (GNU/Linux, AIX, Xenix, Mac OS X, FreeBSD, etc.), BeOS, Amiga, RISC OS, and others + // * CR+LF: DEC RT-11 and most other early non-Unix, non-IBM OSes, CP/M, MP/M, DOS, OS/2, Microsoft Windows, Symbian OS + // * CR: Commodore 8-bit machines, Apple II family, Mac OS up to version 9 and OS-9 + + const char* p = buf; // the read head + char* q = buf; // the write head + const char CR = 0x0d; + const char LF = 0x0a; + + buf[length] = 0; + while( *p ) { + assert( p < (buf+length) ); + assert( q <= (buf+length) ); + assert( q <= p ); + + if ( *p == CR ) { + *q++ = LF; + p++; + if ( *p == LF ) { // check for CR+LF (and skip LF) + p++; + } + } + else { + *q++ = *p++; + } + } + assert( q <= (buf+length) ); + *q = 0; + + Parse( buf, 0, encoding ); + + delete [] buf; + return !Error(); +} + + +bool TiXmlDocument::SaveFile( const char * filename ) const +{ + // The old c stuff lives on... + FILE* fp = TiXmlFOpen( filename, "w" ); + if ( fp ) + { + bool result = SaveFile( fp ); + fclose( fp ); + return result; + } + return false; +} + + +bool TiXmlDocument::SaveFile( FILE* fp ) const +{ + if ( useMicrosoftBOM ) + { + const unsigned char TIXML_UTF_LEAD_0 = 0xefU; + const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; + const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; + + fputc( TIXML_UTF_LEAD_0, fp ); + fputc( TIXML_UTF_LEAD_1, fp ); + fputc( TIXML_UTF_LEAD_2, fp ); + } + Print( fp, 0 ); + return (ferror(fp) == 0); +} + + +void TiXmlDocument::CopyTo( TiXmlDocument* target ) const +{ + TiXmlNode::CopyTo( target ); + + target->error = error; + target->errorId = errorId; + target->errorDesc = errorDesc; + target->tabsize = tabsize; + target->errorLocation = errorLocation; + target->useMicrosoftBOM = useMicrosoftBOM; + + TiXmlNode* node = 0; + for ( node = firstChild; node; node = node->NextSibling() ) + { + target->LinkEndChild( node->Clone() ); + } +} + + +TiXmlNode* TiXmlDocument::Clone() const +{ + TiXmlDocument* clone = new TiXmlDocument(); + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +void TiXmlDocument::Print( FILE* cfile, int depth ) const +{ + assert( cfile ); + for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() ) + { + node->Print( cfile, depth ); + fprintf( cfile, "\n" ); + } +} + + +bool TiXmlDocument::Accept( TiXmlVisitor* visitor ) const +{ + if ( visitor->VisitEnter( *this ) ) + { + for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() ) + { + if ( !node->Accept( visitor ) ) + break; + } + } + return visitor->VisitExit( *this ); +} + + +const TiXmlAttribute* TiXmlAttribute::Next() const +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( next->value.empty() && next->name.empty() ) + return 0; + return next; +} + +/* +TiXmlAttribute* TiXmlAttribute::Next() +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( next->value.empty() && next->name.empty() ) + return 0; + return next; +} +*/ + +const TiXmlAttribute* TiXmlAttribute::Previous() const +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( prev->value.empty() && prev->name.empty() ) + return 0; + return prev; +} + +/* +TiXmlAttribute* TiXmlAttribute::Previous() +{ + // We are using knowledge of the sentinel. The sentinel + // have a value or name. + if ( prev->value.empty() && prev->name.empty() ) + return 0; + return prev; +} +*/ + +void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const +{ + TIXML_STRING n, v; + + EncodeString( name, &n ); + EncodeString( value, &v ); + + if (value.find ('\"') == TIXML_STRING::npos) { + if ( cfile ) { + fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() ); + } + if ( str ) { + (*str) += n; (*str) += "=\""; (*str) += v; (*str) += "\""; + } + } + else { + if ( cfile ) { + fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() ); + } + if ( str ) { + (*str) += n; (*str) += "='"; (*str) += v; (*str) += "'"; + } + } +} + + +int TiXmlAttribute::QueryIntValue( int* ival ) const +{ + if ( TIXML_SSCANF( value.c_str(), "%d", ival ) == 1 ) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; +} + +int TiXmlAttribute::QueryDoubleValue( double* dval ) const +{ + if ( TIXML_SSCANF( value.c_str(), "%lf", dval ) == 1 ) + return TIXML_SUCCESS; + return TIXML_WRONG_TYPE; +} + +void TiXmlAttribute::SetIntValue( int _value ) +{ + char buf [64]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF(buf, sizeof(buf), "%d", _value); + #else + sprintf (buf, "%d", _value); + #endif + SetValue (buf); +} + +void TiXmlAttribute::SetDoubleValue( double _value ) +{ + char buf [256]; + #if defined(TIXML_SNPRINTF) + TIXML_SNPRINTF( buf, sizeof(buf), "%g", _value); + #else + sprintf (buf, "%g", _value); + #endif + SetValue (buf); +} + +int TiXmlAttribute::IntValue() const +{ + return atoi (value.c_str ()); +} + +double TiXmlAttribute::DoubleValue() const +{ + return atof (value.c_str ()); +} + + +TiXmlComment::TiXmlComment( const TiXmlComment& copy ) : TiXmlNode( TiXmlNode::TINYXML_COMMENT ) +{ + copy.CopyTo( this ); +} + + +TiXmlComment& TiXmlComment::operator=( const TiXmlComment& base ) +{ + Clear(); + base.CopyTo( this ); + return *this; +} + + +void TiXmlComment::Print( FILE* cfile, int depth ) const +{ + assert( cfile ); + for ( int i=0; i<depth; i++ ) + { + fprintf( cfile, " " ); + } + fprintf( cfile, "", value.c_str() ); +} + + +void TiXmlComment::CopyTo( TiXmlComment* target ) const +{ + TiXmlNode::CopyTo( target ); +} + + +bool TiXmlComment::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlComment::Clone() const +{ + TiXmlComment* clone = new TiXmlComment(); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +void TiXmlText::Print( FILE* cfile, int depth ) const +{ + assert( cfile ); + if ( cdata ) + { + int i; + fprintf( cfile, "\n" ); + for ( i=0; i<depth; i++ ) { + fprintf( cfile, " " ); + } + fprintf( cfile, "<![CDATA[%s]]>\n", value.c_str() ); // unformatted output + } + else + { + TIXML_STRING buffer; + EncodeString( value, &buffer ); + fprintf( cfile, "%s", buffer.c_str() ); + } +} + + +void TiXmlText::CopyTo( TiXmlText* target ) const +{ + TiXmlNode::CopyTo( target ); + target->cdata = cdata; +} + + +bool TiXmlText::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlText::Clone() const +{ + TiXmlText* clone = 0; + clone = new TiXmlText( "" ); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +TiXmlDeclaration::TiXmlDeclaration( const char * _version, + const char * _encoding, + const char * _standalone ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) +{ + version = _version; + encoding = _encoding; + standalone = _standalone; +} + + +#ifdef TIXML_USE_STL +TiXmlDeclaration::TiXmlDeclaration( const std::string& _version, + const std::string& _encoding, + const std::string& _standalone ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) +{ + version = _version; + encoding = _encoding; + standalone = _standalone; +} +#endif + + +TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy ) + : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) +{ + copy.CopyTo( this ); +} + + +TiXmlDeclaration& TiXmlDeclaration::operator=( const TiXmlDeclaration& copy ) +{ + Clear(); + copy.CopyTo( this ); + return *this; +} + + +void TiXmlDeclaration::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const +{ + if ( cfile ) fprintf( cfile, "<?xml " ); + if ( str ) (*str) += "<?xml "; + + if ( !version.empty() ) { + if ( cfile ) fprintf (cfile, "version=\"%s\" ", version.c_str ()); + if ( str ) { (*str) += "version=\""; (*str) += version; (*str) += "\" "; } + } + if ( !encoding.empty() ) { + if ( cfile ) fprintf (cfile, "encoding=\"%s\" ", encoding.c_str ()); + if ( str ) { (*str) += "encoding=\""; (*str) += encoding; (*str) += "\" "; } + } + if ( !standalone.empty() ) { + if ( cfile ) fprintf (cfile, "standalone=\"%s\" ", standalone.c_str ()); + if ( str ) { (*str) += "standalone=\""; (*str) += standalone; (*str) += "\" "; } + } + if ( cfile ) fprintf( cfile, "?>" ); + if ( str ) (*str) += "?>"; +} + + +void TiXmlDeclaration::CopyTo( TiXmlDeclaration* target ) const +{ + TiXmlNode::CopyTo( target ); + + target->version = version; + target->encoding = encoding; + target->standalone = standalone; +} + + +bool TiXmlDeclaration::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlDeclaration::Clone() const +{ + TiXmlDeclaration* clone = new TiXmlDeclaration(); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +void TiXmlUnknown::Print( FILE* cfile, int depth ) const +{ + for ( int i=0; i<depth; i++ ) + fprintf( cfile, " " ); + fprintf( cfile, "<%s>", value.c_str() ); +} + + +void TiXmlUnknown::CopyTo( TiXmlUnknown* target ) const +{ + TiXmlNode::CopyTo( target ); +} + + +bool TiXmlUnknown::Accept( TiXmlVisitor* visitor ) const +{ + return visitor->Visit( *this ); +} + + +TiXmlNode* TiXmlUnknown::Clone() const +{ + TiXmlUnknown* clone = new TiXmlUnknown(); + + if ( !clone ) + return 0; + + CopyTo( clone ); + return clone; +} + + +TiXmlAttributeSet::TiXmlAttributeSet() +{ + sentinel.next = &sentinel; + sentinel.prev = &sentinel; +} + + +TiXmlAttributeSet::~TiXmlAttributeSet() +{ + assert( sentinel.next == &sentinel ); + assert( sentinel.prev == &sentinel ); +} + + +void TiXmlAttributeSet::Add( TiXmlAttribute* addMe ) +{ + #ifdef TIXML_USE_STL + assert( !Find( TIXML_STRING( addMe->Name() ) ) ); // Shouldn't be multiply adding to the set. + #else + assert( !Find( addMe->Name() ) ); // Shouldn't be multiply adding to the set. + #endif + + addMe->next = &sentinel; + addMe->prev = sentinel.prev; + + sentinel.prev->next = addMe; + sentinel.prev = addMe; +} + +void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe ) +{ + TiXmlAttribute* node; + + for( node = sentinel.next; node != &sentinel; node = node->next ) + { + if ( node == removeMe ) + { + node->prev->next = node->next; + node->next->prev = node->prev; + node->next = 0; + node->prev = 0; + return; + } + } + assert( 0 ); // we tried to remove a non-linked attribute. +} + + +#ifdef TIXML_USE_STL +TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const +{ + for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) + { + if ( node->name == name ) + return node; + } + return 0; +} + +TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const std::string& _name ) +{ + TiXmlAttribute* attrib = Find( _name ); + if ( !attrib ) { + attrib = new TiXmlAttribute(); + Add( attrib ); + attrib->SetName( _name ); + } + return attrib; +} +#endif + + +TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const +{ + for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next ) + { + if ( strcmp( node->name.c_str(), name ) == 0 ) + return node; + } + return 0; +} + + +TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const char* _name ) +{ + TiXmlAttribute* attrib = Find( _name ); + if ( !attrib ) { + attrib = new TiXmlAttribute(); + Add( attrib ); + attrib->SetName( _name ); + } + return attrib; +} + + +#ifdef TIXML_USE_STL +std::istream& operator>> (std::istream & in, TiXmlNode & base) +{ + TIXML_STRING tag; + tag.reserve( 8 * 1000 ); + base.StreamIn( &in, &tag ); + + base.Parse( tag.c_str(), 0, TIXML_DEFAULT_ENCODING ); + return in; +} +#endif + + +#ifdef TIXML_USE_STL +std::ostream& operator<< (std::ostream & out, const TiXmlNode & base) +{ + TiXmlPrinter printer; + printer.SetStreamPrinting(); + base.Accept( &printer ); + out << printer.Str(); + + return out; +} + + +std::string& operator<< (std::string& out, const TiXmlNode& base ) +{ + TiXmlPrinter printer; + printer.SetStreamPrinting(); + base.Accept( &printer ); + out.append( printer.Str() ); + + return out; +} +#endif + + +TiXmlHandle TiXmlHandle::FirstChild() const +{ + if ( node ) + { + TiXmlNode* child = node->FirstChild(); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::FirstChild( const char * value ) const +{ + if ( node ) + { + TiXmlNode* child = node->FirstChild( value ); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::FirstChildElement() const +{ + if ( node ) + { + TiXmlElement* child = node->FirstChildElement(); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::FirstChildElement( const char * value ) const +{ + if ( node ) + { + TiXmlElement* child = node->FirstChildElement( value ); + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::Child( int count ) const +{ + if ( node ) + { + int i; + TiXmlNode* child = node->FirstChild(); + for ( i=0; + child && i<count; + child = child->NextSibling(), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::Child( const char* value, int count ) const +{ + if ( node ) + { + int i; + TiXmlNode* child = node->FirstChild( value ); + for ( i=0; + child && i<count; + child = child->NextSibling( value ), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::ChildElement( int count ) const +{ + if ( node ) + { + int i; + TiXmlElement* child = node->FirstChildElement(); + for ( i=0; + child && i<count; + child = child->NextSiblingElement(), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +TiXmlHandle TiXmlHandle::ChildElement( const char* value, int count ) const +{ + if ( node ) + { + int i; + TiXmlElement* child = node->FirstChildElement( value ); + for ( i=0; + child && i<count; + child = child->NextSiblingElement( value ), ++i ) + { + // nothing + } + if ( child ) + return TiXmlHandle( child ); + } + return TiXmlHandle( 0 ); +} + + +bool TiXmlPrinter::VisitEnter( const TiXmlDocument& ) +{ + return true; +} + +bool TiXmlPrinter::VisitExit( const TiXmlDocument& ) +{ + return true; +} + +bool TiXmlPrinter::VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute ) +{ + DoIndent(); + buffer += "<"; + buffer += element.Value(); + + for( const TiXmlAttribute* attrib = firstAttribute; attrib; attrib = attrib->Next() ) + { + buffer += " "; + attrib->Print( 0, 0, &buffer ); + } + + if ( !element.FirstChild() ) + { + buffer += " />"; + DoLineBreak(); + } + else + { + buffer += ">"; + if ( element.FirstChild()->ToText() + && element.LastChild() == element.FirstChild() + && element.FirstChild()->ToText()->CDATA() == false ) + { + simpleTextPrint = true; + // no DoLineBreak()! + } + else + { + DoLineBreak(); + } + } + ++depth; + return true; +} + + +bool TiXmlPrinter::VisitExit( const TiXmlElement& element ) +{ + --depth; + if ( !element.FirstChild() ) + { + // nothing. + } + else + { + if ( simpleTextPrint ) + { + simpleTextPrint = false; + } + else + { + DoIndent(); + } + buffer += "</"; + buffer += element.Value(); + buffer += ">"; + DoLineBreak(); + } + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlText& text ) +{ + if ( text.CDATA() ) + { + DoIndent(); + buffer += "<![CDATA["; + buffer += text.Value(); + buffer += "]]>"; + DoLineBreak(); + } + else if ( simpleTextPrint ) + { + TIXML_STRING str; + TiXmlBase::EncodeString( text.ValueTStr(), &str ); + buffer += str; + } + else + { + DoIndent(); + TIXML_STRING str; + TiXmlBase::EncodeString( text.ValueTStr(), &str ); + buffer += str; + DoLineBreak(); + } + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlDeclaration& declaration ) +{ + DoIndent(); + declaration.Print( 0, 0, &buffer ); + DoLineBreak(); + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlComment& comment ) +{ + DoIndent(); + buffer += ""; + DoLineBreak(); + return true; +} + + +bool TiXmlPrinter::Visit( const TiXmlUnknown& unknown ) +{ + DoIndent(); + buffer += "<"; + buffer += unknown.Value(); + buffer += ">"; + DoLineBreak(); + return true; +} + Index: /branches/fep_rpc_client/network.h =================================================================== --- /branches/fep_rpc_client/network.h (revision 77) +++ /branches/fep_rpc_client/network.h (revision 79) @@ -11,4 +11,5 @@ const int Fixed_Byte_To_Checksum = 25; // the first byte is not considered in the calculation of "BYTE 2" const int CONTROL_DATA_LEN = 27; + char * const dp5[8] = { "ML_1", "ML_2", "ML_3", "ML_4", "ML_5", "ML_6", "HOV_Lane", "FYW_Conn"}; @@ -20,35 +21,30 @@ "SD_6", "Pass_Vol_Count", "X"}; -/*** NETWORK STRUCTS ***/ -typedef struct loopagg LOOPAGG; -struct loopagg -{ - int index; - char lane; // how namy lanes at the detector station - long time; - int interval; - int g_vol; - float g_occ; - double g_spd; - int *vol; - float *occ; - double *spd; -}; - // FEP line: has several lds typedef struct fep_line FEP_LINE; struct fep_line { - int lineNum; - vector<long> lds; - vector<long> ldsIndex; // location in ldsMap - short ldsNum; // actual number of lds on the line + int lineNum; + vector<long> lds; + vector<long> ldsIndex; // location in ldsMap - short count; // actual count from caltrans - int schedule; - int lineInfo; + short count; // actual count from caltrans + int schedule; + int lineInfo; long systemKey; long globalSeq; long schedleSeq; +}; + +// Loop detector +typedef struct loop LOOP; +struct loop +{ + long loopID; + char *loop_loc; + + int vol; + float occ; + double spd; }; @@ -61,8 +57,6 @@ short line_num; short drop; - - int num; // number of loops - long *loopID; - char **loop_loc; + + vector<LOOP*> loops; // LDS data @@ -74,3 +68,11 @@ }; +typedef struct volOcc VOLOCC; +struct volOcc +{ + char high; + char low; +}; + + #endif Index: /branches/fep_rpc_client/DataPacker.cpp =================================================================== --- /branches/fep_rpc_client/DataPacker.cpp (revision 79) +++ /branches/fep_rpc_client/DataPacker.cpp (revision 79) @@ -0,0 +1,266 @@ +#include "DataPacker.h"; + +unsigned char * DataPacker::msg; + +unsigned char * DataPacker::packData(LDS_LOOP *station) { + int pos = 26; + DataPacker packer; + msg = packer.staticDataPack(station); + pos = packer.dynamicDataPack(station, 5, pos); + pos = packer.dynamicDataPack(station, 6, pos); + pos = packer.dynamicDataPack(station, 7, pos); + pos = packer.dynamicDataPack(station, 8, pos); + // Update data for BYTE 9, 16, 21, 22, 23, 24 + + // what is the current metering rate? + // check each LDS, if there is demand detector, the downstream node the + // ldsMap[i].dataPack[22-1] = ldsMap[i].dataPack[9-1] = ; + + // will need to check if queue override is enabled (Currently, no queue + // ldsMap[i].dataPack[16-1] = ; + + // byte 23: MAINLINE total volume + msg[23 - 1] = station->MlTotVol; + + // byte 24: opposite total volume + msg[24 - 1] = station->OppTotVol; + + // last BYTE: checksum + msg[station->length - 1] = + packer.chksum(msg, station->length - 1 - 1); + + /* + for (int j = 0; j < station->length; j++) { + printf("%02X", msg[j]); + } + printf("\n"); + */ +} + +int DataPacker::dynamicDataPack(LDS_LOOP *station, int packNo, int pos) { + int i, j, vol, occ, haveData; + //used for data byte 23 and 24 + station->MlTotVol = 0; + station->OppTotVol = 0; + + for (j = 1; j <= 8; j++) { + + if (DataAvail(msg[packNo - 1], j)) { + // loop at bit j has data + for (int lane = 0; lane < station->loops.size(); lane++) { + // what's the corresponding loop of bit j + char * currLoopLoc = station->loops.at(lane)->loop_loc; + if (packNo == 5) + haveData = strcmp(currLoopLoc, dp5[j - 1]); + else if (packNo == 6) + haveData = strcmp(currLoopLoc, dp6[j - 1]); + else if (packNo == 7) + haveData = strcmp(currLoopLoc, dp7[j - 1]); + else if (packNo == 8) + haveData = strcmp(currLoopLoc, dp8[j - 1]); + else + return -1; + + if (haveData == 0) { + LOOP *currLoop = station->loops.at(lane); + vol = currLoop->vol; + occ = (int) (currLoop->occ * 900 + 0.5); + + VOLOCC packedVOLOCC = packVOLOCC(vol, occ); + pos++; + msg[pos - 1] = packedVOLOCC.high; + pos++; + msg[pos - 1] = packedVOLOCC.low; + + if (packNo == 5) { + station->MlTotVol += vol; + } else if (packNo == 6) { + station->OppTotVol += vol; + } + } + } + } + } + return pos; +} + +unsigned char * DataPacker::staticDataPack(LDS_LOOP *station) { + int j; + // Allocate memory for dataPack + unsigned char *dataPack = (unsigned char *) calloc(sizeof(unsigned char), station->length); + + // dataPack 5-8: lane config + char d5 = 0, d6 = 0, d7 = 0, d8 = 0; + for (j = 0; j < station->loops.size(); j++) { + for (int k = 0; k < 8; k++) { + char * currLoopLoc = station->loops.at(j)->loop_loc; + if (strcmp(currLoopLoc, dp5[k]) == 0) + d5 += pow(2, k); + if (strcmp(currLoopLoc, dp6[k]) == 0) + d6 += pow(2, k); + if (strcmp(currLoopLoc, dp7[k]) == 0) + d7 += pow(2, k); + if (strcmp(currLoopLoc, dp8[k]) == 0) + d8 += pow(2, k); + } + } + dataPack[5 - 1] = d5; + dataPack[6 - 1] = d6; + dataPack[7 - 1] = d7; + dataPack[8 - 1] = d8; + + // dataPack 1: Drop number, i.e. station address + dataPack[1 - 1] = station->drop; + // dataPack2 (2 bytes per loop) + dataPack[2 - 1] = station->loops.size() * 2 + Fixed_Byte_To_Checksum; + + // dataPacket 3 (lowbyte: # of mainline loops, highbyte: # of opposite loops) + int low = 0, high = 0; + for (j = 1; j <= 6; j++) { + low += DataAvail(dataPack[5 - 1], j); + high += DataAvail(dataPack[6 - 1], j); + } + high = high << 4; + dataPack[3 - 1] = high | low; + + // dataPack4 (Miscl. flags: samples are: 80, A0, E0, 00) + dataPack[4 - 1] = 0xA0; + + // dataPack 9: initialized as 00 (meaning no metering); need to be updated every 30 sec + dataPack[9 - 1] = 0; + + // datadataPack 10-13: lane malfunction? Assuming all functional + dataPack[10 - 1] = 0; + dataPack[11 - 1] = 0; + dataPack[12 - 1] = 0; + dataPack[13 - 1] = 0; + + // dataPack 14-22: ramp metering data + // BYTE 16 and 22 need to be updated every 30 sec + bool found = false; + for (j = 0; j < station->loops.size(); j++) { + if (strcmp(station->loops.at(j)->loop_loc, "DEMAND") == 0) { + found = true; + break; + } + } + if (found) { + // BYTE 14: mostly 07, some are 05, 03, 00 + dataPack[14 - 1] = 0x07; + // mostly 06(TOD table 1); some are 0B (No metering) or 05(traffic responsive) + dataPack[15 - 1] = 0x06; + // most 00, some are 01 (queue override) or 80(Meter ON sign) + dataPack[16 - 1] = 0x00; + // Field Manual Rate + dataPack[17 - 1] = 0xFF; + // TOC Manual Rate + dataPack[18 - 1] = 0xFF; + // PSO Manual Rate + dataPack[19 - 1] = 0xFF; + // CORM Rate + dataPack[20 - 1] = 0xFF; + // Local Responsive Rate. DON'T UNDERSTAND YET + dataPack[21 - 1] = 0x00; + // TOD Rate: need to query RAMP plugin! + dataPack[22 - 1] = 0x00; + }// LDS: NO Metering + else { + dataPack[14 - 1] = 0x00; + dataPack[15 - 1] = 0x0B; + dataPack[16 - 1] = 0x00; + dataPack[17 - 1] = 0xFF; + dataPack[18 - 1] = 0xFF; + dataPack[19 - 1] = 0xFF; + dataPack[20 - 1] = 0xFF; + dataPack[21 - 1] = 0x00; + dataPack[22 - 1] = 0x00; + } + + // dataPack 23-24: sum of mainline/Opp traffic data; need to be updated every 30 sec + station->MlTotVol = 0; + station->OppTotVol = 0; + dataPack[23 - 1] = station->MlTotVol; + dataPack[24 - 1] = station->OppTotVol; + + // dataPack 25-26: BYTE 25 is fixed, i.e. 03; BYTE 26 is either 0xA2 or 0x84 + dataPack[25 - 1] = 0x03; + dataPack[26 - 1] = 0x84; + + return dataPack; +} + +bool DataPacker::DataAvail(char flag, int num) { + int mag, fel; + + // find mask value + if (num == 1) + mag = 0x01; + else if (num == 2) + mag = 0x02; + else if (num == 3) + mag = 0x04; + else if (num == 4) + mag = 0x08; + else if (num == 5) + mag = 0x10; + else if (num == 6) + mag = 0x20; + else if (num == 7) + mag = 0x40; + else if (num == 8) + mag = 0x80; + + fel = flag & mag; + fel = fel >> (num - 1); + + if (fel == 1) + return true; + else + return false; +} + +// checksum based on data from byte 1 (after 0DOA) to the second last byte (the +char DataPacker::chksum(unsigned char *dataptr, int len) { + int i; + unsigned char checksum = 0; + + for (i = 0; i < len; i++) + checksum += dataptr[i]; + + return checksum; +} + +// convert vol and occ data to a two-byte data packet +VOLOCC DataPacker::packVOLOCC(int vol, int occ) +{ + int bit, i; + int high, low; + int high_high = 0, high_low = 0; + VOLOCC com; + + // occ data: 10 bits + low = 0; + for (i=9; i>=0; i--) + { + if (i >= 8) + { + bit = ((occ >> i) & 1); + high_low += pow(2, (i - 8)) * bit; + } + // lower byte + else + { + bit = ((occ >> i) & 1); + low += pow(2, i) * bit; + } + } + + // vol: 6 bits (1. vol, shift to the left for two times; 2. combine data) + high_high = vol << 2; + high = high_high | high_low; + + com.high = high; + com.low = low; + + return com; +} Index: /branches/fep_rpc_client/DataPacker.h =================================================================== --- /branches/fep_rpc_client/DataPacker.h (revision 79) +++ /branches/fep_rpc_client/DataPacker.h (revision 79) @@ -0,0 +1,47 @@ +/* + * File: DataPacker.h + * + * DataPacker has a single static public method packData(..) that returns the + * packed data message that is sent to the ATMS Server in the fep_reply struct + * via RPC. + * + * @author John A. Torres + * @version 9/8/2017 + */ + +#ifndef DATAPACKER_H +#define DATAPACKER_H + +// Include dependencies +#include "network.h"; +#include <iostream> +#include <string.h> + +class DataPacker { + +public: + /** + * Returns packed data message to be sent to ATMS Server in fep_reply via RPC + * + * @param station The station for which the message is to be made + * @return The packed data message + */ + static unsigned char * packData(LDS_LOOP *station); + +private: + static unsigned char *msg; + // Packs the static data in message sent to ATMS + unsigned char * staticDataPack(LDS_LOOP *station); + // Packs dynamic data in message sent to ATMS + int dynamicDataPack(LDS_LOOP *station, int packNo, int pos); + // Sets last byte of message + char chksum(unsigned char *dataptr, int len); + // Tells whether or not data is available for specified lane + bool DataAvail(char flag, int num); + // Helper function: packs vol and occ into two byte data packet + VOLOCC packVOLOCC(int vol, int occ); + +}; + +#endif /* DATAPACKER_H */ + Index: /branches/fep_rpc_client/nbproject/Makefile-Release.mk =================================================================== --- /branches/fep_rpc_client/nbproject/Makefile-Release.mk (revision 77) +++ /branches/fep_rpc_client/nbproject/Makefile-Release.mk (revision 79) @@ -36,4 +36,5 @@ # Object Files OBJECTFILES= \ + ${OBJECTDIR}/DataPacker.o \ ${OBJECTDIR}/FEPClient.o \ ${OBJECTDIR}/NetworkReader.o \ @@ -65,4 +66,9 @@ ${MKDIR} -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM} ${LINK.cc} -o ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client ${OBJECTFILES} ${LDLIBSOPTIONS} + +${OBJECTDIR}/DataPacker.o: DataPacker.cpp + ${MKDIR} -p ${OBJECTDIR} + ${RM} "$@.d" + $(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/DataPacker.o DataPacker.cpp ${OBJECTDIR}/FEPClient.o: FEPClient.cpp Index: /branches/fep_rpc_client/nbproject/Makefile-Debug.mk =================================================================== --- /branches/fep_rpc_client/nbproject/Makefile-Debug.mk (revision 77) +++ /branches/fep_rpc_client/nbproject/Makefile-Debug.mk (revision 79) @@ -36,4 +36,5 @@ # Object Files OBJECTFILES= \ + ${OBJECTDIR}/DataPacker.o \ ${OBJECTDIR}/FEPClient.o \ ${OBJECTDIR}/NetworkReader.o \ @@ -56,5 +57,5 @@ # Link Libraries and Options -LDLIBSOPTIONS=tinyxml/libtinyxml.a +LDLIBSOPTIONS=tinyxml/tinyxml.a # Build Targets @@ -62,9 +63,14 @@ "${MAKE}" -f nbproject/Makefile-${CND_CONF}.mk ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client -${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client: tinyxml/libtinyxml.a +${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client: tinyxml/tinyxml.a ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client: ${OBJECTFILES} ${MKDIR} -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM} ${LINK.cc} -o ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/fep_rpc_client ${OBJECTFILES} ${LDLIBSOPTIONS} + +${OBJECTDIR}/DataPacker.o: DataPacker.cpp + ${MKDIR} -p ${OBJECTDIR} + ${RM} "$@.d" + $(COMPILE.cc) -g -Itinyxml -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/DataPacker.o DataPacker.cpp ${OBJECTDIR}/FEPClient.o: FEPClient.cpp Index: /branches/fep_rpc_client/nbproject/configurations.xml =================================================================== --- /branches/fep_rpc_client/nbproject/configurations.xml (revision 77) +++ /branches/fep_rpc_client/nbproject/configurations.xml (revision 79) @@ -5,4 +5,5 @@ displayName="Header Files" projectFiles="true"> + <itemPath>DataPacker.h</itemPath> <itemPath>FEPClient.h</itemPath> <itemPath>NetworkReader.h</itemPath> @@ -17,4 +18,5 @@ displayName="Source Files" projectFiles="true"> + <itemPath>DataPacker.cpp</itemPath> <itemPath>FEPClient.cpp</itemPath> <itemPath>NetworkReader.cpp</itemPath> @@ -50,8 +52,12 @@ <linkerTool> <linkerLibItems> - <linkerLibFileItem>tinyxml/libtinyxml.a</linkerLibFileItem> + <linkerLibFileItem>tinyxml/tinyxml.a</linkerLibFileItem> </linkerLibItems> </linkerTool> </compileType> + <item path="DataPacker.cpp" ex="false" tool="1" flavor2="0"> + </item> + <item path="DataPacker.h" ex="false" tool="3" flavor2="0"> + </item> <item path="FEPClient.cpp" ex="false" tool="1" flavor2="0"> </item> @@ -91,4 +97,8 @@ </asmTool> </compileType> + <item path="DataPacker.cpp" ex="false" tool="1" flavor2="0"> + </item> + <item path="DataPacker.h" ex="false" tool="3" flavor2="0"> + </item> <item path="FEPClient.cpp" ex="false" tool="1" flavor2="0"> </item> Index: /branches/fep_rpc_client/nbproject/private/private.xml =================================================================== --- /branches/fep_rpc_client/nbproject/private/private.xml (revision 78) +++ /branches/fep_rpc_client/nbproject/private/private.xml (revision 79) @@ -8,9 +8,12 @@ <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2"> <group> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/NetworkReader.h</file> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/FEPClient.cpp</file> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/network.h</file> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/fep.h</file> - <file>file:/home/andrew/tmcsim/branches/fep_rpc_client/NetworkReader.cpp</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/NetworkReader.cpp</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/NetworkReader.h</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/network.h</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/FEPClient.cpp</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/fep.h</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/DataPacker.h</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/DataPacker.cpp</file> + <file>file:/home/andrew/tmcsimulator/branches/fep_rpc_client/FEPClient.h</file> </group> </open-files> Index: /branches/ATMSDriver/build/built-jar.properties =================================================================== --- /branches/ATMSDriver/build/built-jar.properties (revision 77) +++ /branches/ATMSDriver/build/built-jar.properties (revision 79) @@ -1,4 +1,4 @@ -#Wed, 13 Sep 2017 17:07:03 -0700 +#Mon, 02 Oct 2017 13:41:31 -0700 -/home/andrew/branches/ATMSDriver= +/home/andrew/tmcsimulator/branches/ATMSDriver= Index: /branches/ATMSDriver/nbproject/private/private.xml =================================================================== --- /branches/ATMSDriver/nbproject/private/private.xml (revision 77) +++ /branches/ATMSDriver/nbproject/private/private.xml (revision 79) @@ -3,9 +3,5 @@ <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/2" lastBookmarkId="0"/> <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2"> - <group> - <file>file:/home/andrew/branches/ATMSDriver/src/atmsdriver/ATMSDriver.java</file> - <file>file:/home/andrew/branches/ATMSDriver/src/atmsdriver/NetworkReader.java</file> - <file>file:/home/andrew/branches/ATMSDriver/src/atmsdriver/network/model/Network.java</file> - </group> + <group/> </open-files> </project-private>