Пример #1
0
VariantList GoodStock::save() const
{
  VariantList stream;
  stream.push_back( (int)_type );
  stream.push_back( _maxQty );
  stream.push_back( _currentQty );

  return stream;
}
Пример #2
0
  VariantList save() const
  {
     VariantList ret;
     for( auto& mapItem : *this )
     {
       ret.push_back( Variant( (int)mapItem.first ) );
       ret.push_back( Variant( mapItem.second->value() ) );
     }

     return ret;
  }
Пример #3
0
void TileOverlay::save( VariantMap& stream ) const
{
  VariantList config;
  config.push_back( (int)_d->overlayType );
  config.push_back( Variant( MetaDataHolder::instance().getData( _d->overlayType ).getName() ) );
  config.push_back( getTile().getIJ() );

  stream[ "config" ] = config;
  stream[ "picture" ] = Variant( _d->picture.getName() );
  stream[ "pictureOffset" ] = _d->picture.getOffset();
  stream[ "size" ] = _d->size;
  stream[ "isDeleted" ] = _d->isDeleted;
  stream[ "name" ] = Variant( _d->name );
}
Пример #4
0
VariantList proxyProcessList( const VariantList &args, const JSAPIImplPtr& self, const JSAPIImplPtr& proxy )
{
    VariantList newArgs;
    for (VariantList::const_iterator it = args.begin();
        it != args.end(); ++it) {
        if (it->is_of_type<JSAPIPtr>() && it->convert_cast<JSAPIPtr>() == self) {
            newArgs.push_back(proxy);
        } else if (it->is_of_type<VariantList>()) {
            newArgs.push_back(proxyProcessList(it->convert_cast<VariantList>(), self, proxy));
        } else if (it->is_of_type<VariantMap>()) {
            newArgs.push_back(proxyProcessMap(it->convert_cast<VariantMap>(), self, proxy));
        } else {
            newArgs.push_back(*it);
        }
    }
    return newArgs;
}
Пример #5
0
  virtual VariantList save() const
  {
    VariantList ret;
    for (const auto& item : *this) {
      ret.push_back(VariantList(item.first, item.second));
    }

    return ret;
  }
Пример #6
0
void JSAPIImpl::FireJSEvent( const std::string& eventName, const VariantMap &members, const VariantList &arguments )
{
    if (!m_valid)   // When invalidated, do nothing more
        return;

    {
        JSAPIImplPtr self(shared_from_this());
        boost::recursive_mutex::scoped_lock _l(m_proxyMutex);
        ProxyList::iterator proxyIt = m_proxies.begin();
        while (proxyIt != m_proxies.end()) {
            JSAPIImplPtr proxy(proxyIt->lock());
            if (!proxy) {
                // Since you can't use a shared_ptr in a destructor, there
                // is no way for the proxy object to let us know when it goes
                // away; thus when we find them, we remove them for efficiency
                proxyIt = m_proxies.erase(proxyIt);
                continue;
            }

            VariantList newArgs = proxyProcessList(arguments, self, proxy);
            VariantMap newMap = proxyProcessMap(members, self, proxy);

            proxy->FireJSEvent(eventName, newMap, newArgs);
            proxyIt++;
        }
    }

    VariantList args;
    args.push_back(CreateEvent(shared_from_this(), eventName, members, arguments));

    {
        boost::recursive_mutex::scoped_lock _l(m_eventMutex);
        EventContextMap::iterator it(m_eventMap.begin());
        while (it != m_eventMap.end()) {
            std::pair<EventMultiMap::iterator, EventMultiMap::iterator> range = it->second.equal_range(eventName);
            for (EventMultiMap::const_iterator eventIt = range.first; eventIt != range.second; eventIt++) {
                eventIt->second->InvokeAsync("", args);
            }
            ++it;
        }
    }

    // Some events are registered as a jsapi object with a method of the same name as the event
    {
        boost::recursive_mutex::scoped_lock _l(m_eventMutex);
        EventIfaceContextMap::iterator it(m_evtIfaces.begin());
        while (it != m_evtIfaces.end()) {
            for (EventIFaceMap::const_iterator ifaceIt = it->second.begin(); ifaceIt != it->second.end(); ifaceIt++) {
                ifaceIt->second->InvokeAsync(eventName, args);
            }
        }
    }
}
Пример #7
0
    VariantList save() 
    {
      VariantList ret;
      ret.push_back( sellPrice );
      ret.push_back( buyPrice );
      ret.push_back( exportLimit );
      ret.push_back( importLimit );
      ret.push_back( soldGoods );
      ret.push_back( bougthGoods );
      ret.push_back( stacking );
      ret.push_back( order );
      ret.push_back( vendor );

      return ret;
    }
Пример #8
0
VariantMap Storage::save() const
{
  VariantMap stream = good::Store::save();

  stream[ "max" ] = _gsd->capacity;

  VariantList stockSave;
  for( auto& stockInfo : _gsd->stocks )
    stockSave.push_back( stockInfo->save() );

  stream[ "stock" ] = stockSave;

  return stream;
}
Пример #9
0
VariantMap SimpleGoodStore::save() const
{
    VariantMap stream = GoodStore::save();

    stream[ "max" ] = _maxQty;

    VariantList stockSave;
    for( std::vector<GoodStock>::const_iterator itStock = _goodStockList.begin(); itStock != _goodStockList.end(); itStock++)
    {
        stockSave.push_back( (*itStock).save() );
    }

    stream[ "stock" ] = stockSave;

    return stream;
}
Пример #10
0
const VariantList Database::getValueForItemNameAsVector( const std::string &item) const
{
    VariantList list;
    
    std::istringstream f( getValueForItemName( item )->getString() );
    std::string s;
    
    while (getline(f, s, ' '))
    {
        if ( !s.empty() )
            list.push_back( s );
    }
    
    return list;
    
}
Пример #11
0
/**
 * parseArray
 */
Variant Json::parseArray(const std::string &json, int &index, bool &success)
{
  VariantList list;

  Json::nextToken(json, index);

  bool done = false;
  while(!done)
  {
    int token = Json::lookAhead(json, index);

    if(token == JsonTokenNone)
    {
      success = false;
      return VariantList();
    }
    else if(token == JsonTokenComma)
    {
      Json::nextToken(json, index);
    }
    else if(token == JsonTokenSquaredClose)
    {
      Json::nextToken(json, index);
      break;
    }
    else
    {
      Variant value = Json::parseValue(json, index, success);

      if(!success)
      {
        return VariantList();
      }

      list.push_back(value);
    }
  }

  return Variant(list);
}