void SplitIntoVects(const vector <LonLatAnom> &TheMembers,
vector <double> &Lons, vector <double> &Lats, vector <double> &Anoms)
{
Lons.resize(TheMembers.size());
Lats.resize(TheMembers.size());
Anoms.resize(TheMembers.size());
vector<double>::iterator ALon( Lons.begin() ), ALat( Lats.begin() ), AnAnom( Anoms.begin() );
for (vector<LonLatAnom>::const_iterator AMember( TheMembers.begin() ); AMember != TheMembers.end();
AMember++, ALon++, ALat++, AnAnom++)
{
*ALon = AMember->Lon;
*ALat = AMember->Lat;
*AnAnom = AMember->StdAnom;
}
}
void SplitIntoVects(const vector <LonLatAnomDate> &TheMembers,
vector <double> &Lons, vector <double> &Lats, vector <double> &Anoms, vector <time_t> &DateTimes)
{
Lons.resize(TheMembers.size());
Lats.resize(TheMembers.size());
Anoms.resize(TheMembers.size());
DateTimes.resize(TheMembers.size());
vector<double>::iterator ALon( Lons.begin() ), ALat( Lats.begin() ), AnAnom( Anoms.begin() );
vector<time_t>::iterator ADate( DateTimes.begin() );
for (vector<LonLatAnomDate>::const_iterator AMember( TheMembers.begin() ); AMember != TheMembers.end();
AMember++, ALon++, ALat++, AnAnom++, ADate++)
{
*ALon = AMember->Lon;
*ALat = AMember->Lat;
*AnAnom = AMember->StdAnom;
*ADate = AMember->DateInfo;
}
}
vector <LonLatCount> GetMemberCounts(const vector <LonLatAnom> &TheMembers)
{
vector <LonLatCount> MemberCounts(0);
for (vector<LonLatAnom>::const_iterator AMember( TheMembers.begin() ); AMember != TheMembers.end(); AMember++)
{
if (binary_search(MemberCounts.begin(), MemberCounts.end(), *AMember))
{
(lower_bound(MemberCounts.begin(), MemberCounts.end(), *AMember))->Count++;
}
else
{
LonLatCount TempCount;
TempCount.Lon = AMember->Lon;
TempCount.Lat = AMember->Lat;
TempCount.Count = 1;
MemberCounts.insert(lower_bound(MemberCounts.begin(), MemberCounts.end(), *AMember), TempCount);
}
}
return(MemberCounts);
}
/* __testc::AMember(obj, name) */
static AValue TestC_AMember(AThread *t, AValue *frame)
{
char member[100];
AGetStr(t, frame[1], member, 100);
return AMember(t, frame[0], member);
}
/* Str format(...)
Format a string based on a format string which may contain formatting
sequences of form {...}; these correspond to the arguments of the method.
The base string object represents the format string. */
AValue AFormat(AThread *t, AValue *frame)
{
int fi; /* Format string index */
int ai; /* Argument index */
int fmtLen; /* Format string length */
FormatOutput output;
AExpectStr(t, frame[0]);
output.t = t;
output.index = 0;
output.len = FORMAT_BUF_SIZE;
output.str = &frame[2];
fmtLen = AStrLen(frame[0]);
ai = 0;
/* IDEA: Refactor this into multiple functions. */
/* Iterate over the format string. Handle { sequences and copy other
characters directly to the output buffer (} may be duplicated). */
for (fi = 0; fi < fmtLen; fi++) {
int ch = AStrItem(frame[0], fi);
if (ch == '{') {
if (fi == fmtLen - 1 || AStrItem(frame[0], fi + 1) == '{') {
/* Literal '{'. */
fi++;
Append(&output, ch);
} else {
/* A format sequence {...}. */
int negAlign = FALSE;
int align = 0;
int oldInd;
int oldOutInd;
AValue arg;
fi++;
oldInd = fi;
/* Parse alignment */
if (fi < fmtLen && AStrItem(frame[0], fi) == '-'
&& AIsDigit(AStrItem(frame[0], fi + 1))) {
negAlign = TRUE;
fi++;
}
if (fi < fmtLen && AIsDigit(AStrItem(frame[0], fi))) {
do {
align = align * 10 + AStrItem(frame[0], fi) - '0';
fi++;
} while (fi < fmtLen && AIsDigit(AStrItem(frame[0], fi)));
if (AStrItem(frame[0], fi) != ':') {
fi = oldInd;
align = 0;
} else
fi++;
}
oldOutInd = output.index & ~WIDE_BUF_FLAG;
if (ai >= AArrayLen(frame[1]))
ARaiseValueError(t, "Too few arguments");
arg = AArrayItem(frame[1], ai);
if (AIsInstance(arg)
&& AStrItem(frame[0], fi) != '}'
&& AMember(t, arg, "_format") != AError) {
int i;
oldInd = fi;
while (fi <= fmtLen && AStrItem(frame[0], fi) != '}')
fi++;
if (fi >= fmtLen)
ARaiseValueError(t, "Unterminated format");
frame[3] = AArrayItem(frame[1], ai);
frame[4] = ASubStr(t, frame[0], oldInd, fi);
frame[3] = ACallMethod(t, "_format", 1, frame + 3);
if (AIsError(frame[3]))
return AError;
AExpectStr(t, frame[3]);
for (i = 0; i < AStrLen(frame[3]); i++)
Append(&output, AStrItem(frame[3], i));
} else {
/* Either format an Int/Float or use the default conversion
by calling std::Str. */
int minNumLen = 0;
int fractionLen = 0;
int optFractionLen = 0;
int expLen = 0;
int fraction = FALSE;
int scientific = FALSE;
int plusExp = FALSE;
int expChar = ' ';
while (fi < fmtLen &&
(ch = AStrItem(frame[0], fi)) != '}') {
if (ch == '0') {
if (scientific)
expLen++;
else if (fraction)
fractionLen++;
else
minNumLen++;
} else if (ch == '.')
fraction = TRUE;
else if (ch == 'e' || ch == 'E') {
scientific = TRUE;
expChar = ch;
} else if (ch == '+' && scientific)
plusExp = TRUE;
else if (ch == '#' && fraction && !scientific) {
fractionLen++;
optFractionLen++;
} else
ARaiseValueError(t, "Invalid character in format");
fi++;
}
if (scientific)
NumberToScientific(&output, arg, fractionLen, expLen,
expChar, plusExp, optFractionLen);
else if (minNumLen > 0 || fraction)
NumberToStr(&output, arg, minNumLen, fractionLen,
optFractionLen);
else {
/* Not a number formatting sequence. Use std::Str to
convert the argument. */
int i;
frame[3] = arg;
frame[3] = AStdStr(t, &frame[3]);
if (AIsError(frame[3]))
return AError;
for (i = 0; i < AStrLen(frame[3]); i++)
Append(&output, AStrItem(frame[3], i));
}
}
if (fi >= fmtLen)
ARaiseValueError(t, "Unterminated format");
align -= (output.index & ~WIDE_BUF_FLAG) - oldOutInd;
if (align > 0) {
int i;
for (i = 0; i < align; i++)
Append(&output, ' ');
if (!negAlign) {
if (output.index < FORMAT_BUF_SIZE) {
AMoveMem(output.buf + oldOutInd + align,
output.buf + oldOutInd,
output.index - oldOutInd - align);
for (i = 0; i < align; i++)
output.buf[oldOutInd + i] = ' ';
} else {
for (i = (output.index & ~WIDE_BUF_FLAG) - 1;
i >= oldOutInd + align; i--)
ASetStrItem(frame[2], i,
AStrItem(frame[2], i - align));
for (i = 0; i < align; i++)
ASetStrItem(frame[2], oldOutInd + i, ' ');
}
}
}
ai++;
}
} else if (ch == '}') {
/* Literal '}' can be duplicated (but does not need to be). */
if (fi < fmtLen - 1 && AStrItem(frame[0], fi + 1) == '}')
fi++;
Append(&output, ch);
} else
Append(&output, ch);
}
if (ai < AArrayLen(frame[1]))
ARaiseValueError(t, "Too many arguments");
if (output.index <= FORMAT_BUF_SIZE) {
/* The output contains only narrow characters (since the index does not
have the WIDE_BUF_FLAG flag) and is short enough to not require a
heap-allocated buffer. Create a string based on the internal
buffer. */
AValue res = AMakeEmptyStr(t, output.index);
ACopyMem(AGetStrElem(res), output.buf, output.index);
return res;
} else {
/* The output is stored in a heap-allocated buffer (represented as a
Str object). Return the initialized part of the buffer. */
return ASubStr(t, frame[2], 0, output.index & ~WIDE_BUF_FLAG);
}
}
