Variant Document::getData()
{
Variant var = comm.getData(getURL(false));
Object obj = boost::any_cast<Object>(*var);
if(obj.find("_id") == obj.end() && obj.find("_rev") == obj.end() &&
obj.find("error") != obj.end() && obj.find("reason") != obj.end())
{
throw Exception("Document '" + getID() + "' not found: " + boost::any_cast<string>(*obj["reason"]));
}
return var;
}
Attachment Document::getAttachment(const string &attachmentId)
{
Object data = boost::any_cast<Object>(*getData());
if(data.find("_attachments") == data.end())
throw Exception("No attachments");
Object attachments = boost::any_cast<Object>(*data["_attachments"]);
if(attachments.find(attachmentId) == attachments.end())
throw Exception("No attachment found with id '" + attachmentId + "'");
Object attachment = boost::any_cast<Object>(*attachments[attachmentId]);
return Attachment(comm, db, id, attachmentId, "", boost::any_cast<string>(*attachment["content_type"]));
}
bool Document::removeAttachment(const string &attachmentId)
{
string url = getURL(false) + "/" + attachmentId;
if(revision.size() > 0)
url += "?rev=" + revision;
Variant var = comm.getData(url, "DELETE");
Object obj = boost::any_cast<Object>(*var);
if(obj.find("error") != obj.end() && obj.find("reason") != obj.end())
throw Exception("Could not delete attachment '" + attachmentId + "': " + boost::any_cast<string>(*obj["reason"]));
revision = boost::any_cast<string>(*obj["rev"]);
return boost::any_cast<bool>(*obj["ok"]);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Action
///////////////////////////////////////////////////////////////////////////////////////////////////////////
void Action()
{
Object::iterator oIter;
for (oIter = g_Object.begin(); oIter != g_Object.end(); )
{
CBaseObject *pBaseObject = (*oIter);
if (!pBaseObject->Action(pBaseObject->GetObjectID())) oIter++;
else
{
delete pBaseObject;
g_Object.erase(oIter++);
}
WriteProc();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
// TileMap 좌표 지정
///////////////////////////////////////////////////////////////////////////////////////////////////////
if (g_pPlayerObject != NULL)
g_cTileMap.SetDrawPos(g_pPlayerObject->GetCurX(), g_pPlayerObject->GetCurY());
//y축 정렬 시키기
//이펙트는 제일 뒤로 밀기
}
void Json::FreeMemory(){
switch(_kind){
case kNumber: { double* ptr = (double*)_data; delete ptr; break; }
case kString: { std::string* ptr = (std::string*)_data; delete ptr; break; }
case kFalse: case kTrue: { bool* ptr = (bool*)_data; delete ptr; break; }
case kArray:
{
Array& arr = *(Array*)_data;
Array::iterator iter = arr.begin();
for(; iter != arr.end(); iter++){
delete *iter;
*iter = NULL;
}
break;
}
case kObject:
{
Object* obj = (Object*)_data;
Object::iterator iter = obj->begin();
for(; iter != obj->end(); iter++){
delete iter->second;
iter->second = NULL;
}
break;
}
default: break;
}
_data = NULL;
_kind = kNull;
}
void clear(Object& u){
typename Object::iterator b=u.begin(), e=u.end();
while(b!=e)
{
*b = TypeTraits<typename Object::ScalarType>::zero();
++b;
}
}
bool Connection::deleteDatabase(const string &db){
Variant var = comm.getData("/" + db, "DELETE");
Object obj = boost::any_cast<Object>(*var);
if(obj.find("error") != obj.end())
throw Exception("Unable to create database '" + db + "': " + boost::any_cast<string>(*obj["reason"]));
return boost::any_cast<bool>(*obj["ok"]);
}
bool Connection::deleteDatabase(const string &db){
Value val = comm.getData("/" + db, "DELETE");
Object obj = val.getObject();
if(obj.find("error") != obj.end())
throw Exception("Unable to create database '" + db + "': " + obj["reason"].getString());
return obj["ok"].getBoolean();
}
typename Object::ScalarType euclNorm(const Object& u){
typedef typename Object::ScalarType Scalar;
Scalar sum = TypeTraits<Scalar>::zero();
typename Object::const_iterator b=u.begin(), e=u.end();
while(b!=e)
{
sum += static_cast<Scalar>(power(*b,2));
++b;
}
return Scalar(sqrt(nonnegativePart(sum)));
}
Document Document::copy(const string &targetId, const string &targetRev)
{
Communication::HeaderMap headers;
if(targetRev.size() > 0)
headers["Destination"] = targetId + "?rev=" + targetRev;
else
headers["Destination"] = targetId;
Variant var = comm.getData(getURL(true), headers, "COPY");
Object obj = boost::any_cast<Object>(*var);
if(obj.find("error") != obj.end() && obj.find("reason") != obj.end())
throw Exception("Could not copy document '" + getID() + "' to '" + targetId + "': " + boost::any_cast<string>(*obj["reason"]));
string newId = targetId;
if(obj.find("id") != obj.end())
newId = boost::any_cast<string>(*obj["id"]);
return Document(comm, db, newId, "", boost::any_cast<string>(*obj["rev"]));
}
static Value
get_field_from_obj(Object& obj, const string& field)
{
for(Object::iterator it(obj.begin()), end(obj.end()); it != end; it++) {
Pair& p(*it);
if(p.name_ == field)
return p.value_;
}
return UI_NIL;
}
bool Document::addAttachment(const string &attachmentId,
const string &contentType,
const string &data)
{
string url = getURL(false) + "/" + attachmentId;
if(revision.size() > 0)
url += "?rev=" + revision;
Communication::HeaderMap headers;
headers["Content-Type"] = contentType;
Variant var = comm.getData(url, headers, "PUT", data);
Object obj = boost::any_cast<Object>(*var);
if(obj.find("error") != obj.end() && obj.find("reason") != obj.end())
throw Exception("Could not create attachment '" + attachmentId + "': " + boost::any_cast<string>(*obj["reason"]));
revision = boost::any_cast<string>(*obj["rev"]);
return boost::any_cast<bool>(*obj["ok"]);
}
ResultType subtractObjectScalar(const Object& v,const FactorType& s)
{
ResultType result(v.dimension(),true);
typename Object::const_iterator b=v.begin(), e=v.end();
typename ResultType::iterator i=result.begin();
while(b!=e)
{
*i = (*b) - s;
++i;
++b;
}
return result;
}
/**
Converts ar to a list. atomToNative<MapType::value_type>()
is used for the conversions.
*/
inline ReturnType operator()( Object const & ar ) const
{
MapType rc;
Object::ConstIterator it = ar.begin();
Object::ConstIterator const et = ar.end();
for( ; it != et; ++it )
{
Object::Entry const & ent = *it;
rc.insert( std::make_pair( atomToNative<typename MapType::key_type>(ent.key),
atomToNative<typename MapType::mapped_type>(ent.value)
) );
}
return rc;
}
bool fillMap(const Object& object, std::map< std::string, std::vector<std::string> >* pMap)
{
for (Object::const_iterator it = object.begin();
it != object.end();
++it)
{
std::vector<std::string> strings;
const json::Array& array = it->second.get_array();
if (!fillVectorString(array, &strings))
return false;
(*pMap)[it->first] = strings;
}
return true;
}
vector<Attachment> Document::getAllAttachments()
{
Object data = boost::any_cast<Object>(*getData());
if(data.find("_attachments") == data.end())
throw Exception("No attachments");
vector<Attachment> vAttachments;
Object attachments = boost::any_cast<Object>(*data["_attachments"]);
Object::iterator attachmentItr = attachments.begin();
const Object::iterator &attachmentEnd = attachments.end();
for(; attachmentItr != attachmentEnd; ++attachmentItr)
{
const string &attachmentId = attachmentItr->first;
Object attachment = boost::any_cast<Object>(*attachmentItr->second);
vAttachments.push_back(Attachment(comm, db, id, attachmentId, "",
boost::any_cast<string>(*attachment["content_type"])));
}
return vAttachments;
}
bool normalize(Object& u){
typedef typename Object::ScalarType Scalar;
Scalar n;
if( ! (( n=euclNorm(u)) > 0.0) )
{
return false;
}else{
typename Object::iterator b=u.begin(), e=u.end();
while(b!=e)
{
*b /=n;
++b;
}
return true;
}
}
std::string json::Serialize(const Value& v)
{
std::string str;
bool first = true;
if (v.GetType() == ObjectVal)
{
str = "{";
Object obj = v.ToObject();
for (Object::ValueMap::const_iterator it = obj.begin(); it != obj.end(); it++)
{
if (!first)
str += std::string(",");
str += '\n';
str += std::string("\"") + it->first + std::string("\":") + SerializeValue(it->second);
first = false;
}
str += "}";
}
else if (v.GetType() == ArrayVal)
{
str = "[";
Array a = v.ToArray();
for (Array::ValueVector::const_iterator it = a.begin(); it != a.end(); it++)
{
if (!first)
str += std::string(",");
str += SerializeValue(*it);
first = false;
}
str += "]";
}
//else error
return str;
}
std::string json::Serialize(const Value& v)
{
std::string str;
bool first = true;
if (v.GetType() == ObjectVal)
{
str = "{";
Object obj = v.ToObject();
for (Object::ValueMap::const_iterator it = obj.begin(); it != obj.end(); ++it)
{
if (!first)
str += std::string(",");
str += std::string("\"") + it->first + std::string("\":") + SerializeValue(it->second);
first = false;
}
str += "}";
}
else if (v.GetType() == ArrayVal)
{
str = "[";
Array a = v.ToArray();
for (Array::ValueVector::const_iterator it = a.begin(); it != a.end(); ++it)
{
if (!first)
str += std::string(",");
str += SerializeValue(*it);
first = false;
}
str += "]";
}
// else it's not valid JSON, as a JSON data structure must be an array or an object. We'll return an empty string.
return str;
}
std::string Json::ToString( ){
std::ostringstream ostr;
switch(_kind){
case kNull: { ostr << "Null" ; break; }
case kNumber: { ostr << GetDouble() ; break; }
case kString: { ostr << "\"" << GetString() << "\""; break; }
case kTrue: case kFalse: { ostr << boolalpha << GetBool() ; break; }
case kObject:
{
ostr << "{";
Object* obj = (Object*)_data;
Object::const_iterator iter = obj->begin() ;
size_t size = obj->size(), ind = 0;
for(; iter != obj->end(); iter++){
ostr << "\"" << iter->first << "\"" << ":" << iter->second->ToString();
if(++ind < size) ostr << ",";
}
ostr << "}";
break;
}
case kArray:
{
ostr << "[";
Array& arr = *(Array*)_data;
size_t size = arr.size(), ind = -1;
for(; ++ind < size;){
ostr << arr[ind]->ToString();
if(ind+1 < size) ostr << ",";
}
ostr << "]";
break;
}
default: break;
}
return ostr.str();
}
std::string Json::InnerIndentString(const int & indent, const int &level, bool chgLine){
std::string ret;
if(chgLine)
ret += "\n" + IndentSpace(indent, level);
switch(_kind){
case kString: case kNumber: case kTrue: case kFalse: case kNull:
{
ret += ToString(); break;
}
case kArray:
{
ret += "[";
Array& arr = *(Array*)_data;
size_t size = arr.size(), ind = -1;
for(; ++ind < size;){
ret += arr[ind]->InnerIndentString(indent, level+1, true);
if(ind+1 < size) ret += ",";
}
ret += "\n" + IndentSpace(indent, level) + "]";
break;
}
case kObject:
{
ret += "{";
Object* obj = (Object*)_data;
Object::const_iterator iter = obj->begin() ;
size_t size = obj->size(), ind = 0;
for(; iter != obj->end(); iter++){
ret += "\n" + IndentSpace(indent, level+1) + std::string("\"") +
iter->first + std::string("\"") + ":";
ret += iter->second->InnerIndentString(indent, level+1, false);
if(++ind < size) ret += ",";
}
ret += "\n" + IndentSpace(indent, level) + "}";
break;
}
default: break;
}
return ret;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Draw
///////////////////////////////////////////////////////////////////////////////////////////////////////////
void Draw()
{
BYTE *bypDest = g_cScreenDib.GetDibBuffer();
int iDestWidth = g_cScreenDib.GetWidth();
int iDestHeight = g_cScreenDib.GetHeight();
int iDestPitch = g_cScreenDib.GetPitch();
g_cTileMap.Draw(g_pSpriteDib, bypDest, iDestWidth, iDestHeight, iDestPitch);
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Y축 정렬
///////////////////////////////////////////////////////////////////////////////////////////////////////
g_Object.sort(GreaterY());
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Effect, Player 정렬
///////////////////////////////////////////////////////////////////////////////////////////////////////
g_Object.sort(EffectOrPlayer());
Object::iterator oIter;
for (oIter = g_Object.begin(); oIter != g_Object.end(); ++oIter)
(*oIter)->Draw(g_pSpriteDib, bypDest, iDestWidth, iDestHeight, iDestPitch);
}
inline Functor for_all(Object & object, Functor functor) {
return std::for_each(object.begin(), object.end(), functor);
}
bool Move::Parse(const PlayerID &player, const std::string &json)
{
using namespace json_spirit;
if (!IsValidPlayerName(player))
return false;
Value v;
if (!read_string(json, v) || v.type() != obj_type)
return false;
Object obj = v.get_obj();
if (ExtractField(obj, "msg", v))
{
if (v.type() != str_type)
return false;
message = v.get_str();
}
if (ExtractField(obj, "address", v))
{
if (v.type() != str_type)
return false;
const std::string &addr = v.get_str();
if (!addr.empty() && !IsValidBitcoinAddress(addr))
return false;
address = addr;
}
if (ExtractField(obj, "addressLock", v))
{
if (v.type() != str_type)
return false;
const std::string &addr = v.get_str();
if (!addr.empty() && !IsValidBitcoinAddress(addr))
return false;
addressLock = addr;
}
if (ExtractField(obj, "color", v))
{
if (v.type() != int_type)
return false;
color = v.get_int();
if (color >= NUM_TEAM_COLORS)
return false;
if (!obj.empty()) // Extra fields are not allowed in JSON string
return false;
this->player = player;
return true;
}
std::set<int> character_indices;
for (std::vector<json_spirit::Pair>::iterator it = obj.begin(); it != obj.end(); ++it)
{
int i = atoi(it->name_);
if (i < 0 || strprintf("%d", i) != it->name_)
return false; // Number formatting must be strict
if (character_indices.count(i))
return false; // Cannot contain duplicate character indices
character_indices.insert(i);
v = it->value_;
if (v.type() != obj_type)
return false;
Object subobj = v.get_obj();
bool bWaypoints = false;
std::vector<Coord> wp;
if (!ParseWaypoints(subobj, wp, bWaypoints))
return false;
bool bDestruct;
if (!ParseDestruct(subobj, bDestruct))
return false;
if (bDestruct)
{
if (bWaypoints)
return false; // Cannot combine destruct and waypoints
destruct.insert(i);
}
else if (bWaypoints)
waypoints[i] = wp;
if (!subobj.empty()) // Extra fields are not allowed in JSON string
return false;
}
this->player = player;
return true;
}
