irr::core::stringw insertValues(const irr::core::stringw &s, Args ...args)
 {
     std::vector<irr::core::stringw> all_vals;
     all_vals.reserve(sizeof...(args));
     FillStringVector::FillW(all_vals, std::forward<Args>(args)...);
     return insertValues(s, all_vals);
 }
 std::string insertValues(const std::string &s, Args ...args)
 {
     std::vector<std::string> all_vals;
     all_vals.reserve(sizeof...(args));
     FillStringVector::FillS(all_vals, std::forward<Args>(args)...);
     return insertValues(s, all_vals);
 }
 irr::core::stringw insertValues(const wchar_t* chars, const T1 &v1,
                                 const T2 &v2, const T3 &v3, const T4 &v4,
                                 const T5 &v5)
 {
     irr::core::stringw s(chars);
     return insertValues(s, v1, v2, v3, v4, v5);
 }   // insertValues(s, v1, ..., v5)
Exemple #4
0
 irr::core::stringw insertValues(const irr::core::stringw &s, const T1 &v1,
                          const T2 &v2)
 {
     std::vector<irr::core::stringw> all_vals;
     all_vals.push_back( irr::core::stringw(v1) );
     all_vals.push_back( irr::core::stringw(v2) );
     return insertValues(s, all_vals);
 }   // insertValues(s, v1, v2)
    std::string insertValues(const std::string &s, const T1 &v1)
    {
        std::vector<std::string> all_vals;
        std::ostringstream dummy;
        dummy << v1; all_vals.push_back(dummy.str()); dummy.str("");

        return insertValues(s, all_vals);
    }   // insertValues(s, v1)
Exemple #6
0
int main(void){
  char buffer[128];
  FILE *database = fopen("nätverk.txt", "r");
  struct adjNode newNode = insertValues(readline(buffer, 128, database));
  printf("%s\n", newNode.linje);
  printf("%s\n", newNode.src);
  printf("%s\n", newNode.dest);
  printf("%s\n", newNode.time);
  return 0;
}
 std::string insertValues(const std::string &s, const T1 &v1,
                          const T2 &v2, const T3 &v3, const T4 &v4)
 {
     std::vector<std::string> all_vals;
     std::ostringstream dummy;
     dummy << v1; all_vals.push_back(dummy.str()); dummy.str("");
     dummy << v2; all_vals.push_back(dummy.str()); dummy.str("");
     dummy << v3; all_vals.push_back(dummy.str()); dummy.str("");
     dummy << v4; all_vals.push_back(dummy.str());
     return insertValues(s, all_vals);
 }   // insertValues(s, v1, ..., v4)
Exemple #8
0
 irr::core::stringw insertValues(const irr::core::stringw &s, const T1 &v1,
                                 const T2 &v2, const T3 &v3, const T4 &v4,
                                 const T5 &v5)
 {
     std::vector<irr::core::stringw> all_vals;
     all_vals.push_back( irr::core::stringw(v1) );
     all_vals.push_back( irr::core::stringw(v2) );
     all_vals.push_back( irr::core::stringw(v3) );
     all_vals.push_back( irr::core::stringw(v4) );
     all_vals.push_back( irr::core::stringw(v5) );
     return insertValues(s, all_vals);
 }   // insertValues(s, v1, ..., v5)
 std::string insertValues(const char *s, Args ...args)
 {
     return insertValues(std::string(s), std::forward<Args>(args)...);
 }
 std::string insertValues(const char* chars, const T1 &v1)
 {
     std::string s(chars);
     return insertValues(s, v1);
 }   // insertValues(s, v1)
 std::string insertValues(const char* chars, const T1 &v1,
                                 const T2 &v2, const T3 &v3)
 {
     std::string s(chars);
     return insertValues(s, v1, v2, v3);
 }   // insertValues(s, v1, ..., v3)
 irr::core::stringw insertValues(const wchar_t* chars, const T1 &v1)
 {
     irr::core::stringw s(chars);
     return insertValues(s, v1);
 }   // insertValues(s, v1)
Exemple #13
0
// insert new item into the list
int insertListItem(List *list, double value, int i, int j, int isFull, int inserted){
    ListItem *item;
    ListItem *nextItem;
    ListItem *newFirst;
    int searchPlace = 1;
    double v;

    item = list->firstItem;

    // the list is empty
    if(item == NULL){
        list->firstItem = createListItem(value, i, j);
        lastBest = value;
        inserted--;
        return inserted;
    }

    // this listItem should be the first?
    if(value < item->value){
        newFirst = createListItem(value, i, j);
        newFirst->nextItem = item;
        list->firstItem = newFirst;
         if(isFull){
            removeLastItem(list->firstItem);
        }
        inserted--;
        return inserted;
    }

    /* search the right place */
    while(searchPlace){
        // insert in the same list item
        v = item->value;

        if(item->value == value){
             insertValues(item, i, j);
             return inserted;
        }
        nextItem = item->nextItem;

        // there is no next item
        if(nextItem == NULL){
            item->nextItem = createListItem(value, i, j);
            lastBest = value;
            inserted--;
            return inserted;
        }
        // should we add a new list item between two existing items?
        if(nextItem->value > value){
            item->nextItem = createListItem(value, i, j);
            item->nextItem->nextItem = nextItem;
            if(isFull){
                removeLastItem(list->firstItem);
            }
            inserted--;
            return inserted;
        }
        item = item->nextItem;
    }
    return 0;
}
Exemple #14
0
std::string proxy_insertValues4(std::string* formatString, std::string* arg1, std::string* arg2,
                                std::string* arg3, std::string* arg4)
{
    return insertValues(formatString, arg1, arg2, arg3, arg4);
}
Exemple #15
0
std::string proxy_insertValues2(std::string* formatString, std::string* arg1, std::string* arg2)
{
    return insertValues(formatString, arg1, arg2);
}
Exemple #16
0
/** \cond DOXYGEN_IGNORE */
std::string proxy_insertValues1(std::string* formatString, std::string* arg1)
{
    return insertValues(formatString, arg1);
}
 irr::core::stringw insertValues(const wchar_t *s, Args ...args)
 {
     return insertValues(irr::core::stringw(s), std::forward<Args>(args)...);
 }
 irr::core::stringw insertValues(const irr::core::stringw &s, Args ...args)
 {
     std::vector<irr::core::stringw> all_vals;
     __FillStringwVector::__Fill(all_vals, std::forward<Args>(args)...);
     return insertValues(s, all_vals);
 }