{

// Bind() is a method used to re-associate the solver with a given network dataset and its schema. Calling Bind()

// on the solver re-attaches the solver to the NAContext based on the current network dataset settings.

// This is typically used to update the solver and its context based on changes in the network dataset's available

// restrictions, hierarchy attributes, cost attributes, etc.

// load network attributes for later configuration and usage

// this will be used to load restriction and also to load proper impedance (cost) value

INetworkAttribute2Ptr networkAttrib = nullptr;

long count, i;

HRESULT hr = S_OK;

esriNetworkAttributeUsageType utype;

esriNetworkAttributeDataType dtype;

IUnknownPtr unk;

if (pNetwork)

{

if (FAILED(hr = pNetwork->get_Attributes(&allAttribs))) return hr;

if (FAILED(hr = allAttribs->get_Count(&count))) return hr;

turnAttribs.clear();

costAttribs.clear();

discriptiveAttribs.clear();

for (i = 0; i < count; i++)

{

if (FAILED(hr = allAttribs->get_Element(i, &unk))) return hr;

networkAttrib = unk;

if (FAILED(hr = networkAttrib->get_UsageType(&utype))) return hr;

if (FAILED(hr = networkAttrib->get_DataType(&dtype))) return hr;

if (utype == esriNAUTRestriction) turnAttribs.insert(turnAttribs.end(), networkAttrib);

else if (utype == esriNAUTCost) costAttribs.insert(costAttribs.end(), networkAttrib);

else if (utype == esriNAUTDescriptor && (dtype == esriNADTDouble || dtype == esriNADTInteger))

discriptiveAttribs.insert(discriptiveAttribs.end(), networkAttrib);

}

if (costAttribs.size() < 1 && pMessages) pMessages->AddError(-1, L"There are no cost attributes in the network dataset.");

if (discriptiveAttribs.size() < 1 && pMessages) pMessages->AddError(-1, L"There are no descriptive attributes in the network dataset to be used as street capacity.");

if (costAttributeID == -1 && costAttribs.size() > 0) costAttribs[0]->get_ID(&costAttributeID);

if (capAttributeID == -1 && discriptiveAttribs.size() > 0) discriptiveAttribs[0]->get_ID(&capAttributeID);

// Agents setup

// NOTE: this is an appropriate place to find and attach any agents used by this solver.

// For example, the route solver would attach the directions agent.

INamedSetPtr agents;

IUnknownPtr pStreet;

INAContextHelperPtr ipContextHelper(pContext);

if (FAILED(hr = pContext->get_Agents(&agents))) return hr;

if (FAILED(hr = agents->get_ItemByName(L"StreetDirectionsAgent", &pStreet))) return hr;

if (!pStreet)

{

pStreetAgent = INAStreetDirectionsAgentPtr(CLSID_NAStreetDirectionsAgent);

((INAAgentPtr)pStreetAgent)->Initialize(pNetwork, ipContextHelper);

if (FAILED(hr = agents->Add(L"StreetDirectionsAgent", pStreetAgent))) return hr;

}

else pStreetAgent = pStreet;

}

return hr;

{

if (!ppLayer) return E_POINTER;

*ppLayer = nullptr;

// This is an appropriate place to check if the user is licensed to run

// your solver and fail with "E_NOT_LICENSED" or similar.

// Create our custom symbolizer and use it to create the NALayer.

// NOTE: we are assuming here that there is only one symbolizer to

// consider. The Network Analyst framework and ESRI solvers support the notion

// that there can be many symbolizers in CATID_NetworkAnalystSymbolizer.

// One can iterate the objects in this category and call the Applies()

// method to see if the symbolizer should be used for a particular solver/context.

// There is also a get_Priority() method that is used to determine which

// to use if many Apply.

INASymbolizerPtr ipNASymbolizer(CLSID_EvcSolverSymbolizer);

return ipNASymbolizer->CreateLayer(pContext, ppLayer);

{

if (!pLayer || !pLayerUpdated) return E_POINTER;

// This method is called after Solve() and gives us a chance to react to the results of

// the Solve and change the layer. For example, the Service Area solver updates

// its layer renderers after Solve has been called to adjust for unique values.

// We will not need to update our layer, since our renderers will remain the same throughout

*pLayerUpdated = VARIANT_FALSE;

return S_OK;

{

if (!pNetwork || !ppNAContext) return E_POINTER;

if (!contextName || !::wcslen(contextName)) return E_INVALIDARG;

HRESULT hr;

*ppNAContext = nullptr;

// CreateContext() is called by the command that creates the solver and

// initializes it. Below we'll:

//

// - create the class definitions

// - set up defaults

//

// After this method is called, this class should be prepared to have

// its solve method called.

// This is an appropriate place to check if the user is licensed to run

// your solver and fail with "E_NOT_LICENSED" or similar.

// Get the NDS SpatialRef, that will be the same for the context as well as all spatial NAClasses

IDEGeoDatasetPtr ipDEGeoDataset(pNetwork);

if (!ipDEGeoDataset) return E_INVALIDARG;

ISpatialReferencePtr ipNAContextSR;

if (FAILED(hr = ipDEGeoDataset->get_SpatialReference(&ipNAContextSR))) return hr;

IUnknownPtr ipUnknown;

INamedSetPtr ipNAClassDefinitions;

INAClassDefinitionPtr ipEvacueePointsClassDef, ipRoutesClassDef, ipZonesClassDef, ipEdgeStatClassDef, ipFlocksClassDef, ipDynamicChangeClassDef;

// Build the class definitions

if (FAILED(hr = BuildClassDefinitions(ipNAContextSR, &ipNAClassDefinitions, pNetwork))) return hr;

ipNAClassDefinitions->get_ItemByName(ATL::CComBSTR(CS_EVACUEES_NAME), &ipUnknown);

ipEvacueePointsClassDef = ipUnknown;

ipNAClassDefinitions->get_ItemByName(ATL::CComBSTR(CS_ZONES_NAME), &ipUnknown);

ipZonesClassDef = ipUnknown;

ipNAClassDefinitions->get_ItemByName(ATL::CComBSTR(CS_DYNCHANGES_NAME), &ipUnknown);

ipDynamicChangeClassDef = ipUnknown;

ipNAClassDefinitions->get_ItemByName(ATL::CComBSTR(CS_ROUTES_NAME), &ipUnknown);

ipRoutesClassDef = ipUnknown;

ipNAClassDefinitions->get_ItemByName(ATL::CComBSTR(CS_EDGES_NAME), &ipUnknown);

ipEdgeStatClassDef = ipUnknown;

ipNAClassDefinitions->get_ItemByName(ATL::CComBSTR(CS_FLOCKS_NAME), &ipUnknown);

ipFlocksClassDef = ipUnknown;

// Create a context and initialize it

INAContextPtr ipNAContext(CLSID_NAContext);

INAContextEditPtr ipNAContextEdit(ipNAContext);

if (FAILED(hr = ipNAContextEdit->Initialize(contextName, pNetwork))) return hr;

if (FAILED(hr = ipNAContextEdit->putref_Solver(static_cast<INASolver*>(this)))) return hr;

// Create NAClasses for each of our class definitions

INamedSetPtr ipNAClasses;

INAClassPtr ipNAClass;

if (FAILED(hr = ipNAContext->get_NAClasses(&ipNAClasses))) return hr;

if (FAILED(hr = ipNAContextEdit->CreateAnalysisClass(ipZonesClassDef, &ipNAClass))) return hr;

if (FAILED(hr = ipNAClasses->Add(ATL::CComBSTR(CS_ZONES_NAME), (IUnknownPtr)ipNAClass))) return hr;

if (FAILED(hr = ipNAContextEdit->CreateAnalysisClass(ipEvacueePointsClassDef, &ipNAClass))) return hr;

if (FAILED(hr = ipNAClasses->Add(ATL::CComBSTR(CS_EVACUEES_NAME), (IUnknownPtr)ipNAClass))) return hr;

if (FAILED(hr = ipNAContextEdit->CreateAnalysisClass(ipDynamicChangeClassDef, &ipNAClass))) return hr;

if (FAILED(hr = ipNAClasses->Add(ATL::CComBSTR(CS_DYNCHANGES_NAME), (IUnknownPtr)ipNAClass))) return hr;

if (FAILED(hr = ipNAContextEdit->CreateAnalysisClass(ipRoutesClassDef, &ipNAClass))) return hr;

if (FAILED(hr = ipNAClasses->Add(ATL::CComBSTR(CS_ROUTES_NAME), (IUnknownPtr)ipNAClass))) return hr;

if (FAILED(hr = ipNAContextEdit->CreateAnalysisClass(ipEdgeStatClassDef, &ipNAClass))) return hr;

if (FAILED(hr = ipNAClasses->Add(ATL::CComBSTR(CS_EDGES_NAME), (IUnknownPtr)ipNAClass))) return hr;

if (FAILED(hr = ipNAContextEdit->CreateAnalysisClass(ipFlocksClassDef, &ipNAClass))) return hr;

if (FAILED(hr = ipNAClasses->Add(ATL::CComBSTR(CS_FLOCKS_NAME), (IUnknownPtr)ipNAClass))) return hr;

// NOTE: this is an appropriate place to set up any hierarchy defaults if your

// solver supports using a hierarchy attribute (this solver does not). This is

// also an appropriate place to set the default impedance attribute if you

// had one.

// Initialize the default field mappings

// NOTE: this is an appropriate place to set up any default field mappings to be used

// Return the context once it has been fully created and initialized

*ppNAContext = ipNAContext;

ipNAContext->AddRef();

// Set up our solver defaults

m_outputLineType = esriNAOutputLineTrueShapeWithMeasure;

costAttributeID = -1;

capAttributeID = -1;

SaturationPerCap = 500.0;

CriticalDensPerCap = 10.0;

solverMethod = EvcSolverMethod::CASPERSolver;

trafficModel = EvcTrafficModel::POWERModel;

flockingProfile = FLOCK_PROFILE_CAR;

m_CreateTraversalResult = VARIANT_TRUE;

m_FindBestSequence = VARIANT_FALSE;

m_PreserveFirstStop = VARIANT_FALSE;

m_PreserveLastStop = VARIANT_FALSE;

m_UseTimeWindows = VARIANT_FALSE;

evacueeGroupingOption = EvacueeGrouping::None;

CASPERDynamicMode = DynamicMode::Simple;

VarExportEdgeStat = VARIANT_TRUE;

costPerDensity = 0.0f;

flockingEnabled = VARIANT_FALSE;

twoWayShareCapacity = VARIANT_TRUE;

ThreeGenCARMA = VARIANT_TRUE;

flockingSnapInterval = 0.1f;

flockingSimulationInterval = 0.01;

initDelayCostPerPop = 0.01;

CARMAPerformanceRatio = 0.1f;

selfishRatio = 0.0f;

iterateRatio = 0.6f;

backtrack = esriNFSBAllowBacktrack;

CarmaSortCriteria = CARMASort::BWCont;

savedVersion = c_version;

return S_OK;

{

// UpdateContext() is a method used to update the context based on any changes that may have been made to the

// solver settings. This typically includes changes to the set of accumulation attribute names, etc., which can

// be set as fields in the context's NAClass schemas

return S_OK;

{

if (!pStm) return E_POINTER;

ULONG numBytes;

HRESULT hr;

// We need to check the saved version number

if (FAILED(hr = pStm->Read(&savedVersion, sizeof(savedVersion), &numBytes))) return hr;

// We only support versions less than or equal to the current c_version

if (savedVersion > c_version || savedVersion <= 0) return E_FAIL;

// We need to read our persisted solver settings

// version 1

if (FAILED(hr = pStm->Read(&m_outputLineType, sizeof(m_outputLineType), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&costAttributeID, sizeof(costAttributeID), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&capAttributeID, sizeof(capAttributeID), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&trafficModel, sizeof(trafficModel), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&solverMethod, sizeof(solverMethod), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&SaturationPerCap, sizeof(SaturationPerCap), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&CriticalDensPerCap, sizeof(CriticalDensPerCap), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&m_CreateTraversalResult, sizeof(m_CreateTraversalResult), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&m_FindBestSequence, sizeof(m_FindBestSequence), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&m_PreserveFirstStop, sizeof(m_PreserveFirstStop), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&m_PreserveLastStop, sizeof(m_PreserveLastStop), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&m_UseTimeWindows, sizeof(m_UseTimeWindows), &numBytes))) return hr;

if (savedVersion < 7)

{

VARIANT_BOOL separable;

evacueeGroupingOption = EvacueeGrouping::None;

if (FAILED(hr = pStm->Read(&separable, sizeof(separable), &numBytes))) return hr;

if (separable == VARIANT_TRUE) evacueeGroupingOption |= EvacueeGrouping::Separate;

}

else if (FAILED(hr = pStm->Read(&evacueeGroupingOption, sizeof(evacueeGroupingOption), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&VarExportEdgeStat, sizeof(VarExportEdgeStat), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&backtrack, sizeof(backtrack), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&costPerDensity, sizeof(costPerDensity), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&flockingEnabled, sizeof(flockingEnabled), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&flockingSnapInterval, sizeof(flockingSnapInterval), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&flockingSimulationInterval, sizeof(flockingSimulationInterval), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&twoWayShareCapacity, sizeof(twoWayShareCapacity), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&initDelayCostPerPop, sizeof(initDelayCostPerPop), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&flockingProfile, sizeof(flockingProfile), &numBytes))) return hr;

if (FAILED(hr = pStm->Read(&CARMAPerformanceRatio, sizeof(CARMAPerformanceRatio), &numBytes))) return hr;

//version 2

if (savedVersion >= 2)

{

if (FAILED(hr = pStm->Read(&ThreeGenCARMA, sizeof(ThreeGenCARMA), &numBytes))) return hr;

}

else

{

ThreeGenCARMA = VARIANT_TRUE;

savedVersion = 2;

}

//version 4

if (savedVersion >= 4)

{

if (FAILED(hr = pStm->Read(&selfishRatio, sizeof(selfishRatio), &numBytes))) return hr;

}

else

{

selfishRatio = 0.0f;

savedVersion = 4;

}

//version 5

if (savedVersion >= 5)

{

if (FAILED(hr = pStm->Read(&CarmaSortCriteria, sizeof(CarmaSortCriteria), &numBytes))) return hr;

}

else

{

CarmaSortCriteria = CARMASort::BWCont;

savedVersion = 5;

}

//version 6

if (savedVersion >= 6)

{

if (FAILED(hr = pStm->Read(&iterateRatio, sizeof(iterateRatio), &numBytes))) return hr;

}

else

{

iterateRatio = 0.0f;

savedVersion = 6;

}

//version 6

if (savedVersion >= 8)

{

if (FAILED(hr = pStm->Read(&CASPERDynamicMode, sizeof(CASPERDynamicMode), &numBytes))) return hr;

}

else

{

CASPERDynamicMode = DynamicMode::Disabled;

savedVersion = 8;

}

CARMAPerformanceRatio = min(max(CARMAPerformanceRatio, 0.0f), 1.0f);

selfishRatio = min(max(selfishRatio, 0.0f), 1.0f);

iterateRatio = min(max(iterateRatio, 0.0f), 1.0f);

m_bPersistDirty = false;

return S_OK;

{

if (fClearDirty) m_bPersistDirty = false;

ULONG numBytes;

HRESULT hr;

// We need to persist the c_version number

if (FAILED(hr = pStm->Write(&c_version, sizeof(c_version), &numBytes))) return hr;

// We need to persist our solver settings

if (FAILED(hr = pStm->Write(&m_outputLineType, sizeof(m_outputLineType), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&costAttributeID, sizeof(costAttributeID), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&capAttributeID, sizeof(capAttributeID), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&trafficModel, sizeof(trafficModel), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&solverMethod, sizeof(solverMethod), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&SaturationPerCap, sizeof(SaturationPerCap), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&CriticalDensPerCap, sizeof(CriticalDensPerCap), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&m_CreateTraversalResult, sizeof(m_CreateTraversalResult), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&m_FindBestSequence, sizeof(m_FindBestSequence), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&m_PreserveFirstStop, sizeof(m_PreserveFirstStop), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&m_PreserveLastStop, sizeof(m_PreserveLastStop), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&m_UseTimeWindows, sizeof(m_UseTimeWindows), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&evacueeGroupingOption, sizeof(evacueeGroupingOption), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&VarExportEdgeStat, sizeof(VarExportEdgeStat), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&backtrack, sizeof(backtrack), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&costPerDensity, sizeof(costPerDensity), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&flockingEnabled, sizeof(flockingEnabled), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&flockingSnapInterval, sizeof(flockingSnapInterval), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&flockingSimulationInterval, sizeof(flockingSimulationInterval), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&twoWayShareCapacity, sizeof(twoWayShareCapacity), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&initDelayCostPerPop, sizeof(initDelayCostPerPop), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&flockingProfile, sizeof(flockingProfile), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&CARMAPerformanceRatio, sizeof(CARMAPerformanceRatio), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&ThreeGenCARMA, sizeof(ThreeGenCARMA), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&selfishRatio, sizeof(selfishRatio), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&CarmaSortCriteria, sizeof(CarmaSortCriteria), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&iterateRatio, sizeof(iterateRatio), &numBytes))) return hr;

if (FAILED(hr = pStm->Write(&CASPERDynamicMode, sizeof(CASPERDynamicMode), &numBytes))) return hr;

return S_OK;

{

if (!pCbSize) return E_POINTER;

pCbSize->HighPart = 0;

pCbSize->LowPart = sizeof(short);

return S_OK;

{

if (!pClassID) return E_POINTER;

*pClassID = __uuidof(EvcSolver);

return S_OK;

{

if (!pSpatialRef || !ppDefinitions) return E_POINTER;

// This function creates the class definitions for the EvcSolver.

// Recall, class definitions are in-memory feature classes that store the

// inputs and outputs for a solver. This solver's class definitions are:

// Zones (input) Safe zones determine the end locations

// - OID of the search

// - Shape

// - Name

// - (NALocation fields)

// Evacuee Points (input) Evacuee points determine the start locations

// - OID of the search

// - Shape

// - Name

// - Population number of un-seperatable people/cars at this location

// - (NALocation fields)

// Routes (output) Evacuation routes

// - OID

// - Shape evacuation route (polyline)

// - EvcOID Evacuee user ID

// - EvcTime Evacuation cost on this route

// - OrgTime Evacuation cost assuming unlimited capacity

// - RoutedPop The population who would use this route

// Edges (output) Edge/street lines with their population reservations

// - OID

// - Shape edge/street shape (polyline)

// - EdgeID Edge ID from NetworkDataset. there could be at most two edges (different directions) with one edgeID.

// - Direction Direction of travel on this edge

// - SourceID Refers to source street file ID

// - SourceOID Refers to oid of the shape in the street file

// - ReservPop The total population who would use this edge at some time

// - TravCost Traversal cost based on the selected evacuation method on this edge

// - OrgCost Original traversal cost of the edge without any population

HRESULT hr = S_OK;

// Create the class definitions named set and the variables needed to properly instantiate them

INamedSetPtr ipClassDefinitions(CLSID_NamedSet);

INAClassDefinitionPtr ipClassDef;

INAClassDefinitionEditPtr ipClassDefEdit;

IUIDPtr ipIUID;

IFieldsPtr ipFields;

IFieldsEditPtr ipFieldsEdit;

IFieldPtr ipField;

IFieldEditPtr ipFieldEdit;

//******************************************************************************************/

// Zones class definition

ipClassDef.CreateInstance(CLSID_NAClassDefinition);

ipClassDefEdit = ipClassDef;

ipIUID.CreateInstance(CLSID_UID);

if (FAILED(hr = ipIUID->put_Value(ATL::CComVariant(L"esriNetworkAnalyst.NALocationFeature")))) return hr;

ipClassDefEdit->putref_ClassCLSID(ipIUID);

// Create the fields for the class definition

ipFields.CreateInstance(CLSID_Fields);

ipFieldsEdit = ipFields;

// Create and add an OID field

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_OID));

ipFieldEdit->put_Type(esriFieldTypeOID);

ipFieldsEdit->AddField(ipFieldEdit);

// Create and add a Shape field

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

{

IGeometryDefEditPtr ipGeoDef(CLSID_GeometryDef);

ipGeoDef->put_GeometryType(esriGeometryPoint);

ipGeoDef->put_HasM(VARIANT_FALSE);

ipGeoDef->put_HasZ(VARIANT_FALSE);

ipGeoDef->putref_SpatialReference(pSpatialRef);

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_SHAPE));

ipFieldEdit->put_IsNullable(VARIANT_TRUE);

ipFieldEdit->put_Type(esriFieldTypeGeometry);

ipFieldEdit->putref_GeometryDef(ipGeoDef);

}

ipFieldsEdit->AddField(ipFieldEdit);

// Create and add a Name field

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_NAME));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

// Create and add a capacity field

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_CAP));

ipFieldEdit->put_Type(esriFieldTypeDouble); // it use to be String. Have to be careful when I'm reading numbers from this field

ipFieldEdit->put_DefaultValue(ATL::CComVariant(-1.0));

ipFieldEdit->put_IsNullable(VARIANT_FALSE);

ipFieldsEdit->AddField(ipFieldEdit);

// Add the NALocation fields

AddLocationFields(ipFieldsEdit, pDENDS);

// Add the new fields to the class definition (these must be set before setting field types)

ipClassDefEdit->putref_Fields(ipFields);

// Setup the field types (i.e., input/output fields, editable/non-editable fields, visible/non-visible fields, or a combination of these)

AddLocationFieldTypes(ipClassDefEdit);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_OID), esriNAFieldTypeInput | esriNAFieldTypeNotEditable);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_SHAPE), esriNAFieldTypeInput | esriNAFieldTypeNotEditable | esriNAFieldTypeNotVisible);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_NAME), esriNAFieldTypeInput);

// Setup whether the NAClass is considered as input/output

ipClassDefEdit->put_IsInput(VARIANT_TRUE);

ipClassDefEdit->put_IsOutput(VARIANT_FALSE);

// Setup necessary cardinality for allowing a Solve to be run

// NOTE: the LowerBound property is used to define the minimum number of required NALocationObjects that are required by the solver

// to perform analysis. The UpperBound property is used to define the maximum number of NALocationObjects that are allowed by the solver

// to perform analysis.

// In our case, we must have at least one zone point stored in the class before allowing Solve to enabled in ArcMap, and we have no UpperBound

ipClassDefEdit->put_LowerBound(1);

// Give the class definition a name...

ipClassDefEdit->put_Name(ATL::CComBSTR(CS_ZONES_NAME));

// ...and add it to the named set

ipClassDefinitions->Add(ATL::CComBSTR(CS_ZONES_NAME), (IUnknownPtr)ipClassDef);

//******************************************************************************************/

// Evacuee Points class definition

ipClassDef.CreateInstance(CLSID_NAClassDefinition);

ipClassDefEdit = ipClassDef;

ipIUID.CreateInstance(CLSID_UID);

if (FAILED(hr = ipIUID->put_Value(ATL::CComVariant(L"esriNetworkAnalyst.NALocationFeature")))) return hr;

ipClassDefEdit->putref_ClassCLSID(ipIUID);

// Create the fields for the class definition

ipFields.CreateInstance(CLSID_Fields);

ipFieldsEdit = ipFields;

// Create and add an OID field

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_OID));

ipFieldEdit->put_Type(esriFieldTypeOID);

ipFieldsEdit->AddField(ipFieldEdit);

// Create and add an population field

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_EVC_POP2));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldEdit->put_DefaultValue(ATL::CComVariant(1.0));

ipFieldEdit->put_IsNullable(VARIANT_FALSE);

ipFieldsEdit->AddField(ipFieldEdit);

// Create and add a Shape field

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

{

IGeometryDefEditPtr ipGeoDef(CLSID_GeometryDef);

ipGeoDef->put_GeometryType(esriGeometryPoint);

ipGeoDef->put_HasM(VARIANT_FALSE);

ipGeoDef->put_HasZ(VARIANT_FALSE);

ipGeoDef->putref_SpatialReference(pSpatialRef);

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_SHAPE));

ipFieldEdit->put_IsNullable(VARIANT_TRUE);

ipFieldEdit->put_Type(esriFieldTypeGeometry);

ipFieldEdit->putref_GeometryDef(ipGeoDef);

}

ipFieldsEdit->AddField(ipFieldEdit);

// Create and add a Name field

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_NAME));

ipFieldEdit->put_Type(esriFieldTypeString);

ipFieldEdit->put_Length(128);

ipFieldsEdit->AddField(ipFieldEdit);

// Add the NALocation fields

AddLocationFields(ipFieldsEdit, pDENDS);

// Add the new fields to the class definition (these must be set before setting field types)

ipClassDefEdit->putref_Fields(ipFields);

// Setup the field types (i.e., input/output fields, editable/non-editable fields, visible/non-visible fields, or a combination of these)

AddLocationFieldTypes(ipClassDefEdit);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_OID), esriNAFieldTypeInput | esriNAFieldTypeNotEditable);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_SHAPE), esriNAFieldTypeInput | esriNAFieldTypeNotEditable | esriNAFieldTypeNotVisible);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_NAME), esriNAFieldTypeInput);

// Setup whether the NAClass is considered as input/output

ipClassDefEdit->put_IsInput(VARIANT_TRUE);

ipClassDefEdit->put_IsOutput(VARIANT_FALSE);

// Setup necessary cardinality for allowing a Solve to be run

// NOTE: the LowerBound property is used to define the minimum number of required NALocationObjects that are required by the solver

// to perform analysis. The UpperBound property is used to define the maximum number of NALocationObjects that are allowed by the solver

// to perform analysis.

// In our case, we must have at least one Evacuee point stored in the class before allowing Solve to enabled in ArcMap, and we have no UpperBound

ipClassDefEdit->put_LowerBound(1);

// Give the class definition a name...

ipClassDefEdit->put_Name(ATL::CComBSTR(CS_EVACUEES_NAME));

// ...and add it to the named set

ipClassDefinitions->Add(ATL::CComBSTR(CS_EVACUEES_NAME), (IUnknownPtr)ipClassDef);

//******************************************************************************************/

// DynamicChanges class definition

ipClassDef.CreateInstance(CLSID_NAClassDefinition);

ipClassDefEdit = ipClassDef;

ipIUID.CreateInstance(CLSID_UID);

if (FAILED(hr = ipIUID->put_Value(ATL::CComVariant(L"esriNetworkAnalyst.NALocationRangesFeature")))) return hr;

if (FAILED(hr = ipClassDefEdit->putref_ClassCLSID(ipIUID))) return hr;

// set up coded value domains for the the dynamic changes status values

ICodedValueDomainPtr ipCodedValueDomainEdgeDir(CLSID_CodedValueDomain), ipCodedValueDomainEvcStuck(CLSID_CodedValueDomain);

CreateEdgeDirCodedValueDomain(ipCodedValueDomainEdgeDir);

CreateEvcStuckCodedValueDomain(ipCodedValueDomainEvcStuck);

ipFields.CreateInstance(CLSID_Fields);

ipFieldsEdit = ipFields;

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_OID));

ipFieldEdit->put_Type(esriFieldTypeOID);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

{

IGeometryDefEditPtr ipGeoDef(CLSID_GeometryDef);

ipGeoDef->put_GeometryType(esriGeometryPolygon);

ipGeoDef->put_HasM(VARIANT_FALSE);

ipGeoDef->put_HasZ(VARIANT_FALSE);

ipGeoDef->putref_SpatialReference(pSpatialRef);

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_SHAPE));

ipFieldEdit->put_IsNullable(VARIANT_TRUE);

ipFieldEdit->put_Type(esriFieldTypeGeometry);

ipFieldEdit->putref_GeometryDef(ipGeoDef);

}

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(L"Locations"));

ipFieldEdit->put_Type(esriFieldTypeBlob);

ipFieldEdit->put_Required(VARIANT_TRUE);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_DYNROADDIR));

ipFieldEdit->put_Type(esriFieldTypeInteger);

ipFieldEdit->put_DefaultValue(ATL::CComVariant(static_cast<long>(EdgeDirection::Both)));

ipFieldEdit->putref_Domain((IDomainPtr)ipCodedValueDomainEdgeDir);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_DYNSTARTTIME));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldEdit->put_DefaultValue(ATL::CComVariant(0.0));

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_DYNENDTIME));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldEdit->put_DefaultValue(ATL::CComVariant(-1.0));

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_DYNCOST));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldEdit->put_DefaultValue(ATL::CComVariant(10.0));

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_DYNCAPACITY));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldEdit->put_DefaultValue(ATL::CComVariant(1.0));

ipFieldsEdit->AddField(ipFieldEdit);

//ipField.CreateInstance(CLSID_Field);

//ipFieldEdit = ipField;

//ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_DYNEVCSTUCK));

//ipFieldEdit->put_Type(esriFieldTypeInteger);

//ipFieldEdit->put_DefaultValue(ATL::CComVariant(long(1)));

//ipFieldEdit->putref_Domain((IDomainPtr)ipCodedValueDomainEvcStuck);

//ipFieldsEdit->AddField(ipFieldEdit);

ipClassDefEdit->putref_Fields(ipFields);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_OID), esriNAFieldTypeInput | esriNAFieldTypeNotEditable);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_SHAPE), esriNAFieldTypeInput | esriNAFieldTypeNotEditable | esriNAFieldTypeNotVisible);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(L"Locations"), esriNAFieldTypeInput | esriNAFieldTypeNotEditable);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_DYNROADDIR), esriNAFieldTypeInput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_DYNSTARTTIME), esriNAFieldTypeInput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_DYNENDTIME), esriNAFieldTypeInput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_DYNCOST), esriNAFieldTypeInput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_DYNCAPACITY), esriNAFieldTypeInput);

// ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_DYNEVCSTUCK), esriNAFieldTypeInput);

ipClassDefEdit->put_IsInput(VARIANT_TRUE);

ipClassDefEdit->put_IsOutput(VARIANT_FALSE);

ipClassDefEdit->put_Name(ATL::CComBSTR(CS_DYNCHANGES_NAME));

ipClassDefinitions->Add(ATL::CComBSTR(CS_DYNCHANGES_NAME), (IUnknownPtr)ipClassDef);

//******************************************************************************************/

// Flocks class definition

ipClassDef.CreateInstance(CLSID_NAClassDefinition);

ipClassDefEdit = ipClassDef;

ipIUID.CreateInstance(CLSID_UID);

if (FAILED(hr = ipIUID->put_Value(ATL::CComVariant(L"esriGeoDatabase.Feature")))) return hr;

ipClassDefEdit->putref_ClassCLSID(ipIUID);

ipFields.CreateInstance(CLSID_Fields);

ipFieldsEdit = ipFields;

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_OID));

ipFieldEdit->put_Type(esriFieldTypeOID);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

{

IGeometryDefEditPtr ipGeoDef(CLSID_GeometryDef);

ipGeoDef->put_GeometryType(esriGeometryPoint);

ipGeoDef->put_HasM(VARIANT_FALSE);

ipGeoDef->put_HasZ(VARIANT_FALSE);

ipGeoDef->putref_SpatialReference(pSpatialRef);

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_SHAPE));

ipFieldEdit->put_IsNullable(VARIANT_TRUE);

ipFieldEdit->put_Type(esriFieldTypeGeometry);

ipFieldEdit->putref_GeometryDef(ipGeoDef);

}

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_NAME));

ipFieldEdit->put_Type(esriFieldTypeString);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_ID));

ipFieldEdit->put_Type(esriFieldTypeInteger);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_COST));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_VelocityX));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_VelocityY));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_SPEED));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_TRAVELED));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_TIME));

ipFieldEdit->put_Type(esriFieldTypeString);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_PTIME));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_STATUS));

ipFieldEdit->put_Type(esriFieldTypeString);

ipFieldEdit->put_Length(1);

// set up coded value domains for the the flocking status values

ICodedValueDomainPtr ipCodedValueDomain(CLSID_CodedValueDomain);

CreateFlockingCodedValueDomain(ipCodedValueDomain);

ipFieldEdit->putref_Domain((IDomainPtr)ipCodedValueDomain);

ipFieldsEdit->AddField(ipFieldEdit);

ipClassDefEdit->putref_Fields(ipFields);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_OID), esriNAFieldTypeOutput | esriNAFieldTypeNotEditable);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_SHAPE), esriNAFieldTypeOutput | esriNAFieldTypeNotEditable | esriNAFieldTypeNotVisible);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_ID), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_NAME), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_VelocityX), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_VelocityY), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_SPEED), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_TRAVELED), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_TIME), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_PTIME), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_STATUS), esriNAFieldTypeOutput);

ipClassDefEdit->put_IsInput(VARIANT_FALSE);

ipClassDefEdit->put_IsOutput(VARIANT_TRUE);

ipClassDefEdit->put_Name(ATL::CComBSTR(CS_FLOCKS_NAME));

ipClassDefinitions->Add(ATL::CComBSTR(CS_FLOCKS_NAME), (IUnknownPtr)ipClassDef);

//******************************************************************************************/

// Routes class definition

ipClassDef.CreateInstance(CLSID_NAClassDefinition);

ipClassDefEdit = ipClassDef;

ipIUID.CreateInstance(CLSID_UID);

if (FAILED(hr = ipIUID->put_Value(ATL::CComVariant(L"esriGeoDatabase.Feature")))) return hr;

ipClassDefEdit->putref_ClassCLSID(ipIUID);

ipFields.CreateInstance(CLSID_Fields);

ipFieldsEdit = ipFields;

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_OID));

ipFieldEdit->put_Type(esriFieldTypeOID);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

{

IGeometryDefEditPtr ipGeoDef(CLSID_GeometryDef);

ipGeoDef->put_GeometryType(esriGeometryPolyline);

ipGeoDef->put_HasM(VARIANT_FALSE);

ipGeoDef->put_HasZ(VARIANT_FALSE);

ipGeoDef->putref_SpatialReference(pSpatialRef);

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_SHAPE));

ipFieldEdit->put_IsNullable(VARIANT_TRUE);

ipFieldEdit->put_Type(esriFieldTypeGeometry);

ipFieldEdit->putref_GeometryDef(ipGeoDef);

}

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_RID));

ipFieldEdit->put_Type(esriFieldTypeInteger);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_EVC_NAME));

ipFieldEdit->put_Type(esriFieldTypeString);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_E_TIME));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_E_ORG));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_EVC_POP2));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_ZONENAME));

ipFieldEdit->put_Type(esriFieldTypeDouble);

ipFieldsEdit->AddField(ipFieldEdit);

ipClassDefEdit->putref_Fields(ipFields);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_OID), esriNAFieldTypeOutput | esriNAFieldTypeNotEditable);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_SHAPE), esriNAFieldTypeOutput | esriNAFieldTypeNotEditable | esriNAFieldTypeNotVisible);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_EVC_NAME), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_E_TIME), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_EVC_POP2), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_E_ORG), esriNAFieldTypeOutput);

ipClassDefEdit->put_FieldType(ATL::CComBSTR(CS_FIELD_ZONENAME), esriNAFieldTypeOutput);

ipClassDefEdit->put_IsInput(VARIANT_FALSE);

ipClassDefEdit->put_IsOutput(VARIANT_TRUE);

ipClassDefEdit->put_Name(ATL::CComBSTR(CS_ROUTES_NAME));

ipClassDefinitions->Add(ATL::CComBSTR(CS_ROUTES_NAME), (IUnknownPtr)ipClassDef);

//******************************************************************************************/

// EdgeStat class definition

ipClassDef.CreateInstance(CLSID_NAClassDefinition);

ipClassDefEdit = ipClassDef;

ipIUID.CreateInstance(CLSID_UID);

if (FAILED(hr = ipIUID->put_Value(ATL::CComVariant(L"esriGeoDatabase.Feature")))) return hr;

ipClassDefEdit->putref_ClassCLSID(ipIUID);

ipFields.CreateInstance(CLSID_Fields);

ipFieldsEdit = ipFields;

ipField.CreateInstance(CLSID_Field);

ipFieldEdit = ipField;

ipFieldEdit->put_Name(ATL::CComBSTR(CS_FIELD_OID));

ipFieldEdit->put_Type(esriFieldTypeOID);

ipFieldsEdit->AddField(ipFieldEdit);