void TestLogEngineConstructor_SeveralInstances ()
{
LogFileBackup ();
// scope to construct+destruct the object.
{
LogEngine logEngine (LOG_DEVELOPER, "TS1");
{
LogEngine logEngine2 (LOG_DEVELOPER, "TS2");
}
std::fstream testFile;
testFile.open (TestLogFile.c_str (), std::fstream::in);
char buf[4096];
testFile.read (buf, 4096);
std::string bufString (buf);
MAssert (bufString.find ("TS1") != std::string::npos);
MAssert (bufString.find ("TS2") != std::string::npos);
MAssert (bufString.find ("2 log engine") != std::string::npos);
MAssert (bufString.find ("s 0 log engine") == std::string::npos);
}
std::fstream testFile;
testFile.open (TestLogFile.c_str (), std::fstream::in);
char buf[4096];
testFile.read (buf, 4096);
std::string bufString (buf);
MAssert (bufString.find ("s 0 log engine") != std::string::npos);
LogFileRestore ();
}
static void KheMoveChildNode(KHE_NODE child_node, KHE_NODE swap_node)
{
int i, swap_offset; KHE_MEET child_meet, swap_meet;
ARRAY_KHE_MEET swap_meets; ARRAY_INT swap_offsets;
if( DEBUG3 )
{
fprintf(stderr, "[ KheMoveChildNode(");
KheNodeDebug(child_node, 1, -1, stderr);
fprintf(stderr, ", ");
KheNodeDebug(swap_node, 1, -1, stderr);
fprintf(stderr, ")\n");
}
/* store the current assignments and ensure all meets are unassigned */
MArrayInit(swap_meets);
MArrayInit(swap_offsets);
for( i = 0; i < KheNodeMeetCount(child_node); i++ )
{
child_meet = KheNodeMeet(child_node, i);
swap_meet = KheFindSwapTarget(child_meet, swap_node);
MArrayAddLast(swap_meets, swap_meet);
MArrayAddLast(swap_offsets, KheMeetAsstOffset(child_meet));
if( DEBUG3 )
{
fprintf(stderr, " saving child_meet: ");
KheMeetDebug(child_meet, 3, 0, stderr);
fprintf(stderr, " swap_meet: ");
KheMeetDebug(swap_meet, 3, 0, stderr);
}
KheMeetUnAssign(child_meet);
}
/* move the node */
if( !KheNodeDeleteParent(child_node) )
MAssert(false, "KheMoveChildNode internal error 1");
if( !KheNodeAddParent(child_node, swap_node) )
MAssert(false, "KheMoveChildNode internal error 2");
/* assign the meets as recorded */
for( i = 0; i < KheNodeMeetCount(child_node); i++ )
{
child_meet = KheNodeMeet(child_node, i);
swap_meet = MArrayGet(swap_meets, i);
swap_offset = MArrayGet(swap_offsets, i);
if( DEBUG3 )
{
fprintf(stderr, " restoring child_meet: ");
KheMeetDebug(child_meet, 3, 0, stderr);
fprintf(stderr, " swap_meet: ");
KheMeetDebug(swap_meet, 3, 0, stderr);
}
if( !KheMeetAssign(child_meet, swap_meet, swap_offset) )
MAssert(false, "KheMoveChildNode internal error 3");
}
MArrayFree(swap_meets);
MArrayFree(swap_offsets);
if( DEBUG3 )
fprintf(stderr, "] KheMoveChildNode returning\n");
}
void TestGetLogLevelCode ()
{
LogEngine l (LOG_WARNING, "TST");
MAssert (std::string ("EE") == l.GetLogLevelCode (LOG_ERROR));
MAssert (std::string ("WW") == l.GetLogLevelCode (LOG_WARNING));
MAssert (std::string ("UU") == l.GetLogLevelCode (LOG_ENDUSER));
MAssert (std::string ("CC") == l.GetLogLevelCode (LOG_CCREATOR));
MAssert (std::string ("DD") == l.GetLogLevelCode (LOG_DEVELOPER));
}
void notifyBacktrack(int untillevel) {
if(decisionlevel2trail.size()<=(uint)untillevel+1){ // Fake backtrack, only within current level
return;
}
for(uint i=decisionlevel2trail[(uint)untillevel+1]; i<trail.size(); ++i){
MAssert(trail.size()>i);
MAssert(var2time.size()>(uint)var(trail[i]));
var2time[var(trail[i])]=-1;
}
trail.resize(decisionlevel2trail[(uint)untillevel+1]);
decisionlevel2trail.resize((uint)untillevel+1);
}
char *KheLimitIdleTimesMonitorDeviationDescription(
KHE_LIMIT_IDLE_TIMES_MONITOR m, int i)
{
MAssert(i == 0,
"KheLimitIdleTimesMonitorDeviationDescription: i out of range");
return NULL;
}
char *KheAvoidUnavailableTimesMonitorDeviationDescription(
KHE_AVOID_UNAVAILABLE_TIMES_MONITOR m, int i)
{
MAssert(i == 0,
"KheAvoidUnavailableTimesMonitorDeviationDescription: i out of range");
return NULL;
}
bool KheSplitEventsConstraintMake(KHE_INSTANCE ins, char *id,
char *name, bool required, int weight, KHE_COST_FUNCTION cf,
int min_duration, int max_duration, int min_amount, int max_amount,
KHE_SPLIT_EVENTS_CONSTRAINT *c)
{
KHE_SPLIT_EVENTS_CONSTRAINT res;
KHE_CONSTRAINT cc;
MAssert(!KheInstanceComplete(ins),
"KheSplitEventsConstraintMake called after KheInstanceMakeEnd");
if( id != NULL && KheInstanceRetrieveConstraint(ins, id, &cc) )
{
*c = NULL;
return false;
}
MMake(res);
res->back = NULL;
res->tag = KHE_SPLIT_EVENTS_CONSTRAINT_TAG;
res->instance = ins;
res->id = id;
res->name = name;
res->required = required;
res->weight = weight;
res->combined_weight = required ? KheCost(weight, 0) : KheCost(0, weight);
res->cost_function = cf;
res->index = KheInstanceConstraintCount(ins);
res->min_duration = min_duration;
res->max_duration = max_duration;
res->min_amount = min_amount;
res->max_amount = max_amount;
MArrayInit(res->events);
MArrayInit(res->event_groups);
KheInstanceAddConstraint(ins, (KHE_CONSTRAINT) res);
*c = res;
return true;
}
char *KheLimitWorkloadMonitorDeviationDescription(
KHE_LIMIT_WORKLOAD_MONITOR m, int i)
{
MAssert(i == 0,
"KheLimitWorkloadMonitorDeviationDescription: i out of range");
return NULL;
}
char *KheOrdinaryDemandMonitorDeviationDescription(
KHE_ORDINARY_DEMAND_MONITOR m, int i)
{
MAssert(i == 0,
"KheOrdinaryDemandMonitorDeviationDescription: i out of range");
return NULL;
}
bool KheLimitWorkloadConstraintMake(KHE_INSTANCE ins, char *id,
char *name, bool required, int weight, KHE_COST_FUNCTION cf,
int minimum, int maximum, KHE_LIMIT_WORKLOAD_CONSTRAINT *c)
{
KHE_LIMIT_WORKLOAD_CONSTRAINT res; KHE_CONSTRAINT cc;
MAssert(!KheInstanceComplete(ins),
"KheLimitWorkloadConstraintMake called after KheInstanceMakeEnd");
if( id != NULL && KheInstanceRetrieveConstraint(ins, id, &cc) )
{
*c = NULL;
return false;
}
MMake(res);
res->back = NULL;
res->tag = KHE_LIMIT_WORKLOAD_CONSTRAINT_TAG;
res->instance = ins;
res->id = id;
res->name = name;
res->required = required;
res->weight = weight;
res->combined_weight = required ? KheCost(weight, 0) : KheCost(0, weight);
res->cost_function = cf;
res->index = KheInstanceConstraintCount(ins);
MArrayInit(res->resource_groups);
MArrayInit(res->resources);
res->minimum = minimum;
res->maximum = maximum;
KheInstanceAddConstraint(ins, (KHE_CONSTRAINT) res);
*c = res;
return true;
}
KHE_ORDINARY_DEMAND_MONITOR KheOrdinaryDemandMonitorMake(KHE_SOLN soln,
KHE_MATCHING_DEMAND_CHUNK dc, KHE_TASK task, int offset)
{
KHE_ORDINARY_DEMAND_MONITOR res;
MAssert(KheMatchingImpl(KheMatchingDemandChunkMatching(dc)) == (void *) soln,
"KheOrdinaryDemandMonitorMake internal error (%p != %p)",
KheMatchingImpl(KheMatchingDemandChunkMatching(dc)), (void *) soln);
MMake(res);
KheMonitorInitCommonFields((KHE_MONITOR) res, soln,
KHE_ORDINARY_DEMAND_MONITOR_TAG);
res->demand_chunk = dc;
res->domain = KheSolnMatchingZeroDomain(soln);
res->demand_asst = NULL;
res->demand_asst_index = NO_PREV_ASST;
res->unmatched_pos = -1; /* undefined at this point */
res->bfs_next = NULL;
res->bfs_parent = NULL;
res->hall_set = NULL;
res->task = task;
res->offset = offset;
res->copy = NULL;
/* KheGroupMonitorAddMonitor((KHE_GROUP_MONITOR) soln, (KHE_MONITOR) res); */
KheTaskAddDemandMonitor(task, res);
/* KheMonitorCheck((KHE_MONITOR) res); */
return res;
}
uint8_t
CModule_State::GetVal(
uint8_t inVar)
{
MAssert(inVar < eStateVar_Max);
return stateVar[inVar];
}
static bool KheNodeMatch(KHE_NODE layer_node, KHE_NODE other_node,
ARRAY_KHE_MEET *match)
{
int i, j; KHE_MEET layer_meet, other_meet;
j = 0;
for( i = 0; i < KheNodeMeetCount(other_node); i++ )
{
other_meet = KheNodeMeet(other_node, i);
if( KheMeetAsst(other_meet) != NULL )
{
layer_meet = MArrayGet(*match, j);
if( KheMeetAsst(layer_meet) == NULL )
{
if( DEBUG2 )
{
fprintf(stderr, " calling KheMeetAssign(");
KheMeetDebug(layer_meet, 1, -1, stderr);
fprintf(stderr, ", ");
KheMeetDebug(KheMeetAsst(other_meet), 1, -1, stderr);
fprintf(stderr, ", %d)\n", KheMeetAsstOffset(other_meet));
}
if( !KheMeetAssign(layer_meet, KheMeetAsst(other_meet),
KheMeetAsstOffset(other_meet)) )
MAssert(false, "KheNodeMatch internal error");
}
j++;
}
}
return true;
}
bool KheTimeMake(KHE_INSTANCE ins, char *id, char *name,
bool break_after, KHE_TIME *t)
{
KHE_TIME res;
MAssert(!KheInstanceComplete(ins),
"KheTimeMake called after KheInstanceMakeEnd");
if( id != NULL && KheInstanceRetrieveTime(ins, id, &res) )
{
*t = NULL;
return false;
}
MMake(res);
res->back = NULL;
res->instance = ins;
res->id = id;
res->name = name;
res->break_after = break_after;
/* res->inferred_break_after = true; */ /* just the initial value */
res->index = KheInstanceTimeCount(ins);
res->singleton_time_group = KheTimeGroupMakeInternal(
KHE_TIME_GROUP_TYPE_SINGLETON, ins, KHE_TIME_GROUP_KIND_ORDINARY,
NULL, NULL, LSetNew());
KheTimeGroupAddTimeInternal(res->singleton_time_group, res);
KheTimeGroupAddTimeInternal(KheInstanceFullTimeGroupInternal(ins), res);
/* res->cycle_soln_event_index = res->cycle_soln_event_offset = -1; */
/* set later */
KheInstanceAddTime(ins, res);
*t = res;
return true;
}
bool KheAssignResourceConstraintMake(KHE_INSTANCE ins, char *id,
char *name, bool required, int weight, KHE_COST_FUNCTION cf,
char *role, KHE_ASSIGN_RESOURCE_CONSTRAINT *c)
{
KHE_ASSIGN_RESOURCE_CONSTRAINT res; KHE_CONSTRAINT cc;
MAssert(!KheInstanceComplete(ins),
"KheAssignResourceConstraintMake called after KheInstanceMakeEnd");
if( id != NULL && KheInstanceRetrieveConstraint(ins, id, &cc) )
{
*c = NULL;
return false;
}
MMake(res);
res->back = NULL;
res->tag = KHE_ASSIGN_RESOURCE_CONSTRAINT_TAG;
res->instance = ins;
res->id = id;
res->name = name;
res->required = required;
res->weight = weight;
res->combined_weight = required ? KheCost(weight, 0) : KheCost(0, weight);
res->cost_function = cf;
res->index = KheInstanceConstraintCount(ins);
res->role = role;
MArrayInit(res->events);
MArrayInit(res->event_groups);
MArrayInit(res->event_resources);
KheInstanceAddConstraint(ins, (KHE_CONSTRAINT) res);
*c = res;
return true;
}
// --------------------------------------------------------------------------------------------
void polyModifierCmd::collectNodeState()
// --------------------------------------------------------------------------------------------
{
MStatus status;
// Collect node state information on the given polyMeshShape
//
// - HasHistory (Construction History exists)
// - HasTweaks
// - HasRecordHistory (Construction History is turned on)
//
fDagPath.extendToShape();
MObject meshNodeShape = fDagPath.node();
MFnDependencyNode depNodeFn;
depNodeFn.setObject( meshNodeShape );
MPlug inMeshPlug = depNodeFn.findPlug( "inMesh" );
fHasHistory = inMeshPlug.isConnected();
// Tweaks exist only if the multi "pnts" attribute contains plugs
// which contain non-zero tweak values. Use false, until proven true
// search algorithm.
//
fHasTweaks = false;
MPlug tweakPlug = depNodeFn.findPlug( "pnts" );
if( !tweakPlug.isNull() )
{
// ASSERT: tweakPlug should be an array plug!
//
MAssert( (tweakPlug.isArray()),
"tweakPlug.isArray() -- tweakPlug is not an array plug" );
MPlug tweak;
MFloatVector tweakData;
int i;
int numElements = tweakPlug.numElements();
for( i = 0; i < numElements; i++ )
{
tweak = tweakPlug.elementByPhysicalIndex( i, &status );
if( status == MS::kSuccess && !tweak.isNull() )
{
getFloat3PlugValue( tweak, tweakData );
if( 0 != tweakData.x ||
0 != tweakData.y ||
0 != tweakData.z )
{
fHasTweaks = true;
break;
}
}
}
}
int result;
MGlobal::executeCommand( "constructionHistory -q -tgl", result );
fHasRecordHistory = (0 != result);
}
void KheSolnGroupDeleteSoln(KHE_SOLN_GROUP soln_group, KHE_SOLN soln)
{
int pos;
if( !MArrayContains(soln_group->solutions, soln, &pos) )
MAssert(false, "KheSolnGroupDeleteSoln: soln not present");
MArrayRemove(soln_group->solutions, pos);
KheSolnSetSolnGroup(soln, NULL);
}
void
CModule_State::SetVal(
uint8_t inVar,
uint8_t inVal)
{
MAssert(inVar < eStateVar_Max);
stateVar[inVar] = inVal;
}
uint8_t
CModule_Config::GetVal(
uint8_t inVar)
{
Setup();
MAssert(inVar < eConfigVar_Max);
return configVar[inVar];
}
void KheDevMonitorUpdate(KHE_DEV_MONITOR *dm, int old_dev, int new_dev)
{
int pos;
dm->devs_changed = true;
if( !MArrayContains(dm->devs, old_dev, &pos) )
MAssert(false, "DevMonitorUpdate");
MArrayPut(dm->devs, pos, new_dev);
}
void KheSolnGroupAddSoln(KHE_SOLN_GROUP soln_group, KHE_SOLN soln)
{
MAssert(KheSolnGroupArchive(soln_group) ==
KheInstanceArchive(KheSolnInstance(soln)), "KheSolnGroupAddSoln: "
"soln_group and soln's instance lie in different archives");
MArrayAddLast(soln_group->solutions, soln);
KheSolnSetSolnGroup(soln, soln_group);
}
void KheOrdinaryDemandMonitorSetWeight(KHE_ORDINARY_DEMAND_MONITOR m,
KHE_COST new_weight)
{
MAssert(m->attached, "KheOrdinaryDemandMonitorSetWeight internal error");
if( m->demand_asst == NULL )
KheMonitorChangeCost((KHE_MONITOR) m, new_weight);
/* KheMonitorCheck((KHE_MONITOR) m); */
}
void KheOrdinaryDemandMonitorSetDomain(KHE_ORDINARY_DEMAND_MONITOR m,
KHE_RESOURCE_GROUP rg, KHE_MATCHING_DOMAIN_CHANGE_TYPE change_type)
{
MAssert(m->attached, "KheOrdinaryDemandMonitorSetDomain internal error");
KheMatchingDemandNodeSetDomain((KHE_MATCHING_DEMAND_NODE) m,
KheResourceGroupResourceIndexes(rg), change_type);
/* KheMonitorCheck((KHE_MONITOR) m); */
}
void KheAvoidUnavailableTimesMonitorDeleteBusyAndIdle(
KHE_AVOID_UNAVAILABLE_TIMES_MONITOR m, int busy_count, int idle_count)
{
MAssert(m->cost==KheConstraintCost((KHE_CONSTRAINT)m->constraint, busy_count),
"KheAvoidUnavailableTimesMonitorDeleteBusyAndIdle internal error");
m->deviation = 0;
KheMonitorChangeCost((KHE_MONITOR) m, 0);
}
void KheEvennessMonitorDeleteTask(KHE_EVENNESS_MONITOR m)
{
if( m->attached )
{
m->count--;
MAssert(m->count >= 0, "KheEvennessMonitorDeleteTask internal error");
KheMonitorChangeCost((KHE_MONITOR) m, KheEvennessMonitorCost(m));
}
}
void
CModule_Config::SetVal(
uint8_t inVar,
uint8_t inVal)
{
Setup();
MAssert(inVar < eConfigVar_Max);
configVar[inVar] = inVal;
EEPROM.write(eepromOffset + inVar, inVal);
}
void KheEvennessMonitorAttachToSoln(KHE_EVENNESS_MONITOR m)
{
KHE_MEET cycle_meet; int cycle_offset;
MAssert(m->count == 0, "KheEvennessMonitorAttachToSoln internal error");
cycle_meet = KheSolnTimeCycleMeet(m->soln, m->time);
cycle_offset = KheSolnTimeCycleMeetOffset(m->soln, m->time);
KheMeetPartitionTaskCount(cycle_meet, cycle_offset, m->partition, &m->count);
KheEvennessHandlerMonitorAttach(KheSolnEvennessHandler(m->soln));
m->attached = true;
}
static KHE_MEET KheFindSwapTarget(KHE_MEET meet, KHE_NODE swap_node)
{
int i; KHE_MEET swap_meet;
for( i = 0; i < KheNodeMeetCount(swap_node); i++ )
{
swap_meet = KheNodeMeet(swap_node, i);
if( KheMeetAsst(swap_meet) == KheMeetAsst(meet) )
return swap_meet;
}
MAssert(false, "KheFindSwapTargetAndOffset internal error");
return NULL;
}
void TestLogEngineConstructor_FileCreation ()
{
LogFileBackup ();
// scope to construct+destruct the object.
{
LogEngine logEngine (LOG_DEVELOPER, "TST");
}
std::fstream testFile;
testFile.open (TestLogFile.c_str (), std::fstream::in);
char buf[4096];
testFile.getline (buf, 4096);
std::string bufString (buf);
MAssert (bufString.find ("TST") != std::string::npos);
MAssert (bufString.find ("LogFile created") != std::string::npos);
LogFileRestore ();
}
void KheDevMonitorDetach(KHE_DEV_MONITOR *dm, int dev)
{
int pos, tmp;
dm->devs_changed = true;
tmp = MArrayRemoveLast(dm->devs);
if( tmp != dev )
{
if( !MArrayContains(dm->devs, dev, &pos) )
MAssert(false, "DevMonitorDetach");
MArrayPut(dm->devs, pos, tmp);
}
}
