int main(int argc, char** argv)
{
PriceList * priceList = new PriceList[N];
ProductStream * Stream = new ProductStream[N];
//--------------------------------------------------------------------------------------
// Open file with Prices and fill in to priceList
FILE *loadfile;
loadfile = fopen("PriceList.txt","rt");
if(loadfile == NULL)
puts("Cannot open file PriceList.txt");
else
puts("\n File PriceList.txt was loaded successful");
char buff[255];
int countPrices = 0; // use to know how many records are in file
while (!feof(loadfile))
{
fgets(buff,255,loadfile);
sscanf(buff,"%s%d",&priceList[countPrices].Code,&priceList[countPrices].Price);
printf("\n%-10s %d",priceList[countPrices].Code,priceList[countPrices].Price);
countPrices++;
}
//------------------------------------------------------------------------------------------
puts("\n\nInsert information about products");
// Get info about products from keybd
for(int i = 0 ; i < 3 ; i++)
{
printf("Code \t = "); // Product code
scanf("%s",&Stream[i].Code);
printf("Name \t = "); // Product name
scanf("%s",&Stream[i].Name);
printf("Count \t = "); // Count of Products
scanf("%d",&Stream[i].Count);
printf("__________________\n");
}
SortStream(Stream,N);
FindEquals(Stream,N); // if Equals Product codes -> print just one
PrintStream(Stream,priceList,N,countPrices);
delete[] priceList;
delete[] Stream;
return 0;
}
int Next()
{
#ifdef SO_MAX_ARGS
if (m_argc > SO_MAX_ARGS) {
SO_ASSERT(!"Too many args! Check the return value of Init()!");
return 0;
}
#endif
// process a clumped option string if appropriate
if (m_pszClump && *m_pszClump) {
// silently discard invalid clumped option
int bIsValid = NextClumped();
while (*m_pszClump && !bIsValid && HasFlag(SO_O_NOERR)) {
bIsValid = NextClumped();
}
// return this option if valid or we are returning errors
if (bIsValid || !HasFlag(SO_O_NOERR)) {
return 1;
}
}
SO_ASSERT(!m_pszClump || !*m_pszClump);
m_pszClump = NULL;
// init for the next option
m_nOptionIdx = m_nNextOption;
m_nOptionId = -1;
m_pszOptionText = NULL;
m_pszOptionArg = NULL;
m_nLastError = SO_SUCCESS;
// find the next option
char cFirst;
int nTableIdx = -1;
int nOptIdx = m_nOptionIdx;
while (nTableIdx < 0 && nOptIdx < m_nLastArg) {
char * pszArg = m_argv[nOptIdx];
m_pszOptionArg = NULL;
// find this option in the options table
cFirst = PrepareArg(pszArg);
if (pszArg[0] == (char)'-') {
// find any combined argument string and remove equals sign
m_pszOptionArg = FindEquals(pszArg);
if (m_pszOptionArg) {
*m_pszOptionArg++ = (char)'\0';
}
}
nTableIdx = LookupOption(pszArg);
// if we didn't find this option but if it is a short form
// option then we try the alternative forms
if (nTableIdx < 0
&& !m_pszOptionArg
&& pszArg[0] == (char)'-'
&& pszArg[1]
&& pszArg[1] != (char)'-'
&& pszArg[2])
{
// test for a short-form with argument if appropriate
if (HasFlag(SO_O_SHORTARG)) {
m_szShort[1] = pszArg[1];
int nIdx = LookupOption(m_szShort);
if (nIdx >= 0
&& (m_rgOptions[nIdx].nArgType == SO_REQ_CMB
|| m_rgOptions[nIdx].nArgType == SO_OPT))
{
m_pszOptionArg = &pszArg[2];
pszArg = m_szShort;
nTableIdx = nIdx;
}
}
// test for a clumped short-form option string and we didn't
// match on the short-form argument above
if (nTableIdx < 0 && HasFlag(SO_O_CLUMP)) {
m_pszClump = &pszArg[1];
++m_nNextOption;
if (nOptIdx > m_nOptionIdx) {
ShuffleArg(m_nOptionIdx, nOptIdx - m_nOptionIdx);
}
return Next();
}
}
// The option wasn't found. If it starts with a switch character
// and we are not suppressing errors for invalid options then it
// is reported as an error, otherwise it is data.
if (nTableIdx < 0) {
if (!HasFlag(SO_O_NOERR) && pszArg[0] == (char)'-') {
m_pszOptionText = pszArg;
break;
}
pszArg[0] = cFirst;
++nOptIdx;
if (m_pszOptionArg) {
*(--m_pszOptionArg) = (char)'=';
}
}
}
// end of options
if (nOptIdx >= m_nLastArg) {
if (nOptIdx > m_nOptionIdx) {
ShuffleArg(m_nOptionIdx, nOptIdx - m_nOptionIdx);
}
return 0;
}
++m_nNextOption;
// get the option id
ESOArgType nArgType = SO_NONE;
if (nTableIdx < 0) {
m_nLastError = (ESOError) nTableIdx; // error code
}
else {
m_nOptionId = m_rgOptions[nTableIdx].nId;
m_pszOptionText = m_rgOptions[nTableIdx].pszArg;
// ensure that the arg type is valid
nArgType = m_rgOptions[nTableIdx].nArgType;
switch (nArgType) {
case SO_NONE:
if (m_pszOptionArg) {
m_nLastError = SO_ARG_INVALID;
}
break;
case SO_REQ_SEP:
if (m_pszOptionArg) {
// they wanted separate args, but we got a combined one,
// unless we are pedantic, just accept it.
if (HasFlag(SO_O_PEDANTIC)) {
m_nLastError = SO_ARG_INVALID_TYPE;
}
}
// more processing after we shuffle
break;
case SO_REQ_CMB:
if (!m_pszOptionArg) {
m_nLastError = SO_ARG_MISSING;
}
break;
case SO_OPT:
// nothing to do
break;
case SO_MULTI:
// nothing to do. Caller must now check for valid arguments
// using GetMultiArg()
break;
}
}
// shuffle the files out of the way
if (nOptIdx > m_nOptionIdx) {
ShuffleArg(m_nOptionIdx, nOptIdx - m_nOptionIdx);
}
// we need to return the separate arg if required, just re-use the
// multi-arg code because it all does the same thing
if ( nArgType == SO_REQ_SEP
&& !m_pszOptionArg
&& m_nLastError == SO_SUCCESS)
{
char ** ppArgs = MultiArg(1);
if (ppArgs) {
m_pszOptionArg = *ppArgs;
}
}
return 1;
}