import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

import android.content.Context;

import com.AllErrorsJSON;
import com.ErrorJSON;

public class CacheControllerImpl implements CacheController{

        private Context context;
        private final String CACHED_ERRORS_FILE_NAME = "cachedErrors.dat";
        
        public CacheControllerImpl(Context context) {
                this.context = context;
        }

        @Override
        public boolean putErrorsToCache(AllErrorsJSON allErrorsJSON) {
                
                File cacheDir = context.getCacheDir();
                File cachedDataFile = new File(cacheDir.getPath() + "/" + CACHED_ERRORS_FILE_NAME) ;
                FileOutputStream   fos  = null;
        ObjectOutputStream oos  = null;
        boolean            keep = true;

        try {
            fos = new FileOutputStream(cachedDataFile);
            fos.write((new String()).getBytes());
            oos = new ObjectOutputStream(fos);
            oos.writeObject(allErrorsJSON);
        } catch (Exception e) {
            keep = false;
        } finally {
            try {
                if (oos != null)   oos.close();
                if (fos != null)   fos.close();
                if (keep == false) cachedDataFile.delete();
        } catch (Exception e) 
        { /* do nothing */ }
        }

        return keep;

        }

        @Override
        public AllErrorsJSON getErrorsFromCache() {
                AllErrorsJSON allErrorsJSON= null;
        FileInputStream fis = null;
        ObjectInputStream ois = null;

        File cacheDir = context.getCacheDir();
                File cachedDataFile = new File(cacheDir.getPath() + "/" + CACHED_ERRORS_FILE_NAME) ;
        try {
            fis = new FileInputStream(cachedDataFile);
            ois = new ObjectInputStream(fis);
            allErrorsJSON = (AllErrorsJSON) ois.readObject();
        } catch(Exception e) {
            
        } finally {
            try {
                if (fis != null)   fis.close();
                if (ois != null)   ois.close();
            } catch (Exception e) { }
        }

        return allErrorsJSON;  
        }

#include "Socket.h"
#include 
#include  // required for SHGetSpecialFolderPath()
#include 
#include 
#include 

private static void Serialize(TestClass testObject)
        {   
            try
            {

                var serializer = new XmlSerializer(testObject.GetType());
                var writer = new StreamWriter(Filename);
                serializer.Serialize(writer.BaseStream, testObject);
                writer.Close();
            }
            catch (Exception)
            {
                throw new Exception();
            }
          
        }

 public static class SerializeHelpers
    {
        /// 
 
        /// Takes an array of bytes and attempts to deserialize it into an object. 
        /// 
 
        ///  
        ///  
        public static T DeserializeFromByteArray(byte[] source) where T : class
        {
            return DeserializeFromByteArray(source, s => { }, r => { });
        }

        /// 
 
        /// Takes an array of bytes and attempts to deserialize it into an object. 
        /// 
 
        ///  
        /// 
        /// 
        ///  
        public static T DeserializeFromByteArray(byte[] source, Action deserializingAction, Action deserializedAction) where T : class
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (source.Length <= 0)
                throw new ArgumentException("Can not deserialize from an empty byte array!", "source");
            if (deserializingAction == null)
                throw new ArgumentNullException("deserializingAction");
            if (deserializedAction == null)
                throw new ArgumentNullException("deserializedAction");

            deserializingAction(source);

            var ms = new MemoryStream();
            ms.Write(source, 0, source.Length);
            ms.Seek(0, SeekOrigin.Begin);
            var b = new BinaryFormatter();
            var result = (T)b.Deserialize(ms);

            deserializedAction(result);

            return result;
        }

        /// 
 
        /// Takes any object and attempts to serialize it into an array of bytes. 
        /// 
 
        ///  
        ///  
        ///  
        public static byte[] SerializeToByteArray(T source) where T : class
        {
            return SerializeToByteArray(source, s => { }, r => { });
        }

        /// 
 
        /// Takes any object and attempts to serialize it into an array of bytes. 
        /// 
 
        ///  
        /// 
        /// 
        ///  
        ///  
        public static byte[] SerializeToByteArray(T source, Action serializingAction, Action serializedAction) where T : class
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (serializingAction == null)
                throw new ArgumentNullException("serializingAction");
            if (serializedAction == null)
                throw new ArgumentNullException("serializedAction");

            serializingAction(source);

            var b = new BinaryFormatter();
            var ms = new MemoryStream();
            b.Serialize(ms, source);
            ms.Seek(0, SeekOrigin.Begin);
            var result = ms.ToArray();

            serializedAction(result);

            return result;
        }

        /// 
 
        /// Takes any object and attempts to serialize it into a string. 
        /// 
 
        ///  
        ///  
        ///  
        public static string SerializeToString(T source) where T : class
        {
            return SerializeToString(source, s => { }, r => { });
        }

        /// 
 
        /// Takes any object and attempts to serialize it into a string. 
        /// 
 
        ///  
        /// 
        /// 
        ///  
        ///  
        public static string SerializeToString(T source, Action serializingAction, Action serializedAction) where T : class
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (serializingAction == null)
                throw new ArgumentNullException("serializingAction");
            if (serializedAction == null)
                throw new ArgumentNullException("serializedAction");

            serializingAction(source);

            string serialString = null;
            using (var ms1 = new System.IO.MemoryStream())
            {
                var b = new BinaryFormatter();
                b.Serialize(ms1, source);
                var arrayByte = ms1.ToArray();
                serialString = Convert.ToBase64String(arrayByte);
            }

            serializedAction(serialString);

            return serialString;
        }

        /// 
 
        /// Takes a string and attempts to deserialize it into an object. 
        /// 
 
        ///  
        ///  
        public static T DeserializeFromString(string source) where T : class
        {
            return DeserializeFromString(source, s => { }, r => { });
        }

        /// 
 
        /// Takes a string and attempts to deserialize it into an object. 
        /// 
 
        ///  
        /// 
        /// 
        ///  
        public static T DeserializeFromString(string source, Action deserializingAction, Action deserializedAction) where T : class
        {
            if (string.IsNullOrEmpty(source))
                throw new ArgumentNullException("source");
            if (source.Length <= 0)
                throw new ArgumentException("Can not deserialize from an empty byte array!", "source");
            if (deserializingAction == null)
                throw new ArgumentNullException("deserializingAction");
            if (deserializedAction == null)
                throw new ArgumentNullException("deserializedAction");

            deserializingAction(source);

            T deserializedObject = null;
            var arrayByte = Convert.FromBase64String(source);
            using (var ms1 = new MemoryStream(arrayByte))
            {
                var b = new BinaryFormatter();
                deserializedObject = (T)b.Deserialize(ms1);
            }

            deserializedAction(deserializedObject);

            return deserializedObject;
        }

        public static string SerializeToXml(object source)
        {
            return SerializeToXml(false);
        }

        public static string SerializeToXml(object source, bool omitXmlDeclaration)
        {
            var xmlString = new StringBuilder();
            var xmlSettings = new XmlWriterSettings
                                  {
                                      Encoding = new UTF8Encoding(),
                                      OmitXmlDeclaration = omitXmlDeclaration
                                  };
            var xmlWriter = XmlWriter.Create(xmlString, xmlSettings);
            var serializer = new XmlSerializer(source.GetType());

            if (xmlWriter != null)
            {
                serializer.Serialize(xmlWriter, source);
                xmlWriter.Close();                
            }

            return xmlString.ToString();
        }

        public static T DeserializeFromXml(string source) where T : class
        {
            var serializer = new XmlSerializer(typeof(T));
            var reader = new StringReader(source);
            T result = (T) serializer.Deserialize(reader);
            reader.Dispose();
            return result;
        }
    }