//manages if a card is dealt to the player OR if the tabletop device recalls cards
    public void HandleDidChangeRecord(string arg1, DatabaseEntry arg2, IDictionary arg3, string[] arg4)
    {
        Debug.Log ("GameObject Record Change Detected");
        //if the card is dealt to us
        if (arg2.location == clientInit.playerName) {
            GameObject newCard = Instantiate (card1, new Vector3 (0f, 4.2f, -11.0f), card1.transform.rotation) as GameObject;
            newCard.name = "PlayingCard";
            newCard.transform.Rotate (new Vector3 (0, 0, 180));				//keep the card face down
            GameObject.Find("Hand").GetComponent<HandManager>().resetShowingCards();	//reset the hand so that cards are facing down by default
            playingCard1 = newCard.GetComponent<PlayingCard> ();			//set the PlayingCard component

            //sets the variables to a local copy of the card
            playingCard1.dbEntry.location = arg2.location;
            playingCard1.dbEntry.back = arg2.back;
            playingCard1.dbEntry.number = arg2.number;
            playingCard1.dbEntry.suit = arg2.suit;
            playingCard1.dbEntry._id = arg2._id;

            //keep track of this card and enable us to manipulate it
            playingCard1.AddToRecordGroup ();

            //pick the right face of a card to show
            string cardName = arg2.back + "" + arg2.number + "" + arg2.suit;
            foreach (Transform child in newCard.transform) {
                child.gameObject.GetComponent<MeshRenderer> ().enabled = false;
                child.gameObject.SetActive (false);
                if (child.gameObject.name == cardName) {
                    child.gameObject.GetComponent<MeshRenderer> ().enabled = true;
                    child.gameObject.SetActive (true);
                }
            }

            //move the card to the appropriate location
            if (cardInPosition1) {
                newCard.GetComponent<physicalCard> ().moveToTarget (GameObject.Find ("Hand/CardLocation1"));
                cardInPosition1 = false;
            } else {
                newCard.GetComponent<physicalCard> ().moveToTarget (GameObject.Find ("Hand/CardLocation2"));
                cardInPosition1 = true;
            }

            //set the parent to "Hand" so that "Hand can easily control the cards
            newCard.transform.parent = GameObject.Find ("Hand").gameObject.transform;

            //if the tabletop device is recalling the cards (to reshuffle)
        } else if (arg2.location == "deck") {
            //moves the cards to the discard pile on mobile screen
            //and re-syncs the database that the cards are at location 'deck'
            hand.GetComponent<HandManager>().Recall();
        }
        //the card is neither being passed to us nor being recalled by the tabletop
        else {
            Debug.LogError ("this card does not belong to us, it belongs to: " + arg2.location);
            if (!production) {
                debugList.Add(arg2.location + arg2.number + arg2.suit);
                //Debug.Log ("added to list: " + arg2.location + arg2.number + arg2.suit);
                //clientInit.createMsgLog(arg2.location + "\n" + arg2.number + "\n" + arg2.suit, 1f);
            }
        }
    }

 public void HandleDidChangeRecord(string arg1, DatabaseEntry arg2, IDictionary arg3, string[] arg4)
 {
     Debug.Log ("record changed: " + arg2.location);
     if (arg2.location == "home") {
         cube.SetActive(true);
     }
 }

  internal int get_key(DatabaseEntry key) {
    try {
		int ret;
		ret = libdb_csharpPINVOKE.DB_SEQUENCE_get_key(swigCPtr, DBT.getCPtr(DatabaseEntry.getDBT(key)));
		DatabaseException.ThrowException(ret);
		return ret;
} finally {
      GC.KeepAlive(key);
    }
  }

 internal int read(DatabaseEntry data, Int64 offset, uint size, uint flags)
 {
     try {
     int ret;
     ret = libdb_csharpPINVOKE.DB_STREAM_read(swigCPtr, DBT.getCPtr(DatabaseEntry.getDBT(data)), offset, size, flags);
     DatabaseException.ThrowException(ret);
     return ret;
     } finally {
       GC.KeepAlive(data);
     }
 }

 internal int send_request(IntPtr[] request, uint nrequest, DatabaseEntry response, uint timeout, uint flags)
 {
     try {
     int ret;
     ret = libdb_csharpPINVOKE.DB_CHANNEL_send_request(swigCPtr, request, nrequest, DBT.getCPtr(DatabaseEntry.getDBT(response)).Handle, timeout, flags);
     DatabaseException.ThrowException(ret);
     return ret;
     } finally {
       GC.KeepAlive(response);
     }
 }

    //manages if a card is dealt to the player OR if the tabletop device recalls cards
    public void HandleDidChangeRecord(string arg1, DatabaseEntry arg2, IDictionary arg3, string[] arg4)
    {
        Debug.Log ("GameObject Record Change Detected");
        //if the card is dealt to us
        if (arg2.location == "Player") {
            Debug.Log ("record change's location is 'Player'");
            something.SetActive(true);
            something.GetComponent<ExampleObject>().dbEntry._id = arg2._id;
            Debug.Log ("setting Id to " + arg2._id + "and it worked? " + something.GetComponent<ExampleObject>().dbEntry._id );

        } else {
            Debug.LogError ("this does not belong to us, it belongs to: " + arg2.location);
        }
    }

    public void HandleDidAddRecord(string arg1, DatabaseEntry arg2)
    {
        Debug.Log ("Record added: " + arg2.location + arg2.color + arg2._id + ".");
        if (arg2.location == "home") {
            something = Instantiate (newThing, new Vector3 (0f, 10f, 0f), newThing.transform.rotation) as GameObject;
            something.name = "thing";

            exampleObject = something.GetComponent<ExampleObject> ();

            //sets the variables to a local copy of the card
            exampleObject.dbEntry.location = arg2.location;
            exampleObject.dbEntry.color = arg2.color;
            exampleObject.dbEntry._id = arg2._id;
            Debug.Log ("Make sure ID is set: " + exampleObject.dbEntry._id);

            //keep track of this card and enable us to manipulate it
            exampleObject.AddToRecordGroup ();
            something.SetActive(false);

            //if the tabletop device is recalling the cards (to reshuffle)
        } else {
            Debug.LogError ("this: " + arg2.location);
        }
    }

 internal int key_range(DB_TXN txn, DatabaseEntry key, DB_KEY_RANGE range, uint flags)
 {
     try {
     int ret;
     ret = libdb_csharpPINVOKE.DB_key_range(swigCPtr, DB_TXN.getCPtr(txn), DBT.getCPtr(DatabaseEntry.getDBT(key)), DB_KEY_RANGE.getCPtr(range), flags);
     DatabaseException.ThrowException(ret);
     return ret;
     } finally {
       GC.KeepAlive(key);
     }
 }

 internal int log_put(DB_LSN lsn, DatabaseEntry data, uint flags)
 {
     try {
     int ret;
     ret = libdb_csharpPINVOKE.DB_ENV_log_put(swigCPtr, DB_LSN.getCPtr(lsn), DBT.getCPtr(DatabaseEntry.getDBT(data)), flags);
     DatabaseException.ThrowException(ret);
     return ret;
     } finally {
       GC.KeepAlive(data);
     }
 }

 internal DB_LOCK lock_get(uint locker, uint flags, DatabaseEntry arg2, db_lockmode_t mode)
 {
     int err = 0;
     DB_LOCK ret = lock_get(locker, flags, arg2, mode, ref err);
     DatabaseException.ThrowException(err);
     return ret;
 }

 internal int rep_start(DatabaseEntry cdata, uint flags)
 {
     try {
     int ret;
     ret = libdb_csharpPINVOKE.DB_ENV_rep_start(swigCPtr, DBT.getCPtr(DatabaseEntry.getDBT(cdata)), flags);
     DatabaseException.ThrowException(ret);
     return ret;
     } finally {
       GC.KeepAlive(cdata);
     }
 }

 internal int rep_process_message(DatabaseEntry control, DatabaseEntry rec, int envid, DB_LSN ret_lsnp)
 {
     try {
     int ret;
     ret = libdb_csharpPINVOKE.DB_ENV_rep_process_message(swigCPtr, DBT.getCPtr(DatabaseEntry.getDBT(control)), DBT.getCPtr(DatabaseEntry.getDBT(rec)), envid, DB_LSN.getCPtr(ret_lsnp));
     DatabaseException.ThrowException(ret);
     return ret;
     } finally {
       GC.KeepAlive(control);
       GC.KeepAlive(rec);
     }
 }

 public static extern void DBT_app_data_set(HandleRef jarg1, DatabaseEntry jarg2);

 public IntelligentUpload(CloudManagerViewModel model)
 {
     this.ViewModel = model;
     this.dbEntry = new DatabaseEntry();
 }

        public void Delete(DatabaseEntry graphKey, Transaction transaction)
        {
            //Get all reverse index values for the internal id.
            var allKeysInIndex =
                reverseIndex
                    .GetMultiple(graphKey, (int)reverseIndex.Pagesize, transaction);

            //In the forward index, get all keys for each reverse index value and delete the record if the value matches
            //the internal id of the graph we are deleting.
            foreach (var cursor in
                from indexKey in allKeysInIndex.Value
                let c = index.Cursor(new CursorConfig(), transaction)
                where c.Move(indexKey, true)
                select c)
            {
                do
                {
                    if (cursor.Current.Value.Data.SequenceEqual(graphKey.Data)) cursor.Delete();
                }
                while (cursor.MoveNextDuplicate());

                cursor.Close();
            }

            reverseIndex.Delete(graphKey, transaction);
        }

 internal int put(DB_TXN txn, DatabaseEntry key, DatabaseEntry data, uint flags)
 {
     try {
     int ret;
     ret = libdb_csharpPINVOKE.DB_put(swigCPtr, DB_TXN.getCPtr(txn), DBT.getCPtr(DatabaseEntry.getDBT(key)), DBT.getCPtr(DatabaseEntry.getDBT(data)), flags);
     DatabaseException.ThrowException(ret);
     return ret;
     } finally {
       GC.KeepAlive(key);
       GC.KeepAlive(data);
     }
 }

 internal int open(DB_TXN txn, DatabaseEntry key, uint flags)
 {
     try {
     int ret;
     ret = libdb_csharpPINVOKE.DB_SEQUENCE_open(swigCPtr, DB_TXN.getCPtr(txn), DBT.getCPtr(DatabaseEntry.getDBT(key)), flags);
     if (ret != 0)
     close(0);
     DatabaseException.ThrowException(ret);
     return ret;
     } finally {
       GC.KeepAlive(key);
     }
 }

 void HandleDidAddRecord(string arg1, DatabaseEntry arg2)
 {
     Debug.LogError ("record added: " + arg2.back);
     //need to add record to prizm record group
 }

        private DatabaseEntry[] get_partition_keys(ref uint countp, ref uint sizep, ref int err)
        {
            IntPtr cPtr = libdb_csharpPINVOKE.DB_get_partition_keys(swigCPtr, ref countp, ref sizep, ref err);
            if (cPtr == IntPtr.Zero)
            return null;

            DatabaseEntry[] ret = new DatabaseEntry[countp - 1];
            IntPtr val;
            for (int i = 0; i < (countp - 1); i++) {
            val = new IntPtr((IntPtr.Size == 4 ? cPtr.ToInt32() : cPtr.ToInt64()) + i * sizep);
            ret[i] = DatabaseEntry.fromDBT(new DBT(val, false));
            }
            return ret;
        }

 internal int compact(DB_TXN txn, DatabaseEntry start, DatabaseEntry stop, DB_COMPACT cdata, uint flags, DatabaseEntry end)
 {
     try {
     int ret;
     ret = libdb_csharpPINVOKE.DB_compact(swigCPtr, DB_TXN.getCPtr(txn), DBT.getCPtr(DatabaseEntry.getDBT(start)), DBT.getCPtr(DatabaseEntry.getDBT(stop)), DB_COMPACT.getCPtr(cdata), flags, DBT.getCPtr(DatabaseEntry.getDBT(end)));
     DatabaseException.ThrowException(ret);
     return ret;
     } finally {
       GC.KeepAlive(start);
       GC.KeepAlive(stop);
       GC.KeepAlive(end);
     }
 }