} // materializeMainSchemaTable()

        private DocumentSource createDocumentSource()
        {
            Debug.WriteLine("JsonDataContext.createDocumentSource()");

            NInputStream input_stream = _resource.read();

            try
            {
                // MappingJsonFactory jsonFactory = new MappingJsonFactory();
                NJsonParser parser = new NJsonParser(input_stream); // jsonFactory.createParser(inputStream);
                logger.debug("Created JSON parser for resource: {0}", _resource);

                return(new JsonDocumentSource(parser, _resource.getName()));
            }
            catch (Exception e)
            {
                Debug.WriteLine("Unexpected error while creating JSON parser  \n    " + e.Message);
                try
                {
                    Debug.WriteLine("Trying to close input_stream");
                    FileHelper.safeClose(input_stream);
                }
                catch (Exception e1)
                {
                    throw new MetaModelException("Tried to close input_stream\n    " + e1.Message);
                }
                throw new MetaModelException("... Unexpected error while creating JSON parser  \n    " + e.Message);
            }
        } // createDocumentSource()
Esempio n. 2
0
        /**
         * Method invoked by the Java serialization framework while deserializing
         * Row instances. Since previous versions of MetaModel did not use a
         * DataSetHeader, but had a reference to a List<SelectItem>, this
         * deserialization is particularly tricky. We check if the items variable is
         * there, and if it is, we convert it to a header instead.
         *
         * @param stream
         * @throws Exception
         */
        private void readObject(Object o, NInputStream stream) // throws Exception
        {
            XmlSerializer serializer = new XmlSerializer(o.GetType());
            object        read_data  = serializer.Deserialize(stream);  //.readFields();

            FieldInfo[] fields      = read_data.GetType().GetFields();
            FieldInfo   items_field = NTypeUtils.getField(read_data.GetType(), "_items");

            NGetField get_field = new NGetField(read_data, fields);

            try
            {
                // backwards compatible deserialization, convert items to header
                Object items = items_field.GetValue(read_data);
                //@SuppressWarnings("unchecked")
                List <SelectItem>   itemsList = (List <SelectItem>)items;
                SimpleDataSetHeader header    = new SimpleDataSetHeader(itemsList);
                FieldInfo           field     = NTypeUtils.getField(GetType(), "_header");
                // field.setAccessible(true);
                field.SetValue(this, header);
            }
            catch (ArgumentException e)
            {
                // no backwards compatible deserialization needed.
                setWhileDeserializing(get_field, "_header");
            }
            setWhileDeserializing(get_field, "_values");
            setWhileDeserializing(get_field, "_styles");
        } // readObject()
        } // getLastModified()

        // @Override
        public override NInputStream read() // throws ResourceException
        {
            if (_file.isDirectory())
            {
                return(new DirectoryInputStream(_file.Path, _file.Mode, this));
            }
            NInputStream in_stream = FileHelper.getInputStream((NInputStream)_file);

            return(in_stream);
        } // read()
Esempio n. 4
0
        public NJsonParser(NInputStream input_stream)
        {
            Debug.WriteLine("new NJsonParser()");

            byte[] data = input_stream.readFile();
            _data_str = "";
            foreach (byte b in data)
            {
                _data_str += (char)b;
            }
            //parse(_data_str);
        } // constructor
Esempio n. 5
0
        } // getOutputStream()

        public static NInputStream getInputStream(NInputStream stream_arg) // throws IllegalStateException
        {
            //try
            //{
            //    return new BufferedInputStream(new FileInputStream(stream_arg));
            //}
            //catch (FileNotFoundException e)
            //{
            //    throw new InvalidOperationException(e.Message);
            //}
            //return new NInputStream(stream_arg.SafeFileHandle, FileAccess.Read);
            return(stream_arg);
        } // getInputStream()
        } // available()

        private bool openNextFile() // throws IOException
        {
            if (_currentInputStream != null)
            {
                FileHelper.safeClose(_currentInputStream);
                _currentInputStream = null;
            }
            _currentFileIndex++;
            if (_currentFileIndex >= _files.Length)
            {
                return(false);
            }

            _currentInputStream = openStream(_currentFileIndex);
            return(true);
        } // openNextFile()
Esempio n. 7
0
        } // getBufferedReader

        public static void copy(NInputStream from_stream, NOutputStream to_stream) // throws IllegalStateException
        {
            try
            {
                byte[] buffer = new byte[1024 * 32];
                int    offset = 0;
                for (int value = from_stream.Read(buffer, offset++, 1); value != -1; value = from_stream.Read(buffer, offset++, 1))
                {
                    to_stream.Write(buffer, 0, value);
                }
            }
            catch (IOException e)
            {
                throw new InvalidOperationException(e.Message);
            }
        }
        public void read(NAction <NInputStream> readCallback)
        {
            NInputStream in_stream = read();

            try
            {
                readCallback.run(in_stream);
            }
            catch (Exception e)
            {
                throw new NResourceException("Error occurred in read callback", e);
            }
            finally
            {
                FileHelper.safeClose(in_stream);
            }
        } // read()
        } // read()

        public E read <E>(NFunc <NInputStream, E> readCallback)
        {
            NInputStream in_stream = read();

            try
            {
                E result = readCallback.eval(in_stream);
                return(result);
            }
            catch (Exception e)
            {
                throw new NResourceException("Error occurred in read callback", e);
            }
            finally
            {
                FileHelper.safeClose(in_stream);
            }
        } // read()
Esempio n. 10
0
        public static void copy(Resource from_res, Resource to_res) // throws IllegalStateException
        {
            Debug.Assert(from_res.isExists());

            NInputStream in_stream = from_res.read();

            try
            {
                NOutputStream out_stream = to_res.write();
                try
                {
                    copy(in_stream, out_stream);
                }
                finally
                {
                    safeClose(out_stream);
                }
            }
            finally
            {
                safeClose(in_stream);
            }
        } // copy()
Esempio n. 11
0
        } // getInputStream()

        public static byte[] readAsBytes(NInputStream input_stream)
        {
            //ByteArrayOutputStream baos = new ByteArrayOutputStream();
            MemoryStream memory_stream = new MemoryStream();
            StreamWriter baos          = new StreamWriter(memory_stream);
            StreamReader reader        = new StreamReader(input_stream);

            try
            {
                copy(reader, baos);
            }
            finally
            {
                safeClose(input_stream);
            }
            string output_str = baos.ToString();

            byte[] result = new byte[output_str.Length];
            for (int i = 0; i < output_str.Length; i++)
            {
                result[i] = (byte)output_str[i];
            }
            return(result);
        } // readAsBytes()
 public JsonDataContext(NInputStream input_stream) : this(new FileResource(input_stream))
 {
     Debug.WriteLine("new JsonDataContext(NInputStream)");
 } // constructor
Esempio n. 13
0
        public static String readFileAsString(NInputStream in_stream, String encoding) // throws IllegalStateException
        {
            StreamReader br = getReader(in_stream, encoding);

            return(readAsString(br));
        } // readFileAsString()
Esempio n. 14
0
        } // getBufferedWriter()

        public static StreamReader getBufferedReader(NInputStream inputStream, String encoding) // throws IllegalStateException
        {
            StreamReader reader = getReader(inputStream, encoding);

            return(reader);
        } // getBufferedReader()
Esempio n. 15
0
        } // getReader()

        public static String readFileAsString(NInputStream stream_arg) // throws IllegalStateException
        {
            return(readFileAsString(stream_arg, DEFAULT_ENCODING));
        }
Esempio n. 16
0
        } // getWriter()

        //public static StreamWriter getWriter(NOutputStream file, String encoding) // throws IllegalStateException
        //{
        //    return getWriter(file, encoding, false);
        //} // getWriter()

        public static StreamReader getReader(NInputStream input_stream, String encoding_arg) // throws IllegalStateException
        {
            Encoding encoding_obj = null;

            try
            {
                if (encoding_arg == null || encoding_arg.ToLower().IndexOf("utf") != -1)
                {
                    byte[] bom = new byte[4];
                    int    unread;

                    // auto-detect byte-order-mark
                    //@SuppressWarnings("resource")
                    NInputStream pushbackInputStream = new NInputStream(input_stream.SafeFileHandle, FileAccess.Read, bom.Length);
                    int          n = pushbackInputStream.Read(bom, 0, bom.Length);

                    // Read ahead four bytes and check for BOM marks.
                    if ((bom[0] == (byte)0xEF) && (bom[1] == (byte)0xBB) && (bom[2] == (byte)0xBF))
                    {
                        encoding_arg = "UTF-8";
                        unread       = n - 3;
                        encoding_obj = Encoding.UTF8;
                    }
                    else if ((bom[0] == (byte)0xFE) && (bom[1] == (byte)0xFF))
                    {
                        encoding_arg = "UTF-16BE";
                        unread       = n - 2;
                    }
                    else if ((bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE))
                    {
                        encoding_arg = "UTF-16LE";
                        unread       = n - 2;
                    }
                    else if ((bom[0] == (byte)0x00) && (bom[1] == (byte)0x00) && (bom[2] == (byte)0xFE) &&
                             (bom[3] == (byte)0xFF))
                    {
                        encoding_arg = "UTF-32BE";
                        encoding_obj = Encoding.UTF32;
                        unread       = n - 4;
                    }
                    else if ((bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) && (bom[2] == (byte)0x00) &&
                             (bom[3] == (byte)0x00))
                    {
                        encoding_obj = Encoding.UTF32;
                        encoding_arg = "UTF-32LE";
                        unread       = n - 4;
                    }
                    else
                    {
                        unread = n;
                    }

                    if (unread > 0)
                    {
                        //pushbackInputStream.unread(bom, (n - unread), unread);
                    }
                    else if (unread < -1)
                    {
                        //pushbackInputStream.unread(bom, 0, 0);
                    }

                    input_stream = pushbackInputStream;
                }

                StreamReader inputStreamReader;
                if (encoding_arg == null)
                {
                    inputStreamReader = new StreamReader(input_stream);
                }
                else
                {
                    if (encoding_obj != null)
                    {
                        inputStreamReader = new StreamReader(input_stream, encoding_obj);
                    }
                    else
                    {
                        throw new IOException("getReader(): Encoding not available");
                    }
                }
                return(inputStreamReader);
            }
            catch (IOException e)
            {
                throw new InvalidOperationException(e.Message);
            }
        } // getReader()
Esempio n. 17
0
        } // writeStringAsFile()

        public static StreamReader getBufferedReader(NInputStream stream_arg) // throws IllegalStateException
        {
            return(getBufferedReader(stream_arg, DEFAULT_ENCODING));
        } // getBufferedReader()