public override TokenStream tokenStream(string fieldName, java.io.Reader reader)
{
TokenStream result = new HtmlTokenizer(reader);
result = new LowerCaseFilter(result);
return(result);
}
/// <summary>
/// Constructs a new
/// <code>PushbackReader</code>
/// with
/// <code>in</code>
/// as source reader.
/// The size of the pushback buffer is set to
/// <code>size</code>
/// .
/// </summary>
/// <param name="in">the source reader.</param>
/// <param name="size">the size of the pushback buffer.</param>
/// <exception cref="System.ArgumentException">
/// if
/// <code>size</code>
/// is negative.
/// </exception>
public PushbackReader(java.io.Reader @in, int size) : base(@in)
{
if (size <= 0)
{
throw new System.ArgumentException("size <= 0");
}
buf = new char[size];
pos = size;
}
/// <summary>
/// Constructs a new
/// <code>BufferedReader</code>
/// , providing
/// <code>in</code>
/// with
/// <code>size</code>
/// characters
/// of buffer.
/// </summary>
/// <param name="in">
/// the
/// <code>InputStream</code>
/// the buffer reads from.
/// </param>
/// <param name="size">the size of buffer in characters.</param>
/// <exception cref="System.ArgumentException">
/// if
/// <code>size <= 0</code>
/// .
/// </exception>
public BufferedReader(java.io.Reader @in, int size) : base(@in)
{
if (size <= 0)
{
throw new System.ArgumentException("size <= 0");
}
this.@in = @in;
buf = new char[size];
}
public override TokenStreamInfo getStream(string fieldName, Reader reader)
{
Tokenizer tk = tokenizer.create(charStream(reader));
TokenStream ts = tk;
for (int i = 0; i < filters.Length; i++)
{
ts = filters[i].create(ts);
}
return(new TokenStreamInfo(tk, ts));
}
public virtual void setCharacterStream(java.io.Reader arg0)
{
global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
if (!IsClrObject)
{
@__env.CallVoidMethod(this.JvmHandle, global::org.xml.sax.InputSource._setCharacterStream16510, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
}
else
{
@__env.CallNonVirtualVoidMethod(this.JvmHandle, global::org.xml.sax.InputSource.staticClass, global::org.xml.sax.InputSource._setCharacterStream16510, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
}
}
void org.xmlpull.v1.XmlPullParser.setInput(java.io.Reader arg0)
{
global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
if (!IsClrObject)
{
@__env.CallVoidMethod(this.JvmHandle, global::org.xmlpull.v1.XmlPullParser_._setInput16561, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
}
else
{
@__env.CallNonVirtualVoidMethod(this.JvmHandle, global::org.xmlpull.v1.XmlPullParser_.staticClass, global::org.xmlpull.v1.XmlPullParser_._setInput16561, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
}
}
public virtual void load(java.io.Reader arg0)
{
global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
if (!IsClrObject)
{
@__env.CallVoidMethod(this.JvmHandle, global::java.util.Properties._load15606, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
}
else
{
@__env.CallNonVirtualVoidMethod(this.JvmHandle, global::java.util.Properties.staticClass, global::java.util.Properties._load15606, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
}
}
public override Reader charStream(Reader reader)
{
if (charFilters != null && charFilters.Length > 0)
{
CharStream cs = CharReader.get(reader);
for (int i = 0; i < charFilters.Length; i++)
{
cs = charFilters[i].create(cs);
}
reader = cs;
}
return(reader);
}
/// <summary>Returns the remainder of 'reader' as a string, closing it when done.</summary>
/// <remarks>Returns the remainder of 'reader' as a string, closing it when done.</remarks>
/// <exception cref="System.IO.IOException"></exception>
public static string readFully(java.io.Reader reader)
{
try
{
java.io.StringWriter writer = new java.io.StringWriter();
char[] buffer = new char[1024];
int count;
while ((count = reader.read(buffer)) != -1)
{
writer.write(buffer, 0, count);
}
return(writer.ToString());
}
finally
{
reader.close();
}
}
public override TokenStream reusableTokenStream(string fieldName, Reader reader)
{
// if (true) return tokenStream(fieldName, reader);
TokenStreamInfo tsi = (TokenStreamInfo)getPreviousTokenStream();
if (tsi != null)
{
tsi.getTokenizer().reset(charStream(reader));
// the consumer will currently call reset() on the TokenStream to hit all the filters.
// this isn't necessarily guaranteed by the APIs... but is currently done
// by lucene indexing in DocInverterPerField, and in the QueryParser
return(tsi.getTokenStream());
}
else
{
tsi = getStream(fieldName, reader);
setPreviousTokenStream(tsi);
return(tsi.getTokenStream());
}
}
internal override long GetChars(long dataIndex, char[] buffer, int bufferIndex, int length)
{
if (_s != null)
{
return(base.GetChars(dataIndex, buffer, bufferIndex, length));
}
if (_clob == null)
{
return(0);
}
if (buffer == null)
{
return(_clob.length());
}
java.io.Reader reader = _clob.getCharacterStream();
reader.skip(dataIndex);
return(reader.read(buffer, bufferIndex, length));
}
void ReadAll()
{
if (_clob != null)
{
long length = _clob.length();
if (length == 0)
{
_s = String.Empty;
}
else
{
java.io.Reader reader = _clob.getCharacterStream();
char[] charValue = new char[length];
reader.read(charValue);
if (charValue != null)
{
_s = new String(charValue);
}
}
}
}
/// <summary>
/// Resets the scanner to read from a new input stream.
/// Does not close the old reader.
///
/// All internal variables are reset, the old input stream
/// <b>cannot</b> be reused (internal buffer is discarded and lost).
/// Lexical state is set to <tt>ZZ_INITIAL</tt>.
///
/// Internal scan buffer is resized down to its initial length, if it has grown.
/// </summary>
/// <param name="reader"> the new input stream </param>
public void yyreset(java.io.Reader reader)
{
zzReader = reader;
zzAtBOL = true;
zzAtEOF = false;
zzEOFDone = false;
zzEndRead = zzStartRead = 0;
zzCurrentPos = zzMarkedPos = 0;
yyline = yychar_Renamed = yycolumn = 0;
zzLexicalState = YYINITIAL;
if (zzBuffer.Length > ZZ_BUFFERSIZE)
{
zzBuffer = new char[ZZ_BUFFERSIZE];
}
}
/// <summary>
/// Creates a new scanner
/// </summary>
/// <param name="in"> the java.io.Reader to read input from. </param>
public StandardTokenizerImpl(java.io.Reader @in)
{
this.zzReader = @in;
}
static JavaReaderWrapper NewTestSubject(java.io.Reader reader)
{
return(new JavaReaderWrapper(reader));
}
public void setInput(java.io.Reader @in)
{
throw new org.xmlpull.v1.XmlPullParserException("setInput() not supported");
}
public HtmlTokenizer(java.io.Reader input)
: base(input)
{
}
public LineNumberReader(java.io.Reader @in) : base(@in)
{
throw new System.NotImplementedException();
}
public static void parse(java.io.Reader @in, org.xml.sax.ContentHandler contentHandler
)
{
throw new System.NotImplementedException();
}
public InputSource(java.io.Reader arg0) : base(global::MonoJavaBridge.JNIEnv.ThreadEnv)
{
global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
global::MonoJavaBridge.JniLocalHandle handle = @__env.NewObject(org.xml.sax.InputSource.staticClass, global::org.xml.sax.InputSource._InputSource16515, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
Init(@__env, handle);
}
public StreamTokenizer(java.io.Reader r)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Set the character stream for this input source.
/// </summary>
public void setCharacterStream(java.io.Reader characterStream)
{
}
public Model read(java.io.Reader r, string str)
{
throw new NotImplementedException();
}
public CustomTokenizerAdapter(java.io.Reader reader) : base(reader)
{
}
/// <summary>
/// Constructs a new
/// <code>PushbackReader</code>
/// with the specified reader as
/// source. The size of the pushback buffer is set to the default value of 1
/// character.
/// </summary>
/// <param name="in">the source reader.</param>
public PushbackReader(java.io.Reader @in) : base(@in)
{
buf = new char[1];
pos = 1;
}
public static void parse(java.io.Reader arg0, org.xml.sax.ContentHandler arg1)
{
global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
@__env.CallStaticVoidMethod(android.util.Xml.staticClass, global::android.util.Xml._parse8664, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg1));
}
public BufferedReader(java.io.Reader arg0) : base(global::MonoJavaBridge.JNIEnv.ThreadEnv)
{
global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
global::MonoJavaBridge.JniLocalHandle handle = @__env.NewObject(java.io.BufferedReader.staticClass, global::java.io.BufferedReader._BufferedReader12493, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
Init(@__env, handle);
}
/// <summary>
/// Constructs a new
/// <code>BufferedReader</code>
/// , providing
/// <code>in</code>
/// with
/// <code>size</code>
/// characters
/// of buffer.
/// </summary>
/// <param name="in">
/// the
/// <code>InputStream</code>
/// the buffer reads from.
/// </param>
/// <param name="size">the size of buffer in characters.</param>
/// <exception cref="System.ArgumentException">
/// if
/// <code>size <= 0</code>
/// .
/// </exception>
public BufferedReader(java.io.Reader @in, int size) : base(@in)
{
if (size <= 0)
{
throw new System.ArgumentException("size <= 0");
}
this.@in = @in;
buf = new char[size];
}
/// <summary>
/// Constructs a new
/// <code>BufferedReader</code>
/// , providing
/// <code>in</code>
/// with a buffer
/// of 8192 characters.
/// </summary>
/// <param name="in">
/// the
/// <code>Reader</code>
/// the buffer reads from.
/// </param>
public BufferedReader(java.io.Reader @in) : this(@in, 8192)
{
}
/// <summary>
/// Constructs a new FilterReader on the Reader
/// <code>in</code>
/// .
/// </summary>
/// <param name="in">The non-null Reader to filter reads on.</param>
protected internal FilterReader(java.io.Reader @in) : base(@in)
{
this.@in = @in;
}
public InputSource(java.io.Reader r)
{
}
public static List <String> rewrite(java.io.Reader content, Uri source,
ILinkRewriter rewriter, java.io.Writer writer, bool extractImports)
{
List <String> imports = new List <string>();
CharProducer producer = CharProducer.Factory.create(content,
new InputSource(new java.net.URI(source.ToString())));
CssLexer lexer = new CssLexer(producer);
try
{
bool inImport = false;
while (lexer.hasNext())
{
Token token = lexer.next();
if (extractImports)
{
if (token.type == CssTokenType.SYMBOL && token.text.ToLower().Equals("@import"))
{
inImport = true;
continue;
}
if (inImport)
{
if (token.type == CssTokenType.URI)
{
Match matcher = urlMatcher.Match(token.text);
if (matcher.Success)
{
imports.Add(matcher.Groups[2].Value.Trim());
}
}
else if (token.type != CssTokenType.SPACE && token.type != CssTokenType.PUNCTUATION)
{
inImport = false;
}
}
if (!inImport)
{
writer.write(token.text);
}
}
else
{
if (token.type == CssTokenType.URI)
{
writer.write(rewriteLink(token, source, rewriter));
continue;
}
writer.write(token.text);
}
}
writer.flush();
}
catch (ParseException pe)
{
pe.printStackTrace();
}
catch (Exception ioe)
{
throw ioe;
}
return(imports);
}
public static void rewrite(java.io.Reader content, Uri source,
Dictionary <String, IHtmlTagTransformer> transformers, java.io.Writer writer)
{
CharProducer producer = CharProducer.Factory.create(content, new InputSource(new java.net.URI(source.ToString())));
HtmlLexer lexer = new HtmlLexer(producer);
try
{
Token lastToken = null;
Token currentTag = null;
IHtmlTagTransformer currentTransformer = null;
bool tagChanged;
while (lexer.hasNext())
{
tagChanged = false;
Token token = lexer.next() as Token;
if (token.type == HtmlTokenType.IGNORABLE)
{
continue;
}
if (token.type == HtmlTokenType.TAGBEGIN)
{
currentTag = token;
tagChanged = true;
}
if (tagChanged)
{
if (currentTransformer == null)
{
transformers.TryGetValue(currentTag.toString().Substring(1).ToLower(), out currentTransformer);
}
else
{
if (!currentTransformer.acceptNextTag(currentTag))
{
writer.write(currentTransformer.close());
transformers.TryGetValue(currentTag.toString().Substring(1).ToLower(), out currentTransformer);
}
}
}
if (currentTransformer == null)
{
writer.write(producePreTokenSeparator(token, lastToken));
writer.write(token.toString());
writer.write(producePostTokenSeparator(token, lastToken));
}
else
{
currentTransformer.accept(token, lastToken);
}
if (token.type == HtmlTokenType.TAGEND)
{
currentTag = null;
}
lastToken = token;
}
if (currentTransformer != null)
{
writer.write(currentTransformer.close());
}
writer.flush();
}
catch (Exception pe)
{
throw pe;
}
}
/// <summary>
/// Constructs a new FilterReader on the Reader
/// <code>in</code>
/// .
/// </summary>
/// <param name="in">The non-null Reader to filter reads on.</param>
protected internal FilterReader(java.io.Reader @in) : base(@in)
{
this.@in = @in;
}
