/// <summary> <p>Removes all fields with the given name from the document.
/// If there is no field with the specified name, the document remains unchanged.</p>
/// <p> Note that the removeField(s) methods like the add method only make sense
/// prior to adding a document to an index. These methods cannot
/// be used to change the content of an existing index! In order to achieve this,
/// a document has to be deleted from an index and a new changed version of that
/// document has to be added.</p>
/// </summary>
public void RemoveFields(System.String name)
{
for (int i = fields.Count - 1; i >= 0; i--)
{
Field field = (Field)fields[i];
if (field.Name().Equals(name))
{
fields.RemoveAt(i);
}
}
}
/// <summary> Returns an array of bytes for the first (or only) field that has the name
/// specified as the method parameter. This method will return <code>null</code>
/// if no binary fields with the specified name are available.
/// There may be non-binary fields with the same name.
///
/// </summary>
/// <param name="name">the name of the field.
/// </param>
/// <returns> a <code>byte[]</code> containing the binary field value.
/// </returns>
public byte[] GetBinaryValue(System.String name)
{
for (int i = 0; i < fields.Count; i++)
{
Field field = (Field)fields[i];
if (field.Name().Equals(name) && (field.IsBinary()))
{
return(field.BinaryValue());
}
}
return(null);
}
/// <summary>Returns a field with the given name if any exist in this document, or
/// null. If multiple fields exists with this name, this method returns the
/// first value added.
/// </summary>
public Field GetField(System.String name)
{
for (int i = 0; i < fields.Count; i++)
{
Field field = (Field)fields[i];
if (field.Name().Equals(name))
{
return(field);
}
}
return(null);
}
/// <summary> <p>Removes field with the specified name from the document.
/// If multiple fields exist with this name, this method removes the first field that has been added.
/// If there is no field with the specified name, the document remains unchanged.</p>
/// <p> Note that the removeField(s) methods like the add method only make sense
/// prior to adding a document to an index. These methods cannot
/// be used to change the content of an existing index! In order to achieve this,
/// a document has to be deleted from an index and a new changed version of that
/// document has to be added.</p>
/// </summary>
public void RemoveField(System.String name)
{
System.Collections.IEnumerator it = fields.GetEnumerator();
while (it.MoveNext())
{
Field field = (Field)it.Current;
if (field.Name().Equals(name))
{
fields.Remove(field);
return;
}
}
}
/// <summary> Returns an array of byte arrays for of the fields that have the name specified
/// as the method parameter. This method will return <code>null</code> if no
/// binary fields with the specified name are available.
///
/// </summary>
/// <param name="name">the name of the field
/// </param>
/// <returns> a <code>byte[][]</code> of binary field values.
/// </returns>
public byte[][] GetBinaryValues(System.String name)
{
System.Collections.IList result = new System.Collections.ArrayList();
for (int i = 0; i < fields.Count; i++)
{
Field field = (Field)fields[i];
if (field.Name().Equals(name) && (field.IsBinary()))
{
byte[] byteArray = field.BinaryValue();
byte[] resultByteArray = new byte[byteArray.Length];
for (int index = 0; index < byteArray.Length; index++)
{
resultByteArray[index] = (byte)byteArray[index];
}
result.Add(resultByteArray);
}
}
if (result.Count == 0)
{
return(null);
}
System.Collections.ICollection c = result;
System.Object[] objects = new byte[result.Count][];
System.Type type = objects.GetType().GetElementType();
System.Object[] objs = (System.Object[])Array.CreateInstance(type, c.Count);
System.Collections.IEnumerator e = c.GetEnumerator();
int ii = 0;
while (e.MoveNext())
{
objs[ii++] = e.Current;
}
// If objects is smaller than c then do not return the new array in the parameter
if (objects.Length >= c.Count)
{
objs.CopyTo(objects, 0);
}
return((byte[][])objs);
}
/// <summary> Returns an array of values of the field specified as the method parameter.
/// This method can return <code>null</code>.
///
/// </summary>
/// <param name="name">the name of the field
/// </param>
/// <returns> a <code>String[]</code> of field values
/// </returns>
public System.String[] GetValues(System.String name)
{
System.Collections.ArrayList result = new System.Collections.ArrayList();
for (int i = 0; i < fields.Count; i++)
{
Field field = (Field)fields[i];
if (field.Name().Equals(name) && (!field.IsBinary()))
{
result.Add(field.StringValue());
}
}
if (result.Count == 0)
{
return(null);
}
return((System.String[])(result.ToArray(typeof(System.String))));
}
/// <summary> Returns an array of {@link Field}s with the given name.
/// This method can return <code>null</code>.
///
/// </summary>
/// <param name="name">the name of the field
/// </param>
/// <returns> a <code>Field[]</code> array
/// </returns>
public Field[] GetFields(System.String name)
{
System.Collections.ArrayList result = new System.Collections.ArrayList();
for (int i = 0; i < fields.Count; i++)
{
Field field = (Field)fields[i];
if (field.Name().Equals(name))
{
result.Add(field);
}
}
if (result.Count == 0)
{
return(null);
}
return((Field[])result.ToArray(typeof(Field)));
}
/// <summary> Returns an array of {@link Field}s with the given name.
/// Do not use with lazy loaded fields.
/// This method returns an empty array when there are no
/// matching fields. It never returns null.
///
/// </summary>
/// <param name="name">the name of the field
/// </param>
/// <returns> a <code>Field[]</code> array
/// </returns>
public Field[] GetFields(System.String name)
{
List <Field> result = new List <Field>();
for (int i = 0; i < fields.Count; i++)
{
Field field = (Field)fields[i];
if (field.Name().Equals(name))
{
result.Add(field);
}
}
if (result.Count == 0)
{
return(NO_FIELDS);
}
return(result.ToArray());
}
private static KeyValuePair<string, RavenJToken> CreateProperty(Field fld, Document document)
{
var stringValue = fld.StringValue();
if (document.GetField(fld.Name() + "_ConvertToJson") != null)
{
var val = RavenJToken.Parse(fld.StringValue()) as RavenJObject;
return new KeyValuePair<string, RavenJToken>(fld.Name(), val);
}
if (stringValue == Constants.NullValue)
stringValue = null;
if (stringValue == Constants.EmptyString)
stringValue = string.Empty;
return new KeyValuePair<string, RavenJToken>(fld.Name(), stringValue);
}
static protected Property GetPropertyFromDocument (Field f, Document doc, bool from_primary_index)
{
// Note: we don't use the document that we pass in,
// but in theory we could. At some later point we
// might need to split a property's data across two or
// more fields in the document.
if (f == null)
return null;
bool internal_prop = false;
string field_name;
field_name = f.Name ();
if (field_name.Length < 7
|| ! field_name.StartsWith ("prop:")) {
if (DumpIndexMode)
internal_prop = true;
else
return null;
}
string field_value;
field_value = f.StringValue ();
Property prop;
prop = new Property ();
if (DumpIndexMode) {
prop.Type = CodeToType ( internal_prop ? 'k' : field_name [5]);
prop.Key = (internal_prop ? field_name : field_name.Substring (7));
prop.Value = (internal_prop ? field_value : field_value.Substring (3));
} else {
prop.Type = CodeToType (field_name [5]);
prop.Key = field_name.Substring (7);
prop.Value = field_value.Substring (3);
}
prop.IsSearched = (field_value [0] == 's');
prop.IsPersistent = (field_value [1] == 'p');
prop.IsMutable = ! from_primary_index;
prop.IsStored = true; // Unstored fields cannot be retrieved
return prop;
}
private static JProperty CreateProperty(Field fld, Document document)
{
var stringValue = fld.StringValue();
if (document.GetField(fld.Name() + "_ConvertToJson") != null)
{
object val = JsonConvert.DeserializeObject(stringValue);
return new JProperty(fld.Name(), val);
}
if (stringValue == Constants.NullValue)
stringValue = null;
return new JProperty(fld.Name(), stringValue);
}
private static JProperty CreateProperty(Field fld, Document document)
{
if (document.GetField(fld.Name() + "_ConvertToJson") != null)
{
var val = JsonConvert.DeserializeObject(fld.StringValue());
return new JProperty(fld.Name(), val);
}
return new JProperty(fld.Name(), fld.StringValue());
}
// FIXME: This basically queries the value against the field
// and is really really slow!
private bool FieldIsPredicate (Field field, string value)
{
string field_name = field.Name ();
string field_value = field.StringValue ();
Console.WriteLine ("Reverse searching for '{0}' value in {1}='{2}'", value, field_name, field_value);
// Simply run the value of the property against the right analyzer
// and check if there is any match
TokenStream source = IndexingAnalyzer.TokenStream (field_name, new StringReader (field_value));
StringBuilder sb = new StringBuilder ();
try {
Lucene.Net.Analysis.Token token;
while (true) {
token = source.Next ();
if (token == null)
break;
sb.Append (token.TermText ());
sb.Append (" ");
break;
}
} finally {
try {
source.Close ();
} catch { }
}
string field_analyzed = sb.ToString ();
sb.Length = 0;
source = QueryAnalyzer.TokenStream (field_name, new StringReader (value));
try {
Lucene.Net.Analysis.Token token;
while (true) {
token = source.Next ();
if (token == null)
break;
sb.Append (token.TermText ());
sb.Append (" ");
break;
}
} finally {
try {
source.Close ();
} catch { }
}
string value_analyzed = sb.ToString ();
return field_analyzed.Contains (value_analyzed);
}
public SearchField(Field field, IndexField properties)
: this(field.Name(), properties.Caption, field.StringValue(), field.StringValue(), properties.Boost, properties.IsTitle, true, properties.Order)
{
}
public SearchField(Field field, string caption, bool isTitle)
: this(field.Name(), caption, field.StringValue(), field.StringValue(), field.GetBoost(), isTitle, true, 0)
{
}
public SearchField(Field field)
: this(field.Name(), field.Name(), field.StringValue(), field.StringValue(), field.GetBoost(), false, false, 0)
{
}